From 54cf9427521f93c4270d44d56582801c090e841f Mon Sep 17 00:00:00 2001
From: zemse <sohamzemse143@gmail.com>
Date: Sat, 20 Jun 2020 01:08:07 +0530
Subject: [PATCH 01/64] Ignore macOS .DS_Store files from git

---
 .gitignore | 1 +
 1 file changed, 1 insertion(+)

diff --git a/.gitignore b/.gitignore
index 61762d6d8..61f5693d4 100644
--- a/.gitignore
+++ b/.gitignore
@@ -14,3 +14,4 @@ examples/truffle-v4/types
 examples/truffle-v4/migrations
 examples/truffle-v5/types
 examples/truffle-v5/migrations
+.DS_Store
\ No newline at end of file

From 92c8d552544c61bf1ca11b28b1e315dacb2ce65d Mon Sep 17 00:00:00 2001
From: zemse <sohamzemse143@gmail.com>
Date: Sat, 20 Jun 2020 01:25:08 +0530
Subject: [PATCH 02/64] Duplicate ethers v4 directory

---
 packages/target-ethers-v5/.eslintrc.js        |   5 +
 packages/target-ethers-v5/LICENSE             |   8 +
 packages/target-ethers-v5/README.md           |  21 ++
 packages/target-ethers-v5/package.json        |  66 +++++
 .../target-ethers-v5/src/codegen/functions.ts |  48 ++++
 .../target-ethers-v5/src/codegen/index.ts     | 250 ++++++++++++++++++
 .../target-ethers-v5/src/codegen/types.ts     |  80 ++++++
 packages/target-ethers-v5/src/index.ts        | 128 +++++++++
 packages/target-ethers-v5/static/index.d.ts   |  17 ++
 .../target-ethers-v5/test/generation.test.ts  |  18 ++
 packages/target-ethers-v5/tsconfig.build.json |   8 +
 packages/target-ethers-v5/tsconfig.json       |   8 +
 packages/target-ethers-v5/tsconfig.types.json |   9 +
 13 files changed, 666 insertions(+)
 create mode 100644 packages/target-ethers-v5/.eslintrc.js
 create mode 100644 packages/target-ethers-v5/LICENSE
 create mode 100644 packages/target-ethers-v5/README.md
 create mode 100644 packages/target-ethers-v5/package.json
 create mode 100644 packages/target-ethers-v5/src/codegen/functions.ts
 create mode 100644 packages/target-ethers-v5/src/codegen/index.ts
 create mode 100644 packages/target-ethers-v5/src/codegen/types.ts
 create mode 100644 packages/target-ethers-v5/src/index.ts
 create mode 100644 packages/target-ethers-v5/static/index.d.ts
 create mode 100644 packages/target-ethers-v5/test/generation.test.ts
 create mode 100644 packages/target-ethers-v5/tsconfig.build.json
 create mode 100644 packages/target-ethers-v5/tsconfig.json
 create mode 100644 packages/target-ethers-v5/tsconfig.types.json

diff --git a/packages/target-ethers-v5/.eslintrc.js b/packages/target-ethers-v5/.eslintrc.js
new file mode 100644
index 000000000..3526285ae
--- /dev/null
+++ b/packages/target-ethers-v5/.eslintrc.js
@@ -0,0 +1,5 @@
+const baseConfig = require('../../.eslintrc.json')
+
+module.exports = {
+  ...baseConfig,
+}
diff --git a/packages/target-ethers-v5/LICENSE b/packages/target-ethers-v5/LICENSE
new file mode 100644
index 000000000..e17451f9b
--- /dev/null
+++ b/packages/target-ethers-v5/LICENSE
@@ -0,0 +1,8 @@
+Copyright 2020 Krzysztof Kaczor
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
diff --git a/packages/target-ethers-v5/README.md b/packages/target-ethers-v5/README.md
new file mode 100644
index 000000000..4430209fd
--- /dev/null
+++ b/packages/target-ethers-v5/README.md
@@ -0,0 +1,21 @@
+# Typechain target Ethers-v4
+
+<p align="center">
+  <img src="https://github.com/Neufund/TypeChain/blob/d82f3cc644a11e22ca8e42505c16f035e2f2555d/docs/images/typechain-logo.png?raw=true" width="300" alt="TypeChain">
+  <h3 align="center">TypeChain target Ethers-v4</h3>
+  <p align="center">🔌 TypeScript bindings for Ethers 4.x.x smartcontracts</p>
+
+  <p align="center">
+    <a href="https://circleci.com/gh/ethereum-ts/TypeChain"><img alt="Build Status" src="https://circleci.com/gh/ethereum-ts/TypeChain/tree/master.svg?style=svg"></a>
+    <a href="https://coveralls.io/github/ethereum-ts/TypeChain?branch=master"><img alt="Coverage" src="https://coveralls.io/repos/github/ethereum-ts/TypeChain/badge.svg?branch=master"></a>
+    <img alt="Downloads" src="https://img.shields.io/npm/dm/typechain.svg">
+    <a href="https://github.com/prettier/prettier"><img alt="Prettier" src="https://img.shields.io/badge/code_style-prettier-ff69b4.svg"></a>
+    <a href="/package.json"><img alt="Software License" src="https://img.shields.io/badge/license-MIT-brightgreen.svg?style=flat-square"></a>
+  </p>
+
+  <p align="center">
+    <a href="https://blog.neufund.org/introducing-typechain-typescript-bindings-for-ethereum-smart-contracts-839fc2becf22">Medium post</a> | <a href="https://www.youtube.com/watch?v=9x6AkShGkwU">DappCon Video</a>
+  </p>
+</p>
+
+## [TypeChain readme](https://github.com/ethereum-ts/TypeChain)
diff --git a/packages/target-ethers-v5/package.json b/packages/target-ethers-v5/package.json
new file mode 100644
index 000000000..893f0bd80
--- /dev/null
+++ b/packages/target-ethers-v5/package.json
@@ -0,0 +1,66 @@
+{
+  "name": "@typechain/ethers-v4",
+  "description": "🔌 TypeChain target for ethers-v4",
+  "keywords": [
+    "ethers",
+    "ethersjs",
+    "ethereum",
+    "TypeChain",
+    "TypeScript"
+  ],
+  "version": "1.0.0",
+  "license": "MIT",
+  "repository": "https://github.com/ethereum-ts/Typechain",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist/**",
+    "static/**",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "prepublishOnly": "yarn lint && yarn format && yarn test && yarn typecheck && (cd ../.. && yarn build)",
+    "start": "ts-node -T ./src/index.ts",
+    "format": "prettier --config ../../.prettierrc --ignore-path ../../.prettierignore --check \"./**/*.ts\"",
+    "format:fix": "prettier --config ../../.prettierrc --ignore-path ../../.prettierignore --write \"./**/*.ts\"",
+    "lint": "eslint --ext .ts src test",
+    "lint:fix": "yarn lint --fix",
+    "typecheck": "tsc --noEmit --incremental false --composite false && tsc --noEmit --incremental false --composite false -p tsconfig.types.json",
+    "clean": "rm -rf dist && rm -f tsconfig.build.tsbuildinfo",
+    "test": "mocha --config ../../.mocharc.js",
+    "test:fix": "yarn lint:fix && yarn format:fix && yarn test && yarn typecheck"
+  },
+  "peerDependencies": {
+    "typechain": "^2.0.0",
+    "ethers": "^4.0.0"
+  },
+  "devDependencies": {
+    "@types/chai": "^4.2.7",
+    "@types/chai-as-promised": "^7.1.2",
+    "@types/chai-subset": "^1.3.3",
+    "@types/mocha": "^5.2.7",
+    "@types/sinon": "^7.5.1",
+    "@types/sinon-chai": "^3.2.3",
+    "@typescript-eslint/eslint-plugin": "^2.25.0",
+    "@typescript-eslint/parser": "^2.12.0",
+    "chai": "^4.2.0",
+    "chai-as-promised": "^7.1.1",
+    "chai-http": "^4.3.0",
+    "chai-subset": "^1.6.0",
+    "eslint": "^6.8.0",
+    "eslint-config-typestrict": "^1.0.0",
+    "eslint-plugin-no-only-tests": "^2.4.0",
+    "eslint-plugin-sonarjs": "^0.5.0",
+    "ganache-cli": "^6.9.1",
+    "mocha": "^6.2.2",
+    "prettier": "^2.0.1",
+    "sinon": "^8.0.1",
+    "sinon-chai": "^3.3.0",
+    "ts-node": "^8.5.4",
+    "typescript": "3.9.0-beta",
+    "typechain": "^2.0.0",
+    "test-utils": "1.0.0"
+  }
+}
diff --git a/packages/target-ethers-v5/src/codegen/functions.ts b/packages/target-ethers-v5/src/codegen/functions.ts
new file mode 100644
index 000000000..83ca54360
--- /dev/null
+++ b/packages/target-ethers-v5/src/codegen/functions.ts
@@ -0,0 +1,48 @@
+import { FunctionDeclaration, isConstant, isConstantFn, FunctionDocumentation, getSignatureForFn } from 'typechain'
+import { generateInputTypes, generateOutputTypes } from './types'
+
+export function codegenFunctions(fns: FunctionDeclaration[]): string {
+  if (fns.length === 1) {
+    return generateFunction(fns[0])
+  }
+
+  return codegenForOverloadedFunctions(fns)
+}
+
+export function codegenForOverloadedFunctions(fns: FunctionDeclaration[]): string {
+  return fns.map((fn) => generateFunction(fn, `"${getSignatureForFn(fn)}"`)).join('\n')
+}
+
+function generateFunction(fn: FunctionDeclaration, overloadedName?: string): string {
+  return `
+  ${generateFunctionDocumentation(fn.documentation)}
+  ${overloadedName ?? fn.name}(${generateInputTypes(fn.inputs)}${
+    !isConstant(fn) && !isConstantFn(fn) ? 'overrides?: TransactionOverrides' : ''
+  }): Promise<${
+    fn.stateMutability === 'pure' || fn.stateMutability === 'view'
+      ? generateOutputTypes(fn.outputs)
+      : 'ContractTransaction'
+  }>;
+`
+}
+
+function generateFunctionDocumentation(doc?: FunctionDocumentation): string {
+  if (!doc) return ''
+
+  let docString = '/**'
+  if (doc.details) docString += `\n * ${doc.details}`
+  if (doc.notice) docString += `\n * ${doc.notice}`
+
+  const params = Object.entries(doc.params || {})
+  if (params.length) {
+    params.forEach(([key, value]) => {
+      docString += `\n * @param ${key} ${value}`
+    })
+  }
+
+  if (doc.return) docString += `\n * @returns ${doc.return}`
+
+  docString += '\n */'
+
+  return docString
+}
diff --git a/packages/target-ethers-v5/src/codegen/index.ts b/packages/target-ethers-v5/src/codegen/index.ts
new file mode 100644
index 000000000..160326bb4
--- /dev/null
+++ b/packages/target-ethers-v5/src/codegen/index.ts
@@ -0,0 +1,250 @@
+import { values } from 'lodash'
+import {
+  AbiParameter,
+  BytecodeWithLinkReferences,
+  Contract,
+  EventArgDeclaration,
+  EventDeclaration,
+  FunctionDeclaration,
+} from 'typechain'
+import { generateInputType, generateInputTypes } from './types'
+import { codegenFunctions } from './functions'
+
+export function codegenContractTypings(contract: Contract) {
+  const template = `
+  import { Contract, ContractTransaction, EventFilter, Signer } from "ethers";
+  import { Listener, Provider } from 'ethers/providers';
+  import { Arrayish, BigNumber, BigNumberish, Interface } from "ethers/utils";
+  import { TransactionOverrides, TypedEventDescription, TypedFunctionDescription } from ".";
+
+  interface ${contract.name}Interface extends Interface {
+    functions: {
+      ${values(contract.functions)
+        .map((v) => v[0])
+        .map(generateInterfaceFunctionDescription)
+        .join('\n')}
+    };
+
+    events: {
+      ${values(contract.events)
+        .map((v) => v[0])
+        .map(generateInterfaceEventDescription)
+        .join('\n')}
+    };
+  }
+
+  export class ${contract.name} extends Contract {
+    connect(signerOrProvider: Signer | Provider | string): ${contract.name};
+    attach(addressOrName: string): ${contract.name};
+    deployed(): Promise<${contract.name}>;
+
+    on(event: EventFilter | string, listener: Listener): ${contract.name};
+    once(event: EventFilter | string, listener: Listener): ${contract.name};
+    addListener(eventName: EventFilter | string, listener: Listener): ${contract.name};
+    removeAllListeners(eventName: EventFilter | string): ${contract.name};
+    removeListener(eventName: any, listener: Listener): ${contract.name};
+
+    interface: ${contract.name}Interface;
+
+    functions: {
+      ${values(contract.functions).map(codegenFunctions).join('\n')}
+    };
+
+    ${values(contract.functions).map(codegenFunctions).join('\n')}
+
+    filters: {
+      ${values(contract.events)
+        .map((v) => v[0])
+        .map(generateEvents)
+        .join('\n')}
+    };
+
+    estimate: {
+      ${values(contract.functions)
+        .map((v) => v[0])
+        .map(generateEstimateFunction)
+        .join('\n')}
+    };
+  }`
+
+  return template
+}
+
+export function codegenContractFactory(contract: Contract, abi: any, bytecode?: BytecodeWithLinkReferences): string {
+  const constructorArgs =
+    (contract.constructor && contract.constructor[0] ? generateInputTypes(contract.constructor[0].inputs) : '') +
+    'overrides?: TransactionOverrides'
+  const constructorArgNamesWithoutOverrides =
+    contract.constructor && contract.constructor[0] ? generateParamNames(contract.constructor[0].inputs) : ''
+  const constructorArgNames = constructorArgNamesWithoutOverrides
+    ? `${constructorArgNamesWithoutOverrides}, overrides`
+    : 'overrides'
+  if (!bytecode) return codegenAbstractContractFactory(contract, abi)
+
+  // tsc with noUnusedLocals would complain about unused imports
+  const ethersUtilsImports: string[] = []
+  if (constructorArgs.match(/\WArrayish(\W|$)/)) ethersUtilsImports.push('Arrayish')
+  if (constructorArgs.match(/\WBigNumberish(\W|$)/)) ethersUtilsImports.push('BigNumberish')
+  const ethersUtilsImportLine =
+    ethersUtilsImports.length > 0 ? `import { ${ethersUtilsImports.join(', ')} } from "ethers/utils";` : ''
+
+  return `
+  import { Contract, ContractFactory, Signer } from "ethers";
+  import { Provider } from "ethers/providers";
+  import { UnsignedTransaction } from "ethers/utils/transaction";
+  ${ethersUtilsImportLine}
+
+  import { TransactionOverrides } from ".";
+  import { ${contract.name} } from "./${contract.name}";
+
+  export class ${contract.name}Factory extends ContractFactory {
+    ${generateFactoryConstructor(contract, bytecode)}
+    deploy(${constructorArgs}): Promise<${contract.name}> {
+      return super.deploy(${constructorArgNames}) as Promise<${contract.name}>;
+    }
+    getDeployTransaction(${constructorArgs}): UnsignedTransaction {
+      return super.getDeployTransaction(${constructorArgNames});
+    };
+    attach(address: string): ${contract.name} {
+      return super.attach(address) as ${contract.name};
+    }
+    connect(signer: Signer): ${contract.name}Factory {
+      return super.connect(signer) as ${contract.name}Factory;
+    }
+    static connect(address: string, signerOrProvider: Signer | Provider): ${contract.name} {
+      return new Contract(address, _abi, signerOrProvider) as ${contract.name};
+    }
+  }
+
+  const _abi = ${JSON.stringify(abi, null, 2)};
+
+  const _bytecode = "${bytecode.bytecode}";
+
+  ${generateLibraryAddressesInterface(contract, bytecode)}
+  `
+}
+
+export function codegenAbstractContractFactory(contract: Contract, abi: any): string {
+  return `
+  import { Contract, Signer } from "ethers";
+  import { Provider } from "ethers/providers";
+
+  import { ${contract.name} } from "./${contract.name}";
+
+  export class ${contract.name}Factory {
+    static connect(address: string, signerOrProvider: Signer | Provider): ${contract.name} {
+      return new Contract(address, _abi, signerOrProvider) as ${contract.name};
+    }
+  }
+
+  const _abi = ${JSON.stringify(abi, null, 2)};
+  `
+}
+
+function generateFactoryConstructor(contract: Contract, bytecode: BytecodeWithLinkReferences): string {
+  if (!bytecode.linkReferences) {
+    return `
+    constructor(signer?: Signer) {
+      super(_abi, _bytecode, signer);
+    }
+    `
+  }
+
+  const linkRefReplacements = bytecode.linkReferences.map((linkRef) => {
+    // https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Regular_Expressions#Escaping
+    // We're using a double escape backslash, since the string will be pasted into generated code.
+    const escapedLinkRefRegex = linkRef.reference.replace(/[.*+?^${}()|[\]\\]/g, '\\\\$&')
+    const libraryKey = linkRef.name || linkRef.reference
+    return `
+      linkedBytecode = linkedBytecode.replace(
+        new RegExp("${escapedLinkRefRegex}", "g"),
+        linkLibraryAddresses["${libraryKey}"].replace(/^0x/, '').toLowerCase(),
+      );`
+  })
+
+  return `
+    constructor(linkLibraryAddresses: ${contract.name}LibraryAddresses, signer?: Signer) {
+      super(_abi, ${contract.name}Factory.linkBytecode(linkLibraryAddresses), signer);
+    }
+
+    static linkBytecode(linkLibraryAddresses: ${contract.name}LibraryAddresses): string {
+      let linkedBytecode = _bytecode;
+      ${linkRefReplacements.join('\n')}
+
+      return linkedBytecode;
+    }
+  `
+}
+
+function generateLibraryAddressesInterface(contract: Contract, bytecode: BytecodeWithLinkReferences): string {
+  if (!bytecode.linkReferences) return ''
+
+  const linkLibrariesKeys = bytecode.linkReferences.map(
+    (linkRef) => `    ["${linkRef.name || linkRef.reference}"]: string;`,
+  )
+  return `
+  export interface ${contract.name}LibraryAddresses {
+    ${linkLibrariesKeys.join('\n')}
+  };`
+}
+
+function generateEstimateFunction(fn: FunctionDeclaration): string {
+  return `
+  ${fn.name}(${generateInputTypes(fn.inputs)}): Promise<BigNumber>;
+`
+}
+
+function generateInterfaceFunctionDescription(fn: FunctionDeclaration): string {
+  return `
+  ${fn.name}: TypedFunctionDescription<{ encode(${generateParamArrayNames(fn.inputs)}: ${generateParamArrayTypes(
+    fn.inputs,
+  )}): string; }>;
+`
+}
+
+function generateParamArrayTypes(params: Array<AbiParameter>): string {
+  return `[${params.map((param) => generateInputType(param.type)).join(', ')}]`
+}
+
+function generateParamNames(params: Array<AbiParameter | EventArgDeclaration>): string {
+  return params.map((param) => param.name).join(', ')
+}
+
+function generateParamArrayNames(params: Array<AbiParameter | EventArgDeclaration>): string {
+  return `[${generateParamNames(params)}]`
+}
+
+function generateEvents(event: EventDeclaration) {
+  return `
+  ${event.name}(${generateEventTypes(event.inputs)}): EventFilter;
+`
+}
+
+function generateInterfaceEventDescription(event: EventDeclaration): string {
+  return `
+  ${event.name}: TypedEventDescription<{ encodeTopics(${generateParamArrayNames(
+    event.inputs,
+  )}: ${generateEventTopicTypes(event.inputs)}): string[]; }>;
+`
+}
+
+function generateEventTopicTypes(eventArgs: Array<EventArgDeclaration>): string {
+  return `[${eventArgs.map(generateEventArgType).join(', ')}]`
+}
+
+function generateEventTypes(eventArgs: EventArgDeclaration[]) {
+  if (eventArgs.length === 0) {
+    return ''
+  }
+  return (
+    eventArgs
+      .map((arg) => {
+        return `${arg.name}: ${generateEventArgType(arg)}`
+      })
+      .join(', ') + ', '
+  )
+}
+
+function generateEventArgType(eventArg: EventArgDeclaration): string {
+  return eventArg.isIndexed ? `${generateInputType(eventArg.type)} | null` : 'null'
+}
diff --git a/packages/target-ethers-v5/src/codegen/types.ts b/packages/target-ethers-v5/src/codegen/types.ts
new file mode 100644
index 000000000..574181f94
--- /dev/null
+++ b/packages/target-ethers-v5/src/codegen/types.ts
@@ -0,0 +1,80 @@
+import { EvmType, EvmOutputType, TupleType, AbiParameter, AbiOutputParameter } from 'typechain'
+
+export function generateInputTypes(input: Array<AbiParameter>): string {
+  if (input.length === 0) {
+    return ''
+  }
+  return (
+    input.map((input, index) => `${input.name || `arg${index}`}: ${generateInputType(input.type)}`).join(', ') + ', '
+  )
+}
+
+export function generateOutputTypes(outputs: Array<AbiOutputParameter>): string {
+  if (outputs.length === 1) {
+    return generateOutputType(outputs[0].type)
+  } else {
+    return `{
+      ${outputs.map((t) => t.name && `${t.name}: ${generateOutputType(t.type)}, `).join('')}
+      ${outputs.map((t, i) => `${i}: ${generateOutputType(t.type)}`).join(', ')}
+      }`
+  }
+}
+
+// https://docs.ethers.io/ethers.js/html/api-contract.html#types
+export function generateInputType(evmType: EvmType): string {
+  switch (evmType.type) {
+    case 'integer':
+      return 'BigNumberish'
+    case 'uinteger':
+      return 'BigNumberish'
+    case 'address':
+      return 'string'
+    case 'bytes':
+    case 'dynamic-bytes':
+      return 'Arrayish'
+    case 'array':
+      return `(${generateInputType(evmType.itemType)})[]`
+    case 'boolean':
+      return 'boolean'
+    case 'string':
+      return 'string'
+    case 'tuple':
+      return generateTupleType(evmType, generateInputType)
+  }
+}
+
+export function generateOutputType(evmType: EvmOutputType): string {
+  switch (evmType.type) {
+    case 'integer':
+    case 'uinteger':
+      return evmType.bits <= 48 ? 'number' : 'BigNumber'
+    case 'address':
+      return 'string'
+    case 'void':
+      return 'void'
+    case 'bytes':
+    case 'dynamic-bytes':
+      return 'string'
+    case 'array':
+      return `(${generateOutputType(evmType.itemType)})[]`
+    case 'boolean':
+      return 'boolean'
+    case 'string':
+      return 'string'
+    case 'tuple':
+      return generateOutputTupleType(evmType)
+  }
+}
+
+export function generateTupleType(tuple: TupleType, generator: (evmType: EvmType) => string) {
+  return '{' + tuple.components.map((component) => `${component.name}: ${generator(component.type)}`).join(',') + '}'
+}
+
+export function generateOutputTupleType(tuple: TupleType) {
+  return (
+    '{' +
+    tuple.components.map((component) => `${component.name}: ${generateOutputType(component.type)} ,`).join('\n') +
+    tuple.components.map((component, index) => `${index}: ${generateOutputType(component.type)}`).join(', ') +
+    '}'
+  )
+}
diff --git a/packages/target-ethers-v5/src/index.ts b/packages/target-ethers-v5/src/index.ts
new file mode 100644
index 000000000..2c695a4b8
--- /dev/null
+++ b/packages/target-ethers-v5/src/index.ts
@@ -0,0 +1,128 @@
+import { join, resolve } from 'path'
+import { readFileSync } from 'fs'
+import { Dictionary } from 'ts-essentials'
+import { TContext, TFileDesc, TsGeneratorPlugin } from 'ts-generator'
+import {
+  BytecodeWithLinkReferences,
+  Contract,
+  extractAbi,
+  extractBytecode,
+  extractDocumentation,
+  getFileExtension,
+  getFilename,
+  parse,
+} from 'typechain'
+
+import { codegenAbstractContractFactory, codegenContractFactory, codegenContractTypings } from './codegen'
+
+export interface IEthersCfg {
+  outDir?: string
+}
+
+const DEFAULT_OUT_PATH = './types/ethers-contracts/'
+
+export default class Ethers extends TsGeneratorPlugin {
+  name = 'Ethers'
+
+  private readonly outDirAbs: string
+  private readonly contractCache: Dictionary<{
+    abi: any
+    contract: Contract
+  }> = {}
+  private readonly bytecodeCache: Dictionary<BytecodeWithLinkReferences> = {}
+
+  constructor(ctx: TContext<IEthersCfg>) {
+    super(ctx)
+
+    const { cwd, rawConfig } = ctx
+
+    this.outDirAbs = resolve(cwd, rawConfig.outDir || DEFAULT_OUT_PATH)
+  }
+
+  transformFile(file: TFileDesc): TFileDesc[] | void {
+    const fileExt = getFileExtension(file.path)
+
+    // For json files with both ABI and bytecode, both the contract typing and factory can be
+    // generated at once. For split files (.abi and .bin) we don't know in which order they will
+    // be transformed -- so we temporarily store whichever comes first, and generate the factory
+    // only when both ABI and bytecode are present.
+
+    // TODO we might want to add a configuration switch to control whether we want to generate the
+    // factories, or just contract type declarations.
+
+    if (fileExt === '.bin') {
+      return this.transformBinFile(file)
+    }
+    return this.transformAbiOrFullJsonFile(file)
+  }
+
+  transformBinFile(file: TFileDesc): TFileDesc[] | void {
+    const name = getFilename(file.path)
+    const bytecode = extractBytecode(file.contents)
+
+    if (!bytecode) {
+      return
+    }
+
+    if (this.contractCache[name]) {
+      const { contract, abi } = this.contractCache[name]
+      delete this.contractCache[name]
+      return [this.genContractFactoryFile(contract, abi, bytecode)]
+    } else {
+      this.bytecodeCache[name] = bytecode
+    }
+  }
+
+  transformAbiOrFullJsonFile(file: TFileDesc): TFileDesc[] | void {
+    const name = getFilename(file.path)
+    const abi = extractAbi(file.contents)
+
+    if (abi.length === 0) {
+      return
+    }
+    const documentation = extractDocumentation(file.contents)
+
+    const contract = parse(abi, name, documentation)
+    const bytecode = extractBytecode(file.contents) || this.bytecodeCache[name]
+
+    if (bytecode) {
+      return [this.genContractTypingsFile(contract), this.genContractFactoryFile(contract, abi, bytecode)]
+    } else {
+      this.contractCache[name] = { abi, contract }
+      return [this.genContractTypingsFile(contract)]
+    }
+  }
+
+  genContractTypingsFile(contract: Contract): TFileDesc {
+    return {
+      path: join(this.outDirAbs, `${contract.name}.d.ts`),
+      contents: codegenContractTypings(contract),
+    }
+  }
+
+  genContractFactoryFile(contract: Contract, abi: any, bytecode?: BytecodeWithLinkReferences) {
+    return {
+      path: join(this.outDirAbs, `${contract.name}Factory.ts`),
+      contents: codegenContractFactory(contract, abi, bytecode),
+    }
+  }
+
+  afterRun(): TFileDesc[] {
+    // For each contract that doesn't have bytecode (it's either abstract, or only ABI was provided)
+    // generate a simplified factory, that allows to interact with deployed contract instances.
+    const abstractFactoryFiles = Object.keys(this.contractCache).map((contractName) => {
+      const { contract, abi } = this.contractCache[contractName]
+      return {
+        path: join(this.outDirAbs, `${contract.name}Factory.ts`),
+        contents: codegenAbstractContractFactory(contract, abi),
+      }
+    })
+    return [
+      ...abstractFactoryFiles,
+      {
+        path: join(this.outDirAbs, 'index.d.ts'),
+        contents: readFileSync(join(__dirname, '../static/index.d.ts'), 'utf-8'),
+      },
+    ]
+  }
+}
diff --git a/packages/target-ethers-v5/static/index.d.ts b/packages/target-ethers-v5/static/index.d.ts
new file mode 100644
index 000000000..d8611cbb7
--- /dev/null
+++ b/packages/target-ethers-v5/static/index.d.ts
@@ -0,0 +1,17 @@
+import { BigNumberish, EventDescription, FunctionDescription } from 'ethers/utils'
+
+export class TransactionOverrides {
+  nonce?: BigNumberish | Promise<BigNumberish>
+  gasLimit?: BigNumberish | Promise<BigNumberish>
+  gasPrice?: BigNumberish | Promise<BigNumberish>
+  value?: BigNumberish | Promise<BigNumberish>
+  chainId?: number | Promise<number>
+}
+
+export interface TypedEventDescription<T extends Pick<EventDescription, 'encodeTopics'>> extends EventDescription {
+  encodeTopics: T['encodeTopics']
+}
+
+export interface TypedFunctionDescription<T extends Pick<FunctionDescription, 'encode'>> extends FunctionDescription {
+  encode: T['encode']
+}
diff --git a/packages/target-ethers-v5/test/generation.test.ts b/packages/target-ethers-v5/test/generation.test.ts
new file mode 100644
index 000000000..91749fae0
--- /dev/null
+++ b/packages/target-ethers-v5/test/generation.test.ts
@@ -0,0 +1,18 @@
+import { expect } from 'chai'
+import { Contract } from 'typechain'
+
+import { codegenContractFactory } from '../src/codegen'
+
+describe('Ethers generation edge cases', () => {
+  const emptyContract: Contract = {
+    name: 'TestContract',
+    rawName: 'TestContract',
+    functions: {},
+    events: {},
+    constructor: [{ name: 'constructor', inputs: [], outputs: [], stateMutability: 'nonpayable' }],
+  }
+
+  it('should generate simple factory when no bytecode available', () => {
+    expect(codegenContractFactory(emptyContract, 'abi', undefined)).to.match(/export class TestContractFactory \{/)
+  })
+})
diff --git a/packages/target-ethers-v5/tsconfig.build.json b/packages/target-ethers-v5/tsconfig.build.json
new file mode 100644
index 000000000..23eb22c58
--- /dev/null
+++ b/packages/target-ethers-v5/tsconfig.build.json
@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.json",
+  "include": ["src", "static", "static"],
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src"
+  }
+}
diff --git a/packages/target-ethers-v5/tsconfig.json b/packages/target-ethers-v5/tsconfig.json
new file mode 100644
index 000000000..3f59d2ea5
--- /dev/null
+++ b/packages/target-ethers-v5/tsconfig.json
@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.json",
+  "include": ["src", "test", "static"],
+  "compilerOptions": {
+    "esModuleInterop": true,
+    "skipLibCheck": true
+  }
+}
diff --git a/packages/target-ethers-v5/tsconfig.types.json b/packages/target-ethers-v5/tsconfig.types.json
new file mode 100644
index 000000000..f9a76de17
--- /dev/null
+++ b/packages/target-ethers-v5/tsconfig.types.json
@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "include": ["types"],
+  "exclude": ["node_modules"],
+  "compilerOptions": {
+    "esModuleInterop": true,
+    "lib": ["ES2018", "DOM"],
+  }
+}

From 7c5883186366a8155e2080ae16da82e36d7f920c Mon Sep 17 00:00:00 2001
From: zemse <sohamzemse143@gmail.com>
Date: Sat, 20 Jun 2020 02:05:51 +0530
Subject: [PATCH 03/64] Add ethers v5 target to tsconfig reference path

---
 tsconfig.json | 1 +
 1 file changed, 1 insertion(+)

diff --git a/tsconfig.json b/tsconfig.json
index 87baeaf76..11ebec82b 100644
--- a/tsconfig.json
+++ b/tsconfig.json
@@ -18,5 +18,6 @@
     { "path": "./packages/target-truffle-v4/tsconfig.build.json" },
     { "path": "./packages/target-truffle-v5/tsconfig.build.json" },
     { "path": "./packages/target-ethers-v4/tsconfig.build.json" },
+    { "path": "./packages/target-ethers-v5/tsconfig.build.json" }
   ]
 }

From 3b1916cf45cc2640a8075b46e37c534dd4b0f527 Mon Sep 17 00:00:00 2001
From: zemse <sohamzemse143@gmail.com>
Date: Sat, 20 Jun 2020 02:05:56 +0530
Subject: [PATCH 04/64] Rename contract estimate to estimateGas

---
 packages/target-ethers-v5/src/codegen/index.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/target-ethers-v5/src/codegen/index.ts b/packages/target-ethers-v5/src/codegen/index.ts
index 160326bb4..dbc995037 100644
--- a/packages/target-ethers-v5/src/codegen/index.ts
+++ b/packages/target-ethers-v5/src/codegen/index.ts
@@ -59,7 +59,7 @@ export function codegenContractTypings(contract: Contract) {
         .join('\n')}
     };
 
-    estimate: {
+    estimateGas: {
       ${values(contract.functions)
         .map((v) => v[0])
         .map(generateEstimateFunction)

From ea81db91abdec107e7c2b152a80af55cd4989d1b Mon Sep 17 00:00:00 2001
From: zemse <sohamzemse143@gmail.com>
Date: Sat, 20 Jun 2020 02:28:24 +0530
Subject: [PATCH 05/64] Update Arrayish to BytesLike

---
 packages/target-ethers-v5/src/codegen/index.ts | 12 +++++-------
 packages/target-ethers-v5/src/codegen/types.ts |  2 +-
 2 files changed, 6 insertions(+), 8 deletions(-)

diff --git a/packages/target-ethers-v5/src/codegen/index.ts b/packages/target-ethers-v5/src/codegen/index.ts
index dbc995037..6522f0445 100644
--- a/packages/target-ethers-v5/src/codegen/index.ts
+++ b/packages/target-ethers-v5/src/codegen/index.ts
@@ -13,6 +13,7 @@ import { codegenFunctions } from './functions'
 export function codegenContractTypings(contract: Contract) {
   const template = `
   import { Contract, ContractTransaction, EventFilter, Signer } from "ethers";
+  import { BytesLike } from '@ethersproject/bytes';
   import { Listener, Provider } from 'ethers/providers';
   import { Arrayish, BigNumber, BigNumberish, Interface } from "ethers/utils";
   import { TransactionOverrides, TypedEventDescription, TypedFunctionDescription } from ".";
@@ -82,17 +83,14 @@ export function codegenContractFactory(contract: Contract, abi: any, bytecode?:
   if (!bytecode) return codegenAbstractContractFactory(contract, abi)
 
   // tsc with noUnusedLocals would complain about unused imports
-  const ethersUtilsImports: string[] = []
-  if (constructorArgs.match(/\WArrayish(\W|$)/)) ethersUtilsImports.push('Arrayish')
-  if (constructorArgs.match(/\WBigNumberish(\W|$)/)) ethersUtilsImports.push('BigNumberish')
-  const ethersUtilsImportLine =
-    ethersUtilsImports.length > 0 ? `import { ${ethersUtilsImports.join(', ')} } from "ethers/utils";` : ''
+  const ethersImports: string[] = ['Contract', 'ContractFactory', 'Signer']
+  if (constructorArgs.match(/\WBytesLike(\W|$)/)) ethersImports.push('BytesLike')
+  if (constructorArgs.match(/\WBigNumberish(\W|$)/)) ethersImports.push('BigNumberish')
 
   return `
-  import { Contract, ContractFactory, Signer } from "ethers";
+  import { ${ethersImports.join(', ')} } from "ethers";
   import { Provider } from "ethers/providers";
   import { UnsignedTransaction } from "ethers/utils/transaction";
-  ${ethersUtilsImportLine}
 
   import { TransactionOverrides } from ".";
   import { ${contract.name} } from "./${contract.name}";
diff --git a/packages/target-ethers-v5/src/codegen/types.ts b/packages/target-ethers-v5/src/codegen/types.ts
index 574181f94..8a0542477 100644
--- a/packages/target-ethers-v5/src/codegen/types.ts
+++ b/packages/target-ethers-v5/src/codegen/types.ts
@@ -31,7 +31,7 @@ export function generateInputType(evmType: EvmType): string {
       return 'string'
     case 'bytes':
     case 'dynamic-bytes':
-      return 'Arrayish'
+      return 'BytesLike'
     case 'array':
       return `(${generateInputType(evmType.itemType)})[]`
     case 'boolean':

From b8b0bdfe598d1effe277859c19f72a793a4d9c5b Mon Sep 17 00:00:00 2001
From: zemse <sohamzemse143@gmail.com>
Date: Sat, 20 Jun 2020 03:12:45 +0530
Subject: [PATCH 06/64] Update imports from ethers v5

---
 .../target-ethers-v5/src/codegen/functions.ts |  2 +-
 .../target-ethers-v5/src/codegen/index.ts     | 20 +++++++++----------
 2 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/packages/target-ethers-v5/src/codegen/functions.ts b/packages/target-ethers-v5/src/codegen/functions.ts
index 83ca54360..5c9ecb039 100644
--- a/packages/target-ethers-v5/src/codegen/functions.ts
+++ b/packages/target-ethers-v5/src/codegen/functions.ts
@@ -17,7 +17,7 @@ function generateFunction(fn: FunctionDeclaration, overloadedName?: string): str
   return `
   ${generateFunctionDocumentation(fn.documentation)}
   ${overloadedName ?? fn.name}(${generateInputTypes(fn.inputs)}${
-    !isConstant(fn) && !isConstantFn(fn) ? 'overrides?: TransactionOverrides' : ''
+    !isConstant(fn) && !isConstantFn(fn) ? 'overrides?: Overrides' : ''
   }): Promise<${
     fn.stateMutability === 'pure' || fn.stateMutability === 'view'
       ? generateOutputTypes(fn.outputs)
diff --git a/packages/target-ethers-v5/src/codegen/index.ts b/packages/target-ethers-v5/src/codegen/index.ts
index 6522f0445..1503cdc39 100644
--- a/packages/target-ethers-v5/src/codegen/index.ts
+++ b/packages/target-ethers-v5/src/codegen/index.ts
@@ -12,13 +12,13 @@ import { codegenFunctions } from './functions'
 
 export function codegenContractTypings(contract: Contract) {
   const template = `
-  import { Contract, ContractTransaction, EventFilter, Signer } from "ethers";
+  import { EventFilter, Signer, BigNumber, BigNumberish } from 'ethers';
+  import { Contract, ContractTransaction, Overrides } from '@ethersproject/contracts';
   import { BytesLike } from '@ethersproject/bytes';
-  import { Listener, Provider } from 'ethers/providers';
-  import { Arrayish, BigNumber, BigNumberish, Interface } from "ethers/utils";
-  import { TransactionOverrides, TypedEventDescription, TypedFunctionDescription } from ".";
+  import { Listener, Provider } from '@ethersproject/providers';
+  import { TypedEventDescription, TypedFunctionDescription } from ".";
 
-  interface ${contract.name}Interface extends Interface {
+  interface ${contract.name}Interface extends ethers.utils.Interface {
     functions: {
       ${values(contract.functions)
         .map((v) => v[0])
@@ -74,7 +74,7 @@ export function codegenContractTypings(contract: Contract) {
 export function codegenContractFactory(contract: Contract, abi: any, bytecode?: BytecodeWithLinkReferences): string {
   const constructorArgs =
     (contract.constructor && contract.constructor[0] ? generateInputTypes(contract.constructor[0].inputs) : '') +
-    'overrides?: TransactionOverrides'
+    'overrides?: Overrides'
   const constructorArgNamesWithoutOverrides =
     contract.constructor && contract.constructor[0] ? generateParamNames(contract.constructor[0].inputs) : ''
   const constructorArgNames = constructorArgNamesWithoutOverrides
@@ -83,16 +83,16 @@ export function codegenContractFactory(contract: Contract, abi: any, bytecode?:
   if (!bytecode) return codegenAbstractContractFactory(contract, abi)
 
   // tsc with noUnusedLocals would complain about unused imports
-  const ethersImports: string[] = ['Contract', 'ContractFactory', 'Signer']
+  const ethersImports: string[] = ['Signer']
   if (constructorArgs.match(/\WBytesLike(\W|$)/)) ethersImports.push('BytesLike')
   if (constructorArgs.match(/\WBigNumberish(\W|$)/)) ethersImports.push('BigNumberish')
 
   return `
   import { ${ethersImports.join(', ')} } from "ethers";
-  import { Provider } from "ethers/providers";
-  import { UnsignedTransaction } from "ethers/utils/transaction";
+  import { Provider } from '@ethersproject/providers';
+  import { UnsignedTransaction } from '@ethersproject/transactions';
+  import { Contract, ContractFactory, Overrides } from "@ethersproject/contracts";
 
-  import { TransactionOverrides } from ".";
   import { ${contract.name} } from "./${contract.name}";
 
   export class ${contract.name}Factory extends ContractFactory {

From e383c4d0725817c47bc8b50ada3ab1ae62fa85e0 Mon Sep 17 00:00:00 2001
From: zemse <sohamzemse143@gmail.com>
Date: Sat, 20 Jun 2020 03:36:43 +0530
Subject: [PATCH 07/64] Replace interface events and function fragments

---
 .../target-ethers-v5/src/codegen/index.ts     | 25 ++++++++++---------
 1 file changed, 13 insertions(+), 12 deletions(-)

diff --git a/packages/target-ethers-v5/src/codegen/index.ts b/packages/target-ethers-v5/src/codegen/index.ts
index 1503cdc39..a13b1f36d 100644
--- a/packages/target-ethers-v5/src/codegen/index.ts
+++ b/packages/target-ethers-v5/src/codegen/index.ts
@@ -12,11 +12,11 @@ import { codegenFunctions } from './functions'
 
 export function codegenContractTypings(contract: Contract) {
   const template = `
-  import { EventFilter, Signer, BigNumber, BigNumberish } from 'ethers';
+  import { ethers, EventFilter, Signer, BigNumber, BigNumberish } from 'ethers';
   import { Contract, ContractTransaction, Overrides } from '@ethersproject/contracts';
   import { BytesLike } from '@ethersproject/bytes';
   import { Listener, Provider } from '@ethersproject/providers';
-  import { TypedEventDescription, TypedFunctionDescription } from ".";
+  import { FunctionFragment, EventFragment } from '@ethersproject/abi';
 
   interface ${contract.name}Interface extends ethers.utils.Interface {
     functions: {
@@ -193,11 +193,12 @@ function generateEstimateFunction(fn: FunctionDeclaration): string {
 }
 
 function generateInterfaceFunctionDescription(fn: FunctionDeclaration): string {
-  return `
-  ${fn.name}: TypedFunctionDescription<{ encode(${generateParamArrayNames(fn.inputs)}: ${generateParamArrayTypes(
-    fn.inputs,
-  )}): string; }>;
-`
+  // console.log(fn.name, fn.inputs)
+  return `'${generateFunctionSignature(fn)}': FunctionFragment;`
+}
+
+function generateFunctionSignature(fn: FunctionDeclaration): string {
+  return `${fn.name}(${fn.inputs.map((input: any) => input.type.originalType).join(',')})`
 }
 
 function generateParamArrayTypes(params: Array<AbiParameter>): string {
@@ -219,11 +220,11 @@ function generateEvents(event: EventDeclaration) {
 }
 
 function generateInterfaceEventDescription(event: EventDeclaration): string {
-  return `
-  ${event.name}: TypedEventDescription<{ encodeTopics(${generateParamArrayNames(
-    event.inputs,
-  )}: ${generateEventTopicTypes(event.inputs)}): string[]; }>;
-`
+  return `'${generateEventSignature(event)}': EventFragment;`
+}
+
+function generateEventSignature(event: EventDeclaration): string {
+  return `${event.name}(${event.inputs.map((input: any) => input.type.originalType).join(',')})`
 }
 
 function generateEventTopicTypes(eventArgs: Array<EventArgDeclaration>): string {

From 3412c1c13b5fc6e6ad0f3992a6c324815007c923 Mon Sep 17 00:00:00 2001
From: zemse <sohamzemse143@gmail.com>
Date: Sat, 20 Jun 2020 03:45:29 +0530
Subject: [PATCH 08/64] Update getDeployTransaction signature

---
 packages/target-ethers-v5/src/codegen/index.ts | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/packages/target-ethers-v5/src/codegen/index.ts b/packages/target-ethers-v5/src/codegen/index.ts
index a13b1f36d..9e1ad3f7f 100644
--- a/packages/target-ethers-v5/src/codegen/index.ts
+++ b/packages/target-ethers-v5/src/codegen/index.ts
@@ -89,8 +89,7 @@ export function codegenContractFactory(contract: Contract, abi: any, bytecode?:
 
   return `
   import { ${ethersImports.join(', ')} } from "ethers";
-  import { Provider } from '@ethersproject/providers';
-  import { UnsignedTransaction } from '@ethersproject/transactions';
+  import { Provider, TransactionRequest } from '@ethersproject/providers';
   import { Contract, ContractFactory, Overrides } from "@ethersproject/contracts";
 
   import { ${contract.name} } from "./${contract.name}";
@@ -100,7 +99,7 @@ export function codegenContractFactory(contract: Contract, abi: any, bytecode?:
     deploy(${constructorArgs}): Promise<${contract.name}> {
       return super.deploy(${constructorArgNames}) as Promise<${contract.name}>;
     }
-    getDeployTransaction(${constructorArgs}): UnsignedTransaction {
+    getDeployTransaction(${constructorArgs}): TransactionRequest {
       return super.getDeployTransaction(${constructorArgNames});
     };
     attach(address: string): ${contract.name} {

From 1eeffb739bc9cd122af0dcf0c6685956ce3e717e Mon Sep 17 00:00:00 2001
From: zemse <sohamzemse143@gmail.com>
Date: Sat, 20 Jun 2020 04:00:32 +0530
Subject: [PATCH 09/64] Update Contract self return on helper methods

---
 packages/target-ethers-v5/src/codegen/index.ts | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/packages/target-ethers-v5/src/codegen/index.ts b/packages/target-ethers-v5/src/codegen/index.ts
index 9e1ad3f7f..185cdec1b 100644
--- a/packages/target-ethers-v5/src/codegen/index.ts
+++ b/packages/target-ethers-v5/src/codegen/index.ts
@@ -35,15 +35,15 @@ export function codegenContractTypings(contract: Contract) {
   }
 
   export class ${contract.name} extends Contract {
-    connect(signerOrProvider: Signer | Provider | string): ${contract.name};
-    attach(addressOrName: string): ${contract.name};
-    deployed(): Promise<${contract.name}>;
-
-    on(event: EventFilter | string, listener: Listener): ${contract.name};
-    once(event: EventFilter | string, listener: Listener): ${contract.name};
-    addListener(eventName: EventFilter | string, listener: Listener): ${contract.name};
-    removeAllListeners(eventName: EventFilter | string): ${contract.name};
-    removeListener(eventName: any, listener: Listener): ${contract.name};
+    connect(signerOrProvider: Signer | Provider | string): this;
+    attach(addressOrName: string): this;
+    deployed(): Promise<this>;
+
+    on(event: EventFilter | string, listener: Listener): this;
+    once(event: EventFilter | string, listener: Listener): this;
+    addListener(eventName: EventFilter | string, listener: Listener): this;
+    removeAllListeners(eventName: EventFilter | string): this;
+    removeListener(eventName: any, listener: Listener): this;
 
     interface: ${contract.name}Interface;
 

From 22b3dbd4d86571e779c720b87e01a896a28b9f14 Mon Sep 17 00:00:00 2001
From: zemse <sohamzemse143@gmail.com>
Date: Sat, 20 Jun 2020 04:06:15 +0530
Subject: [PATCH 10/64] Remove index.d.ts static file

---
 packages/target-ethers-v5/src/index.ts      |  8 +-------
 packages/target-ethers-v5/static/index.d.ts | 17 -----------------
 2 files changed, 1 insertion(+), 24 deletions(-)
 delete mode 100644 packages/target-ethers-v5/static/index.d.ts

diff --git a/packages/target-ethers-v5/src/index.ts b/packages/target-ethers-v5/src/index.ts
index 2c695a4b8..541c3a49a 100644
--- a/packages/target-ethers-v5/src/index.ts
+++ b/packages/target-ethers-v5/src/index.ts
@@ -117,12 +117,6 @@ export default class Ethers extends TsGeneratorPlugin {
         contents: codegenAbstractContractFactory(contract, abi),
       }
     })
-    return [
-      ...abstractFactoryFiles,
-      {
-        path: join(this.outDirAbs, 'index.d.ts'),
-        contents: readFileSync(join(__dirname, '../static/index.d.ts'), 'utf-8'),
-      },
-    ]
+    return abstractFactoryFiles
   }
 }
diff --git a/packages/target-ethers-v5/static/index.d.ts b/packages/target-ethers-v5/static/index.d.ts
deleted file mode 100644
index d8611cbb7..000000000
--- a/packages/target-ethers-v5/static/index.d.ts
+++ /dev/null
@@ -1,17 +0,0 @@
-import { BigNumberish, EventDescription, FunctionDescription } from 'ethers/utils'
-
-export class TransactionOverrides {
-  nonce?: BigNumberish | Promise<BigNumberish>
-  gasLimit?: BigNumberish | Promise<BigNumberish>
-  gasPrice?: BigNumberish | Promise<BigNumberish>
-  value?: BigNumberish | Promise<BigNumberish>
-  chainId?: number | Promise<number>
-}
-
-export interface TypedEventDescription<T extends Pick<EventDescription, 'encodeTopics'>> extends EventDescription {
-  encodeTopics: T['encodeTopics']
-}
-
-export interface TypedFunctionDescription<T extends Pick<FunctionDescription, 'encode'>> extends FunctionDescription {
-  encode: T['encode']
-}

From e755f8640f4590870923f86dd75229d24fa28369 Mon Sep 17 00:00:00 2001
From: zemse <sohamzemse143@gmail.com>
Date: Sat, 20 Jun 2020 20:22:15 +0530
Subject: [PATCH 11/64] Rename Factory file suffix to Contract

---
 packages/target-ethers-v5/src/index.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/packages/target-ethers-v5/src/index.ts b/packages/target-ethers-v5/src/index.ts
index 541c3a49a..dd0370d60 100644
--- a/packages/target-ethers-v5/src/index.ts
+++ b/packages/target-ethers-v5/src/index.ts
@@ -102,7 +102,7 @@ export default class Ethers extends TsGeneratorPlugin {
 
   genContractFactoryFile(contract: Contract, abi: any, bytecode?: BytecodeWithLinkReferences) {
     return {
-      path: join(this.outDirAbs, `${contract.name}Factory.ts`),
+      path: join(this.outDirAbs, `${contract.name}Contract.ts`),
       contents: codegenContractFactory(contract, abi, bytecode),
     }
   }
@@ -113,7 +113,7 @@ export default class Ethers extends TsGeneratorPlugin {
     const abstractFactoryFiles = Object.keys(this.contractCache).map((contractName) => {
       const { contract, abi } = this.contractCache[contractName]
       return {
-        path: join(this.outDirAbs, `${contract.name}Factory.ts`),
+        path: join(this.outDirAbs, `${contract.name}Contract.ts`),
         contents: codegenAbstractContractFactory(contract, abi),
       }
     })

From 04c067805e1aeee6510883a9509b9a0c57026d27 Mon Sep 17 00:00:00 2001
From: zemse <sohamzemse143@gmail.com>
Date: Sat, 20 Jun 2020 20:23:27 +0530
Subject: [PATCH 12/64] Export an existing contract constructor

---
 packages/target-ethers-v5/src/codegen/index.ts | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/packages/target-ethers-v5/src/codegen/index.ts b/packages/target-ethers-v5/src/codegen/index.ts
index 185cdec1b..ac17c5a57 100644
--- a/packages/target-ethers-v5/src/codegen/index.ts
+++ b/packages/target-ethers-v5/src/codegen/index.ts
@@ -92,7 +92,13 @@ export function codegenContractFactory(contract: Contract, abi: any, bytecode?:
   import { Provider, TransactionRequest } from '@ethersproject/providers';
   import { Contract, ContractFactory, Overrides } from "@ethersproject/contracts";
 
-  import { ${contract.name} } from "./${contract.name}";
+  import { ${contract.name} as _${contract.name} } from "./${contract.name}";
+
+  export class ${contract.name} extends _${contract.name} {
+    constructor(addressOrName: string, signerOrProvider?: Signer | Provider | undefined) {
+      super(addressOrName, _abi, signerOrProvider);
+    }
+  }
 
   export class ${contract.name}Factory extends ContractFactory {
     ${generateFactoryConstructor(contract, bytecode)}

From 8fa1ea7676416f75540ad63d69a9c754f8f230ed Mon Sep 17 00:00:00 2001
From: zemse <sohamzemse143@gmail.com>
Date: Sat, 20 Jun 2020 20:51:08 +0530
Subject: [PATCH 13/64] Fix PayableOverrides if payable constructor

---
 packages/target-ethers-v5/src/codegen/index.ts | 11 +++++++++--
 1 file changed, 9 insertions(+), 2 deletions(-)

diff --git a/packages/target-ethers-v5/src/codegen/index.ts b/packages/target-ethers-v5/src/codegen/index.ts
index ac17c5a57..78b7053b6 100644
--- a/packages/target-ethers-v5/src/codegen/index.ts
+++ b/packages/target-ethers-v5/src/codegen/index.ts
@@ -74,7 +74,7 @@ export function codegenContractTypings(contract: Contract) {
 export function codegenContractFactory(contract: Contract, abi: any, bytecode?: BytecodeWithLinkReferences): string {
   const constructorArgs =
     (contract.constructor && contract.constructor[0] ? generateInputTypes(contract.constructor[0].inputs) : '') +
-    'overrides?: Overrides'
+    `overrides?: ${contract.constructor[0]?.stateMutability === 'payable' ? 'PayableOverrides' : 'Overrides'}`
   const constructorArgNamesWithoutOverrides =
     contract.constructor && contract.constructor[0] ? generateParamNames(contract.constructor[0].inputs) : ''
   const constructorArgNames = constructorArgNamesWithoutOverrides
@@ -87,10 +87,17 @@ export function codegenContractFactory(contract: Contract, abi: any, bytecode?:
   if (constructorArgs.match(/\WBytesLike(\W|$)/)) ethersImports.push('BytesLike')
   if (constructorArgs.match(/\WBigNumberish(\W|$)/)) ethersImports.push('BigNumberish')
 
+  const ethersContractImports: string[] = ['Contract', 'ContractFactory']
+  if (constructorArgs.match(/\WPayableOverrides(\W|$)/)) {
+    ethersContractImports.push('PayableOverrides')
+  } else {
+    ethersContractImports.push('Overrides')
+  }
+
   return `
   import { ${ethersImports.join(', ')} } from "ethers";
   import { Provider, TransactionRequest } from '@ethersproject/providers';
-  import { Contract, ContractFactory, Overrides } from "@ethersproject/contracts";
+  import { ${ethersContractImports.join(', ')} } from "@ethersproject/contracts";
 
   import { ${contract.name} as _${contract.name} } from "./${contract.name}";
 

From c759bad6daa47b50a22ebfad1ae7f251ac973e19 Mon Sep 17 00:00:00 2001
From: zemse <sohamzemse143@gmail.com>
Date: Sat, 20 Jun 2020 21:01:37 +0530
Subject: [PATCH 14/64] Fix PayableOverrides if payable contract method

---
 packages/target-ethers-v5/src/codegen/functions.ts | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/packages/target-ethers-v5/src/codegen/functions.ts b/packages/target-ethers-v5/src/codegen/functions.ts
index 5c9ecb039..ba5b8cfe4 100644
--- a/packages/target-ethers-v5/src/codegen/functions.ts
+++ b/packages/target-ethers-v5/src/codegen/functions.ts
@@ -13,11 +13,15 @@ export function codegenForOverloadedFunctions(fns: FunctionDeclaration[]): strin
   return fns.map((fn) => generateFunction(fn, `"${getSignatureForFn(fn)}"`)).join('\n')
 }
 
+function isPayable(fn: FunctionDeclaration): boolean {
+  return fn.stateMutability === 'payable'
+}
+
 function generateFunction(fn: FunctionDeclaration, overloadedName?: string): string {
   return `
   ${generateFunctionDocumentation(fn.documentation)}
   ${overloadedName ?? fn.name}(${generateInputTypes(fn.inputs)}${
-    !isConstant(fn) && !isConstantFn(fn) ? 'overrides?: Overrides' : ''
+    !isConstant(fn) && !isConstantFn(fn) ? `overrides?: ${isPayable(fn) ? 'PayableOverrides' : 'Overrides'}` : ''
   }): Promise<${
     fn.stateMutability === 'pure' || fn.stateMutability === 'view'
       ? generateOutputTypes(fn.outputs)

From 865d89c3f3649e0e36df27f4f7763b14c63fa27f Mon Sep 17 00:00:00 2001
From: zemse <sohamzemse143@gmail.com>
Date: Sat, 20 Jun 2020 21:15:31 +0530
Subject: [PATCH 15/64] Add populateTransaction

---
 packages/target-ethers-v5/src/codegen/index.ts | 18 +++++++++++++-----
 1 file changed, 13 insertions(+), 5 deletions(-)

diff --git a/packages/target-ethers-v5/src/codegen/index.ts b/packages/target-ethers-v5/src/codegen/index.ts
index 78b7053b6..cb4c29fa6 100644
--- a/packages/target-ethers-v5/src/codegen/index.ts
+++ b/packages/target-ethers-v5/src/codegen/index.ts
@@ -12,7 +12,7 @@ import { codegenFunctions } from './functions'
 
 export function codegenContractTypings(contract: Contract) {
   const template = `
-  import { ethers, EventFilter, Signer, BigNumber, BigNumberish } from 'ethers';
+  import { ethers, EventFilter, Signer, BigNumber, BigNumberish, PopulatedTransaction } from 'ethers';
   import { Contract, ContractTransaction, Overrides } from '@ethersproject/contracts';
   import { BytesLike } from '@ethersproject/bytes';
   import { Listener, Provider } from '@ethersproject/providers';
@@ -66,6 +66,13 @@ export function codegenContractTypings(contract: Contract) {
         .map(generateEstimateFunction)
         .join('\n')}
     };
+
+    populateTransaction: {
+      ${values(contract.functions)
+        .map((v) => v[0])
+        .map(generatePopulateTransactionFunction)
+        .join('\n')}
+    };
   }`
 
   return template
@@ -199,13 +206,14 @@ function generateLibraryAddressesInterface(contract: Contract, bytecode: Bytecod
 }
 
 function generateEstimateFunction(fn: FunctionDeclaration): string {
-  return `
-  ${fn.name}(${generateInputTypes(fn.inputs)}): Promise<BigNumber>;
-`
+  return `${fn.name}(${generateInputTypes(fn.inputs)}): Promise<BigNumber>;`
+}
+
+function generatePopulateTransactionFunction(fn: FunctionDeclaration): string {
+  return `${fn.name}(${generateInputTypes(fn.inputs)}): Promise<PopulatedTransaction>;`
 }
 
 function generateInterfaceFunctionDescription(fn: FunctionDeclaration): string {
-  // console.log(fn.name, fn.inputs)
   return `'${generateFunctionSignature(fn)}': FunctionFragment;`
 }
 

From abe42154f21adab031e11a5122eea3661c10507b Mon Sep 17 00:00:00 2001
From: zemse <sohamzemse143@gmail.com>
Date: Sat, 20 Jun 2020 21:45:37 +0530
Subject: [PATCH 16/64] Fix functions Result obj (ethers-io/ethers.js#869)

---
 packages/target-ethers-v5/src/codegen/functions.ts | 14 +++++++-------
 packages/target-ethers-v5/src/codegen/index.ts     |  4 ++--
 packages/target-ethers-v5/src/codegen/types.ts     |  4 ++--
 3 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/packages/target-ethers-v5/src/codegen/functions.ts b/packages/target-ethers-v5/src/codegen/functions.ts
index ba5b8cfe4..9be6566ac 100644
--- a/packages/target-ethers-v5/src/codegen/functions.ts
+++ b/packages/target-ethers-v5/src/codegen/functions.ts
@@ -1,30 +1,30 @@
 import { FunctionDeclaration, isConstant, isConstantFn, FunctionDocumentation, getSignatureForFn } from 'typechain'
 import { generateInputTypes, generateOutputTypes } from './types'
 
-export function codegenFunctions(fns: FunctionDeclaration[]): string {
+export function codegenFunctions(returnResultObject: boolean, fns: FunctionDeclaration[]): string {
   if (fns.length === 1) {
-    return generateFunction(fns[0])
+    return generateFunction(returnResultObject, fns[0])
   }
 
-  return codegenForOverloadedFunctions(fns)
+  return codegenForOverloadedFunctions(returnResultObject, fns)
 }
 
-export function codegenForOverloadedFunctions(fns: FunctionDeclaration[]): string {
-  return fns.map((fn) => generateFunction(fn, `"${getSignatureForFn(fn)}"`)).join('\n')
+export function codegenForOverloadedFunctions(returnResultObject: boolean, fns: FunctionDeclaration[]): string {
+  return fns.map((fn) => generateFunction(returnResultObject, fn, `"${getSignatureForFn(fn)}"`)).join('\n')
 }
 
 function isPayable(fn: FunctionDeclaration): boolean {
   return fn.stateMutability === 'payable'
 }
 
-function generateFunction(fn: FunctionDeclaration, overloadedName?: string): string {
+function generateFunction(returnResultObject: boolean, fn: FunctionDeclaration, overloadedName?: string): string {
   return `
   ${generateFunctionDocumentation(fn.documentation)}
   ${overloadedName ?? fn.name}(${generateInputTypes(fn.inputs)}${
     !isConstant(fn) && !isConstantFn(fn) ? `overrides?: ${isPayable(fn) ? 'PayableOverrides' : 'Overrides'}` : ''
   }): Promise<${
     fn.stateMutability === 'pure' || fn.stateMutability === 'view'
-      ? generateOutputTypes(fn.outputs)
+      ? generateOutputTypes(returnResultObject, fn.outputs)
       : 'ContractTransaction'
   }>;
 `
diff --git a/packages/target-ethers-v5/src/codegen/index.ts b/packages/target-ethers-v5/src/codegen/index.ts
index cb4c29fa6..6c341757d 100644
--- a/packages/target-ethers-v5/src/codegen/index.ts
+++ b/packages/target-ethers-v5/src/codegen/index.ts
@@ -48,10 +48,10 @@ export function codegenContractTypings(contract: Contract) {
     interface: ${contract.name}Interface;
 
     functions: {
-      ${values(contract.functions).map(codegenFunctions).join('\n')}
+      ${values(contract.functions).map(codegenFunctions.bind(null, true)).join('\n')}
     };
 
-    ${values(contract.functions).map(codegenFunctions).join('\n')}
+    ${values(contract.functions).map(codegenFunctions.bind(null, false)).join('\n')}
 
     filters: {
       ${values(contract.events)
diff --git a/packages/target-ethers-v5/src/codegen/types.ts b/packages/target-ethers-v5/src/codegen/types.ts
index 8a0542477..d3ad78c67 100644
--- a/packages/target-ethers-v5/src/codegen/types.ts
+++ b/packages/target-ethers-v5/src/codegen/types.ts
@@ -9,8 +9,8 @@ export function generateInputTypes(input: Array<AbiParameter>): string {
   )
 }
 
-export function generateOutputTypes(outputs: Array<AbiOutputParameter>): string {
-  if (outputs.length === 1) {
+export function generateOutputTypes(returnResultObject: boolean, outputs: Array<AbiOutputParameter>): string {
+  if (!returnResultObject && outputs.length === 1) {
     return generateOutputType(outputs[0].type)
   } else {
     return `{

From 6805bf4cebcfea670cf2f317c87bb9cf64c0c6e9 Mon Sep 17 00:00:00 2001
From: zemse <sohamzemse143@gmail.com>
Date: Sat, 20 Jun 2020 22:06:50 +0530
Subject: [PATCH 17/64] Add CallOverrides optional param for constant fns

---
 packages/target-ethers-v5/src/codegen/functions.ts | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/packages/target-ethers-v5/src/codegen/functions.ts b/packages/target-ethers-v5/src/codegen/functions.ts
index 9be6566ac..0c85e8055 100644
--- a/packages/target-ethers-v5/src/codegen/functions.ts
+++ b/packages/target-ethers-v5/src/codegen/functions.ts
@@ -21,7 +21,9 @@ function generateFunction(returnResultObject: boolean, fn: FunctionDeclaration,
   return `
   ${generateFunctionDocumentation(fn.documentation)}
   ${overloadedName ?? fn.name}(${generateInputTypes(fn.inputs)}${
-    !isConstant(fn) && !isConstantFn(fn) ? `overrides?: ${isPayable(fn) ? 'PayableOverrides' : 'Overrides'}` : ''
+    !isConstant(fn) && !isConstantFn(fn)
+      ? `overrides?: ${isPayable(fn) ? 'PayableOverrides' : 'Overrides'}`
+      : 'overrides?: CallOverrides'
   }): Promise<${
     fn.stateMutability === 'pure' || fn.stateMutability === 'view'
       ? generateOutputTypes(returnResultObject, fn.outputs)

From 5eb4631e7677bb3696f42910f382cba2bcf5412d Mon Sep 17 00:00:00 2001
From: zemse <sohamzemse143@gmail.com>
Date: Sat, 20 Jun 2020 22:13:01 +0530
Subject: [PATCH 18/64] Fix unused overrides import

---
 packages/target-ethers-v5/src/codegen/index.ts | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/packages/target-ethers-v5/src/codegen/index.ts b/packages/target-ethers-v5/src/codegen/index.ts
index 6c341757d..fcf0750b0 100644
--- a/packages/target-ethers-v5/src/codegen/index.ts
+++ b/packages/target-ethers-v5/src/codegen/index.ts
@@ -11,9 +11,16 @@ import { generateInputType, generateInputTypes } from './types'
 import { codegenFunctions } from './functions'
 
 export function codegenContractTypings(contract: Contract) {
+  const contractImports: string[] = ['Contract', 'ContractTransaction']
+  const allFunctions = values(contract.functions).map(codegenFunctions.bind(null, true)).join('')
+
+  if (allFunctions.match(/\W Overrides(\W|$)/)) contractImports.push('Overrides')
+  if (allFunctions.match(/\WPayableOverrides(\W|$)/)) contractImports.push('PayableOverrides')
+  if (allFunctions.match(/\WCallOverrides(\W|$)/)) contractImports.push('CallOverrides')
+
   const template = `
   import { ethers, EventFilter, Signer, BigNumber, BigNumberish, PopulatedTransaction } from 'ethers';
-  import { Contract, ContractTransaction, Overrides } from '@ethersproject/contracts';
+  import { ${contractImports.join(', ')} } from '@ethersproject/contracts';
   import { BytesLike } from '@ethersproject/bytes';
   import { Listener, Provider } from '@ethersproject/providers';
   import { FunctionFragment, EventFragment } from '@ethersproject/abi';

From 4548a0a561814392563436472cc79232ceeb3d19 Mon Sep 17 00:00:00 2001
From: zemse <sohamzemse143@gmail.com>
Date: Sat, 20 Jun 2020 23:30:28 +0530
Subject: [PATCH 19/64] Add index file that exports all contracts

---
 packages/target-ethers-v5/src/index.ts | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/packages/target-ethers-v5/src/index.ts b/packages/target-ethers-v5/src/index.ts
index dd0370d60..a22903718 100644
--- a/packages/target-ethers-v5/src/index.ts
+++ b/packages/target-ethers-v5/src/index.ts
@@ -23,6 +23,7 @@ const DEFAULT_OUT_PATH = './types/ethers-contracts/'
 
 export default class Ethers extends TsGeneratorPlugin {
   name = 'Ethers'
+  contractFiles: string[] = []
 
   private readonly outDirAbs: string
   private readonly contractCache: Dictionary<{
@@ -80,6 +81,7 @@ export default class Ethers extends TsGeneratorPlugin {
     if (abi.length === 0) {
       return
     }
+
     const documentation = extractDocumentation(file.contents)
 
     const contract = parse(abi, name, documentation)
@@ -101,6 +103,8 @@ export default class Ethers extends TsGeneratorPlugin {
   }
 
   genContractFactoryFile(contract: Contract, abi: any, bytecode?: BytecodeWithLinkReferences) {
+    this.contractFiles.push(`${contract.name}Contract`)
+
     return {
       path: join(this.outDirAbs, `${contract.name}Contract.ts`),
       contents: codegenContractFactory(contract, abi, bytecode),
@@ -117,6 +121,13 @@ export default class Ethers extends TsGeneratorPlugin {
         contents: codegenAbstractContractFactory(contract, abi),
       }
     })
-    return abstractFactoryFiles
+
+    return [
+      ...abstractFactoryFiles,
+      {
+        path: join(this.outDirAbs, 'index.ts'),
+        contents: this.contractFiles.map((fileName) => `export * from './${fileName}'`).join('\n'),
+      },
+    ]
   }
 }

From 72553b5999c64ec7f08add275ebf4706dc3f4e13 Mon Sep 17 00:00:00 2001
From: zemse <sohamzemse143@gmail.com>
Date: Sat, 20 Jun 2020 23:47:37 +0530
Subject: [PATCH 20/64] Run yarn test:fix and fix errors

---
 packages/target-ethers-v5/src/codegen/index.ts | 12 ------------
 packages/target-ethers-v5/src/index.ts         |  1 -
 2 files changed, 13 deletions(-)

diff --git a/packages/target-ethers-v5/src/codegen/index.ts b/packages/target-ethers-v5/src/codegen/index.ts
index fcf0750b0..67b603020 100644
--- a/packages/target-ethers-v5/src/codegen/index.ts
+++ b/packages/target-ethers-v5/src/codegen/index.ts
@@ -228,18 +228,10 @@ function generateFunctionSignature(fn: FunctionDeclaration): string {
   return `${fn.name}(${fn.inputs.map((input: any) => input.type.originalType).join(',')})`
 }
 
-function generateParamArrayTypes(params: Array<AbiParameter>): string {
-  return `[${params.map((param) => generateInputType(param.type)).join(', ')}]`
-}
-
 function generateParamNames(params: Array<AbiParameter | EventArgDeclaration>): string {
   return params.map((param) => param.name).join(', ')
 }
 
-function generateParamArrayNames(params: Array<AbiParameter | EventArgDeclaration>): string {
-  return `[${generateParamNames(params)}]`
-}
-
 function generateEvents(event: EventDeclaration) {
   return `
   ${event.name}(${generateEventTypes(event.inputs)}): EventFilter;
@@ -254,10 +246,6 @@ function generateEventSignature(event: EventDeclaration): string {
   return `${event.name}(${event.inputs.map((input: any) => input.type.originalType).join(',')})`
 }
 
-function generateEventTopicTypes(eventArgs: Array<EventArgDeclaration>): string {
-  return `[${eventArgs.map(generateEventArgType).join(', ')}]`
-}
-
 function generateEventTypes(eventArgs: EventArgDeclaration[]) {
   if (eventArgs.length === 0) {
     return ''
diff --git a/packages/target-ethers-v5/src/index.ts b/packages/target-ethers-v5/src/index.ts
index a22903718..34233162b 100644
--- a/packages/target-ethers-v5/src/index.ts
+++ b/packages/target-ethers-v5/src/index.ts
@@ -1,5 +1,4 @@
 import { join, resolve } from 'path'
-import { readFileSync } from 'fs'
 import { Dictionary } from 'ts-essentials'
 import { TContext, TFileDesc, TsGeneratorPlugin } from 'ts-generator'
 import {

From 01954da953336a82562cb9459a5dd5aafc826f94 Mon Sep 17 00:00:00 2001
From: zemse <sohamzemse143@gmail.com>
Date: Sat, 20 Jun 2020 23:55:43 +0530
Subject: [PATCH 21/64] Rename to v5

---
 packages/target-ethers-v5/README.md    |  6 +++---
 packages/target-ethers-v5/package.json | 11 +++++++----
 2 files changed, 10 insertions(+), 7 deletions(-)

diff --git a/packages/target-ethers-v5/README.md b/packages/target-ethers-v5/README.md
index 4430209fd..f46bc6afa 100644
--- a/packages/target-ethers-v5/README.md
+++ b/packages/target-ethers-v5/README.md
@@ -1,9 +1,9 @@
-# Typechain target Ethers-v4
+# Typechain target Ethers-v5
 
 <p align="center">
   <img src="https://github.com/Neufund/TypeChain/blob/d82f3cc644a11e22ca8e42505c16f035e2f2555d/docs/images/typechain-logo.png?raw=true" width="300" alt="TypeChain">
-  <h3 align="center">TypeChain target Ethers-v4</h3>
-  <p align="center">🔌 TypeScript bindings for Ethers 4.x.x smartcontracts</p>
+  <h3 align="center">TypeChain target Ethers-v5</h3>
+  <p align="center">🔌 TypeScript bindings for Ethers 5.x.x smartcontracts</p>
 
   <p align="center">
     <a href="https://circleci.com/gh/ethereum-ts/TypeChain"><img alt="Build Status" src="https://circleci.com/gh/ethereum-ts/TypeChain/tree/master.svg?style=svg"></a>
diff --git a/packages/target-ethers-v5/package.json b/packages/target-ethers-v5/package.json
index 893f0bd80..7273bb99b 100644
--- a/packages/target-ethers-v5/package.json
+++ b/packages/target-ethers-v5/package.json
@@ -1,6 +1,6 @@
 {
-  "name": "@typechain/ethers-v4",
-  "description": "🔌 TypeChain target for ethers-v4",
+  "name": "@typechain/ethers-v5",
+  "description": "🔌 TypeChain target for ethers-v5",
   "keywords": [
     "ethers",
     "ethersjs",
@@ -58,9 +58,12 @@
     "prettier": "^2.0.1",
     "sinon": "^8.0.1",
     "sinon-chai": "^3.3.0",
+    "test-utils": "1.0.0",
     "ts-node": "^8.5.4",
-    "typescript": "3.9.0-beta",
     "typechain": "^2.0.0",
-    "test-utils": "1.0.0"
+    "typescript": "3.9.0-beta"
+  },
+  "dependencies": {
+    "ethers": "^5.0.2"
   }
 }

From 59e38bd2b0ca27b9def78c7fe04eb9285badd1fe Mon Sep 17 00:00:00 2001
From: zemse <sohamzemse143@gmail.com>
Date: Sun, 21 Jun 2020 02:05:50 +0530
Subject: [PATCH 22/64] Rename Contract file suffix back to Factory

---
 packages/target-ethers-v5/src/index.ts | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/packages/target-ethers-v5/src/index.ts b/packages/target-ethers-v5/src/index.ts
index 34233162b..adffd8919 100644
--- a/packages/target-ethers-v5/src/index.ts
+++ b/packages/target-ethers-v5/src/index.ts
@@ -102,10 +102,10 @@ export default class Ethers extends TsGeneratorPlugin {
   }
 
   genContractFactoryFile(contract: Contract, abi: any, bytecode?: BytecodeWithLinkReferences) {
-    this.contractFiles.push(`${contract.name}Contract`)
+    this.contractFiles.push(`${contract.name}`)
 
     return {
-      path: join(this.outDirAbs, `${contract.name}Contract.ts`),
+      path: join(this.outDirAbs, `${contract.name}Factory.ts`),
       contents: codegenContractFactory(contract, abi, bytecode),
     }
   }
@@ -125,7 +125,7 @@ export default class Ethers extends TsGeneratorPlugin {
       ...abstractFactoryFiles,
       {
         path: join(this.outDirAbs, 'index.ts'),
-        contents: this.contractFiles.map((fileName) => `export * from './${fileName}'`).join('\n'),
+        contents: this.contractFiles.map((fileName) => `export * from './${fileName}Factory'`).join('\n'),
       },
     ]
   }

From d298842efe91d07d24823bda5d7dc07174ef98fd Mon Sep 17 00:00:00 2001
From: zemse <sohamzemse143@gmail.com>
Date: Sun, 21 Jun 2020 02:07:16 +0530
Subject: [PATCH 23/64] Remove existing contract constructor

---
 packages/target-ethers-v5/src/codegen/index.ts | 8 +-------
 1 file changed, 1 insertion(+), 7 deletions(-)

diff --git a/packages/target-ethers-v5/src/codegen/index.ts b/packages/target-ethers-v5/src/codegen/index.ts
index 67b603020..10f8b5860 100644
--- a/packages/target-ethers-v5/src/codegen/index.ts
+++ b/packages/target-ethers-v5/src/codegen/index.ts
@@ -113,13 +113,7 @@ export function codegenContractFactory(contract: Contract, abi: any, bytecode?:
   import { Provider, TransactionRequest } from '@ethersproject/providers';
   import { ${ethersContractImports.join(', ')} } from "@ethersproject/contracts";
 
-  import { ${contract.name} as _${contract.name} } from "./${contract.name}";
-
-  export class ${contract.name} extends _${contract.name} {
-    constructor(addressOrName: string, signerOrProvider?: Signer | Provider | undefined) {
-      super(addressOrName, _abi, signerOrProvider);
-    }
-  }
+  import { ${contract.name} } from "./${contract.name}";
 
   export class ${contract.name}Factory extends ContractFactory {
     ${generateFactoryConstructor(contract, bytecode)}

From a34fe8d5d4c6c8c41fb8b7701f4e67849b26c8f8 Mon Sep 17 00:00:00 2001
From: zemse <sohamzemse143@gmail.com>
Date: Sun, 21 Jun 2020 02:08:31 +0530
Subject: [PATCH 24/64] Fix ethers constructor too many arguments error

---
 packages/target-ethers-v5/src/codegen/index.ts | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/packages/target-ethers-v5/src/codegen/index.ts b/packages/target-ethers-v5/src/codegen/index.ts
index 10f8b5860..38916f3a3 100644
--- a/packages/target-ethers-v5/src/codegen/index.ts
+++ b/packages/target-ethers-v5/src/codegen/index.ts
@@ -92,8 +92,8 @@ export function codegenContractFactory(contract: Contract, abi: any, bytecode?:
   const constructorArgNamesWithoutOverrides =
     contract.constructor && contract.constructor[0] ? generateParamNames(contract.constructor[0].inputs) : ''
   const constructorArgNames = constructorArgNamesWithoutOverrides
-    ? `${constructorArgNamesWithoutOverrides}, overrides`
-    : 'overrides'
+    ? `${constructorArgNamesWithoutOverrides}, overrides || {}`
+    : 'overrides || {}'
   if (!bytecode) return codegenAbstractContractFactory(contract, abi)
 
   // tsc with noUnusedLocals would complain about unused imports

From d2812306ee73d88725c060ce5c8ea498ba499af0 Mon Sep 17 00:00:00 2001
From: zemse <sohamzemse143@gmail.com>
Date: Tue, 23 Jun 2020 15:52:17 +0530
Subject: [PATCH 25/64] Add staticCall (ethers-io/ethers.js#395)

---
 .../target-ethers-v5/src/codegen/functions.ts  | 18 +++++++++---------
 packages/target-ethers-v5/src/codegen/index.ts | 16 +++++++++++++---
 packages/target-ethers-v5/src/codegen/types.ts |  5 +++++
 3 files changed, 27 insertions(+), 12 deletions(-)

diff --git a/packages/target-ethers-v5/src/codegen/functions.ts b/packages/target-ethers-v5/src/codegen/functions.ts
index 0c85e8055..c4158e8d0 100644
--- a/packages/target-ethers-v5/src/codegen/functions.ts
+++ b/packages/target-ethers-v5/src/codegen/functions.ts
@@ -1,23 +1,23 @@
 import { FunctionDeclaration, isConstant, isConstantFn, FunctionDocumentation, getSignatureForFn } from 'typechain'
-import { generateInputTypes, generateOutputTypes } from './types'
+import { generateInputTypes, generateOutputTypes, GenerateFunctionOptions } from './types'
 
-export function codegenFunctions(returnResultObject: boolean, fns: FunctionDeclaration[]): string {
+export function codegenFunctions(options: GenerateFunctionOptions, fns: FunctionDeclaration[]): string {
   if (fns.length === 1) {
-    return generateFunction(returnResultObject, fns[0])
+    return generateFunction(options, fns[0])
   }
 
-  return codegenForOverloadedFunctions(returnResultObject, fns)
+  return codegenForOverloadedFunctions(options, fns)
 }
 
-export function codegenForOverloadedFunctions(returnResultObject: boolean, fns: FunctionDeclaration[]): string {
-  return fns.map((fn) => generateFunction(returnResultObject, fn, `"${getSignatureForFn(fn)}"`)).join('\n')
+export function codegenForOverloadedFunctions(options: GenerateFunctionOptions, fns: FunctionDeclaration[]): string {
+  return fns.map((fn) => generateFunction(options, fn, `"${getSignatureForFn(fn)}"`)).join('\n')
 }
 
 function isPayable(fn: FunctionDeclaration): boolean {
   return fn.stateMutability === 'payable'
 }
 
-function generateFunction(returnResultObject: boolean, fn: FunctionDeclaration, overloadedName?: string): string {
+function generateFunction(options: GenerateFunctionOptions, fn: FunctionDeclaration, overloadedName?: string): string {
   return `
   ${generateFunctionDocumentation(fn.documentation)}
   ${overloadedName ?? fn.name}(${generateInputTypes(fn.inputs)}${
@@ -25,8 +25,8 @@ function generateFunction(returnResultObject: boolean, fn: FunctionDeclaration,
       ? `overrides?: ${isPayable(fn) ? 'PayableOverrides' : 'Overrides'}`
       : 'overrides?: CallOverrides'
   }): Promise<${
-    fn.stateMutability === 'pure' || fn.stateMutability === 'view'
-      ? generateOutputTypes(returnResultObject, fn.outputs)
+    options.isStaticCall || fn.stateMutability === 'pure' || fn.stateMutability === 'view'
+      ? generateOutputTypes(!!options.returnResultObject, fn.outputs)
       : 'ContractTransaction'
   }>;
 `
diff --git a/packages/target-ethers-v5/src/codegen/index.ts b/packages/target-ethers-v5/src/codegen/index.ts
index 38916f3a3..aebaad8a6 100644
--- a/packages/target-ethers-v5/src/codegen/index.ts
+++ b/packages/target-ethers-v5/src/codegen/index.ts
@@ -12,7 +12,9 @@ import { codegenFunctions } from './functions'
 
 export function codegenContractTypings(contract: Contract) {
   const contractImports: string[] = ['Contract', 'ContractTransaction']
-  const allFunctions = values(contract.functions).map(codegenFunctions.bind(null, true)).join('')
+  const allFunctions = values(contract.functions)
+    .map(codegenFunctions.bind(null, { returnResultObject: true }))
+    .join('')
 
   if (allFunctions.match(/\W Overrides(\W|$)/)) contractImports.push('Overrides')
   if (allFunctions.match(/\WPayableOverrides(\W|$)/)) contractImports.push('PayableOverrides')
@@ -55,10 +57,18 @@ export function codegenContractTypings(contract: Contract) {
     interface: ${contract.name}Interface;
 
     functions: {
-      ${values(contract.functions).map(codegenFunctions.bind(null, true)).join('\n')}
+      ${values(contract.functions)
+        .map(codegenFunctions.bind(null, { returnResultObject: true }))
+        .join('\n')}
     };
 
-    ${values(contract.functions).map(codegenFunctions.bind(null, false)).join('\n')}
+    ${values(contract.functions).map(codegenFunctions.bind(null, {})).join('\n')}
+
+    staticCall: {
+      ${values(contract.functions)
+        .map(codegenFunctions.bind(null, { isStaticCall: true }))
+        .join('\n')}
+    };
 
     filters: {
       ${values(contract.events)
diff --git a/packages/target-ethers-v5/src/codegen/types.ts b/packages/target-ethers-v5/src/codegen/types.ts
index d3ad78c67..60b59445f 100644
--- a/packages/target-ethers-v5/src/codegen/types.ts
+++ b/packages/target-ethers-v5/src/codegen/types.ts
@@ -1,5 +1,10 @@
 import { EvmType, EvmOutputType, TupleType, AbiParameter, AbiOutputParameter } from 'typechain'
 
+export interface GenerateFunctionOptions {
+  returnResultObject?: boolean
+  isStaticCall?: boolean
+}
+
 export function generateInputTypes(input: Array<AbiParameter>): string {
   if (input.length === 0) {
     return ''

From 72e6681a21e3b196b3cd8648b72e917910bdf5ce Mon Sep 17 00:00:00 2001
From: zemse <sohamzemse143@gmail.com>
Date: Tue, 23 Jun 2020 15:54:19 +0530
Subject: [PATCH 26/64] Fix provider import

---
 packages/target-ethers-v5/src/codegen/index.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/target-ethers-v5/src/codegen/index.ts b/packages/target-ethers-v5/src/codegen/index.ts
index aebaad8a6..1f796d40f 100644
--- a/packages/target-ethers-v5/src/codegen/index.ts
+++ b/packages/target-ethers-v5/src/codegen/index.ts
@@ -155,7 +155,7 @@ export function codegenContractFactory(contract: Contract, abi: any, bytecode?:
 export function codegenAbstractContractFactory(contract: Contract, abi: any): string {
   return `
   import { Contract, Signer } from "ethers";
-  import { Provider } from "ethers/providers";
+  import { Provider } from "@ethersproject/providers";
 
   import { ${contract.name} } from "./${contract.name}";
 

From 8575219ceb6c7530ef8ba1201be106eb5872bf8b Mon Sep 17 00:00:00 2001
From: zemse <sohamzemse143@gmail.com>
Date: Tue, 23 Jun 2020 15:58:07 +0530
Subject: [PATCH 27/64] Remove .DS_Store from .gitignore

---
 .gitignore | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/.gitignore b/.gitignore
index 61f5693d4..0c04882ee 100644
--- a/.gitignore
+++ b/.gitignore
@@ -13,5 +13,4 @@ examples/web3-v1/types
 examples/truffle-v4/types
 examples/truffle-v4/migrations
 examples/truffle-v5/types
-examples/truffle-v5/migrations
-.DS_Store
\ No newline at end of file
+examples/truffle-v5/migrations
\ No newline at end of file

From 1614cb3f82d4ff1c6719c62aee9004e20e9b0baf Mon Sep 17 00:00:00 2001
From: zemse <sohamzemse143@gmail.com>
Date: Sun, 28 Jun 2020 14:43:30 +0530
Subject: [PATCH 28/64] Add encodeFunctionData function overloads

---
 packages/target-ethers-v5/src/codegen/index.ts | 17 +++++++++++++++++
 1 file changed, 17 insertions(+)

diff --git a/packages/target-ethers-v5/src/codegen/index.ts b/packages/target-ethers-v5/src/codegen/index.ts
index 1f796d40f..1aa115874 100644
--- a/packages/target-ethers-v5/src/codegen/index.ts
+++ b/packages/target-ethers-v5/src/codegen/index.ts
@@ -35,6 +35,11 @@ export function codegenContractTypings(contract: Contract) {
         .join('\n')}
     };
 
+    ${values(contract.functions)
+      .map((v) => v[0])
+      .map(generateEncodeFunctionDataOverload)
+      .join('\n')}
+    
     events: {
       ${values(contract.events)
         .map((v) => v[0])
@@ -232,6 +237,18 @@ function generateFunctionSignature(fn: FunctionDeclaration): string {
   return `${fn.name}(${fn.inputs.map((input: any) => input.type.originalType).join(',')})`
 }
 
+function generateEncodeFunctionDataOverload(fn: FunctionDeclaration): string {
+  const methodInputs = [`functionFragment: '${fn.name}'`]
+
+  if (fn.inputs.length) {
+    methodInputs.push(`values: [${fn.inputs.map((input) => generateInputType(input.type)).join(', ')}]`)
+  } else {
+    methodInputs.push('values?: void')
+  }
+
+  return `encodeFunctionData(${methodInputs.join(', ')}): string;`
+}
+
 function generateParamNames(params: Array<AbiParameter | EventArgDeclaration>): string {
   return params.map((param) => param.name).join(', ')
 }

From 170806b4ce23ef1cf7c6d096dbdc369b41aaece0 Mon Sep 17 00:00:00 2001
From: zemse <sohamzemse143@gmail.com>
Date: Sun, 28 Jun 2020 14:57:43 +0530
Subject: [PATCH 29/64] Add decodeFunctionResult function overloads

---
 packages/target-ethers-v5/src/codegen/index.ts | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/packages/target-ethers-v5/src/codegen/index.ts b/packages/target-ethers-v5/src/codegen/index.ts
index 1aa115874..8d9efef73 100644
--- a/packages/target-ethers-v5/src/codegen/index.ts
+++ b/packages/target-ethers-v5/src/codegen/index.ts
@@ -25,7 +25,7 @@ export function codegenContractTypings(contract: Contract) {
   import { ${contractImports.join(', ')} } from '@ethersproject/contracts';
   import { BytesLike } from '@ethersproject/bytes';
   import { Listener, Provider } from '@ethersproject/providers';
-  import { FunctionFragment, EventFragment } from '@ethersproject/abi';
+  import { FunctionFragment, EventFragment, Result } from '@ethersproject/abi';
 
   interface ${contract.name}Interface extends ethers.utils.Interface {
     functions: {
@@ -40,6 +40,11 @@ export function codegenContractTypings(contract: Contract) {
       .map(generateEncodeFunctionDataOverload)
       .join('\n')}
     
+    ${values(contract.functions)
+      .map((v) => v[0])
+      .map(generateDecodeFunctionResultOverload)
+      .join('\n')}
+
     events: {
       ${values(contract.events)
         .map((v) => v[0])
@@ -249,6 +254,10 @@ function generateEncodeFunctionDataOverload(fn: FunctionDeclaration): string {
   return `encodeFunctionData(${methodInputs.join(', ')}): string;`
 }
 
+function generateDecodeFunctionResultOverload(fn: FunctionDeclaration): string {
+  return `decodeFunctionResult(functionFragment: '${fn.name}', data: BytesLike): Result;`
+}
+
 function generateParamNames(params: Array<AbiParameter | EventArgDeclaration>): string {
   return params.map((param) => param.name).join(', ')
 }

From c25f9bf4ac47d2332f239ef856e049cf39280132 Mon Sep 17 00:00:00 2001
From: zemse <sohamzemse143@gmail.com>
Date: Sun, 28 Jun 2020 14:59:27 +0530
Subject: [PATCH 30/64] Add getEvent function overloads

---
 packages/target-ethers-v5/src/codegen/index.ts | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/packages/target-ethers-v5/src/codegen/index.ts b/packages/target-ethers-v5/src/codegen/index.ts
index 8d9efef73..a4ddc6078 100644
--- a/packages/target-ethers-v5/src/codegen/index.ts
+++ b/packages/target-ethers-v5/src/codegen/index.ts
@@ -51,6 +51,11 @@ export function codegenContractTypings(contract: Contract) {
         .map(generateInterfaceEventDescription)
         .join('\n')}
     };
+
+    ${values(contract.events)
+      .map((v) => v[0])
+      .map(generateGetEventOverload)
+      .join('\n')}
   }
 
   export class ${contract.name} extends Contract {
@@ -292,3 +297,7 @@ function generateEventTypes(eventArgs: EventArgDeclaration[]) {
 function generateEventArgType(eventArg: EventArgDeclaration): string {
   return eventArg.isIndexed ? `${generateInputType(eventArg.type)} | null` : 'null'
 }
+
+function generateGetEventOverload(event: EventDeclaration): string {
+  return `getEvent(nameOrSignatureOrTopic: '${event.name}'): EventFragment;`
+}

From 6c1ed8ce92f08f4ba0f02d2401aac374ccd0881d Mon Sep 17 00:00:00 2001
From: zemse <sohamzemse143@gmail.com>
Date: Sun, 28 Jun 2020 15:02:25 +0530
Subject: [PATCH 31/64] Move GenerateFunctionOptions to functions.ts

---
 packages/target-ethers-v5/src/codegen/functions.ts | 7 ++++++-
 packages/target-ethers-v5/src/codegen/types.ts     | 5 -----
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/packages/target-ethers-v5/src/codegen/functions.ts b/packages/target-ethers-v5/src/codegen/functions.ts
index c4158e8d0..8fb00d51b 100644
--- a/packages/target-ethers-v5/src/codegen/functions.ts
+++ b/packages/target-ethers-v5/src/codegen/functions.ts
@@ -1,5 +1,10 @@
 import { FunctionDeclaration, isConstant, isConstantFn, FunctionDocumentation, getSignatureForFn } from 'typechain'
-import { generateInputTypes, generateOutputTypes, GenerateFunctionOptions } from './types'
+import { generateInputTypes, generateOutputTypes } from './types'
+
+interface GenerateFunctionOptions {
+  returnResultObject?: boolean
+  isStaticCall?: boolean
+}
 
 export function codegenFunctions(options: GenerateFunctionOptions, fns: FunctionDeclaration[]): string {
   if (fns.length === 1) {
diff --git a/packages/target-ethers-v5/src/codegen/types.ts b/packages/target-ethers-v5/src/codegen/types.ts
index 60b59445f..d3ad78c67 100644
--- a/packages/target-ethers-v5/src/codegen/types.ts
+++ b/packages/target-ethers-v5/src/codegen/types.ts
@@ -1,10 +1,5 @@
 import { EvmType, EvmOutputType, TupleType, AbiParameter, AbiOutputParameter } from 'typechain'
 
-export interface GenerateFunctionOptions {
-  returnResultObject?: boolean
-  isStaticCall?: boolean
-}
-
 export function generateInputTypes(input: Array<AbiParameter>): string {
   if (input.length === 0) {
     return ''

From 654e976fc6fc8f9d4d720c94b9b853e8517abacb Mon Sep 17 00:00:00 2001
From: zemse <sohamzemse143@gmail.com>
Date: Sun, 28 Jun 2020 16:09:06 +0530
Subject: [PATCH 32/64] Add a helper method to push optional imports

---
 .../target-ethers-v5/src/codegen/index.ts     | 20 +++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/packages/target-ethers-v5/src/codegen/index.ts b/packages/target-ethers-v5/src/codegen/index.ts
index a4ddc6078..550de921d 100644
--- a/packages/target-ethers-v5/src/codegen/index.ts
+++ b/packages/target-ethers-v5/src/codegen/index.ts
@@ -16,9 +16,8 @@ export function codegenContractTypings(contract: Contract) {
     .map(codegenFunctions.bind(null, { returnResultObject: true }))
     .join('')
 
-  if (allFunctions.match(/\W Overrides(\W|$)/)) contractImports.push('Overrides')
-  if (allFunctions.match(/\WPayableOverrides(\W|$)/)) contractImports.push('PayableOverrides')
-  if (allFunctions.match(/\WCallOverrides(\W|$)/)) contractImports.push('CallOverrides')
+  const optionalContractImports = ['Overrides', 'PayableOverrides', 'CallOverrides']
+  optionalContractImports.forEach((importName) => pushImportIfUsed(importName, allFunctions, contractImports))
 
   const template = `
   import { ethers, EventFilter, Signer, BigNumber, BigNumberish, PopulatedTransaction } from 'ethers';
@@ -123,15 +122,12 @@ export function codegenContractFactory(contract: Contract, abi: any, bytecode?:
 
   // tsc with noUnusedLocals would complain about unused imports
   const ethersImports: string[] = ['Signer']
-  if (constructorArgs.match(/\WBytesLike(\W|$)/)) ethersImports.push('BytesLike')
-  if (constructorArgs.match(/\WBigNumberish(\W|$)/)) ethersImports.push('BigNumberish')
+  const optionalEthersImports = ['BytesLike', 'BigNumberish']
+  optionalEthersImports.forEach((importName) => pushImportIfUsed(importName, constructorArgs, ethersImports))
 
   const ethersContractImports: string[] = ['Contract', 'ContractFactory']
-  if (constructorArgs.match(/\WPayableOverrides(\W|$)/)) {
-    ethersContractImports.push('PayableOverrides')
-  } else {
-    ethersContractImports.push('Overrides')
-  }
+  const optionalContractImports = ['PayableOverrides', 'Overrides']
+  optionalContractImports.forEach((importName) => pushImportIfUsed(importName, constructorArgs, ethersContractImports))
 
   return `
   import { ${ethersImports.join(', ')} } from "ethers";
@@ -301,3 +297,7 @@ function generateEventArgType(eventArg: EventArgDeclaration): string {
 function generateGetEventOverload(event: EventDeclaration): string {
   return `getEvent(nameOrSignatureOrTopic: '${event.name}'): EventFragment;`
 }
+
+function pushImportIfUsed(importName: string, generatedCode: string, importArray: string[]): void {
+  if (new RegExp(`\\W${importName}(\\W|$)`).test(generatedCode)) importArray.push(importName)
+}

From f6ded62e5af62c53f684ea3578b882a0655baa43 Mon Sep 17 00:00:00 2001
From: zemse <sohamzemse143@gmail.com>
Date: Sun, 28 Jun 2020 17:41:11 +0530
Subject: [PATCH 33/64] Duplicate ethers v4 tests directory

---
 packages/target-ethers-v5-test/.eslintrc.js   |   5 +
 packages/target-ethers-v5-test/LICENSE        |   8 +
 packages/target-ethers-v5-test/package.json   |  48 +++
 .../test/DataTypesInput.test.ts               |  65 ++++
 .../test/Overload.test.ts                     |  27 ++
 packages/target-ethers-v5-test/test/common.ts |  22 ++
 .../target-ethers-v5-test/test/setup.test.ts  |  10 +
 .../target-ethers-v5-test/tsconfig.build.json |   8 +
 packages/target-ethers-v5-test/tsconfig.json  |   8 +
 .../target-ethers-v5-test/tsconfig.types.json |   9 +
 .../types/DataTypesInput.d.ts                 | 203 ++++++++++++
 .../types/DataTypesInputFactory.ts            | 300 ++++++++++++++++++
 .../types/DataTypesPure.d.ts                  | 178 +++++++++++
 .../types/DataTypesPureFactory.ts             | 223 +++++++++++++
 .../types/DataTypesView.d.ts                  | 178 +++++++++++
 .../types/DataTypesViewFactory.ts             | 223 +++++++++++++
 .../target-ethers-v5-test/types/Events.d.ts   | 105 ++++++
 .../types/EventsFactory.ts                    | 128 ++++++++
 .../types/NameMangling.d.ts                   |  48 +++
 .../types/NameManglingFactory.ts              |  32 ++
 .../types/Overloads.d.ts                      |  57 ++++
 .../types/OverloadsFactory.ts                 |  62 ++++
 .../target-ethers-v5-test/types/Payable.d.ts  |  59 ++++
 .../types/PayableFactory.ts                   |  33 ++
 .../target-ethers-v5-test/types/index.d.ts    |  27 ++
 25 files changed, 2066 insertions(+)
 create mode 100644 packages/target-ethers-v5-test/.eslintrc.js
 create mode 100644 packages/target-ethers-v5-test/LICENSE
 create mode 100644 packages/target-ethers-v5-test/package.json
 create mode 100644 packages/target-ethers-v5-test/test/DataTypesInput.test.ts
 create mode 100644 packages/target-ethers-v5-test/test/Overload.test.ts
 create mode 100644 packages/target-ethers-v5-test/test/common.ts
 create mode 100644 packages/target-ethers-v5-test/test/setup.test.ts
 create mode 100644 packages/target-ethers-v5-test/tsconfig.build.json
 create mode 100644 packages/target-ethers-v5-test/tsconfig.json
 create mode 100644 packages/target-ethers-v5-test/tsconfig.types.json
 create mode 100644 packages/target-ethers-v5-test/types/DataTypesInput.d.ts
 create mode 100644 packages/target-ethers-v5-test/types/DataTypesInputFactory.ts
 create mode 100644 packages/target-ethers-v5-test/types/DataTypesPure.d.ts
 create mode 100644 packages/target-ethers-v5-test/types/DataTypesPureFactory.ts
 create mode 100644 packages/target-ethers-v5-test/types/DataTypesView.d.ts
 create mode 100644 packages/target-ethers-v5-test/types/DataTypesViewFactory.ts
 create mode 100644 packages/target-ethers-v5-test/types/Events.d.ts
 create mode 100644 packages/target-ethers-v5-test/types/EventsFactory.ts
 create mode 100644 packages/target-ethers-v5-test/types/NameMangling.d.ts
 create mode 100644 packages/target-ethers-v5-test/types/NameManglingFactory.ts
 create mode 100644 packages/target-ethers-v5-test/types/Overloads.d.ts
 create mode 100644 packages/target-ethers-v5-test/types/OverloadsFactory.ts
 create mode 100644 packages/target-ethers-v5-test/types/Payable.d.ts
 create mode 100644 packages/target-ethers-v5-test/types/PayableFactory.ts
 create mode 100644 packages/target-ethers-v5-test/types/index.d.ts

diff --git a/packages/target-ethers-v5-test/.eslintrc.js b/packages/target-ethers-v5-test/.eslintrc.js
new file mode 100644
index 000000000..3526285ae
--- /dev/null
+++ b/packages/target-ethers-v5-test/.eslintrc.js
@@ -0,0 +1,5 @@
+const baseConfig = require('../../.eslintrc.json')
+
+module.exports = {
+  ...baseConfig,
+}
diff --git a/packages/target-ethers-v5-test/LICENSE b/packages/target-ethers-v5-test/LICENSE
new file mode 100644
index 000000000..e17451f9b
--- /dev/null
+++ b/packages/target-ethers-v5-test/LICENSE
@@ -0,0 +1,8 @@
+Copyright 2020 Krzysztof Kaczor
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
diff --git a/packages/target-ethers-v5-test/package.json b/packages/target-ethers-v5-test/package.json
new file mode 100644
index 000000000..45a70e872
--- /dev/null
+++ b/packages/target-ethers-v5-test/package.json
@@ -0,0 +1,48 @@
+{
+  "name": "@typechain/ethers-v5-test",
+  "private": true,
+  "version": "1.0.0",
+  "license": "MIT",
+  "scripts": {
+    "prepublishOnly": "yarn lint && yarn test && yarn build",
+    "format": "prettier --config ../../.prettierrc --ignore-path ../../.prettierignore --check \"./**/*.ts\"",
+    "format:fix": "prettier --config ../../.prettierrc --ignore-path ../../.prettierignore --write \"./**/*.ts\"",
+    "lint": "eslint --ext .ts test",
+    "lint:fix": "yarn lint --fix",
+    "typecheck": "tsc --noEmit --incremental false --composite false && tsc --noEmit --incremental false --composite false -p tsconfig.types.json",
+    "clean": "rm -rf dist contracts/* && rm -f tsconfig.build.tsbuildinfo && rm -rf build",
+    "generate-types": "../typechain/dist/cli/cli.js --target=`pwd`/../target-ethers-v4/dist/index.js --outDir ./types/ '../../contracts/compiled/*.abi'",
+    "test": "yarn generate-types && mocha --config ../../.mocharc.js",
+    "test:fix": "yarn lint:fix && yarn format:fix && yarn test && yarn typecheck"
+  },
+  "devDependencies": {
+    "@types/chai": "^4.2.7",
+    "@types/chai-as-promised": "^7.1.2",
+    "@types/chai-subset": "^1.3.3",
+    "@types/mocha": "^5.2.7",
+    "@types/sinon": "^7.5.1",
+    "@types/sinon-chai": "^3.2.3",
+    "@typescript-eslint/eslint-plugin": "^2.25.0",
+    "@typescript-eslint/parser": "^2.12.0",
+    "chai": "^4.2.0",
+    "chai-as-promised": "^7.1.1",
+    "chai-http": "^4.3.0",
+    "chai-subset": "^1.6.0",
+    "eslint": "^6.8.0",
+    "eslint-config-typestrict": "^1.0.0",
+    "eslint-plugin-no-only-tests": "^2.4.0",
+    "eslint-plugin-sonarjs": "^0.5.0",
+    "ganache-cli": "^6.9.1",
+    "mocha": "^6.2.2",
+    "prettier": "^2.0.1",
+    "sinon": "^8.0.1",
+    "sinon-chai": "^3.3.0",
+    "test-utils": "1.0.0",
+    "ts-node": "^8.5.4",
+    "typechain": "^2.0.0",
+    "typescript": "3.9.0-beta"
+  },
+  "dependencies": {
+    "ethers": "^4.0.46"
+  }
+}
diff --git a/packages/target-ethers-v5-test/test/DataTypesInput.test.ts b/packages/target-ethers-v5-test/test/DataTypesInput.test.ts
new file mode 100644
index 000000000..e090cb78f
--- /dev/null
+++ b/packages/target-ethers-v5-test/test/DataTypesInput.test.ts
@@ -0,0 +1,65 @@
+import { typedAssert, q18 } from 'test-utils'
+import { BigNumber, formatBytes32String } from 'ethers/utils'
+
+import { createNewBlockchain, deployContract } from './common'
+import { DataTypesInput } from '../types/DataTypesInput'
+
+describe('DataTypesInput', () => {
+  let contract!: DataTypesInput
+  let ganache: any
+  beforeEach(async () => {
+    const { ganache: _ganache, signer } = await createNewBlockchain()
+    ganache = _ganache
+    contract = await deployContract<DataTypesInput>(signer, 'DataTypesInput')
+  })
+
+  afterEach(() => ganache.close())
+
+  it('works', async () => {
+    typedAssert(await contract.input_uint8('42'), 42)
+    typedAssert(await contract.input_uint8(42), 42)
+
+    typedAssert(await contract.input_uint256(q18(1)), new BigNumber(q18(1)))
+    typedAssert(await contract.input_uint256(1), new BigNumber(1))
+
+    typedAssert(await contract.input_int8('42'), 42)
+    typedAssert(await contract.input_int8(42), 42)
+
+    typedAssert(await contract.input_int256(q18(1)), new BigNumber(q18(1)))
+    typedAssert(await contract.input_int256(1), new BigNumber('1'))
+
+    typedAssert(await contract.input_bool(true), true)
+
+    typedAssert(
+      await contract.input_address('0x70b144972C5Ef6CB941A5379240B74239c418CD4'),
+      '0x70b144972C5Ef6CB941A5379240B74239c418CD4',
+    )
+
+    typedAssert(await contract.input_bytes1('0xaa'), '0xaa')
+    typedAssert(await contract.input_bytes1([0]), '0x00')
+
+    typedAssert(
+      await contract.input_bytes(formatBytes32String('TypeChain')),
+      '0x54797065436861696e0000000000000000000000000000000000000000000000',
+    )
+
+    typedAssert(await contract.input_string('TypeChain'), 'TypeChain')
+
+    typedAssert(await contract.input_stat_array(['1', '2', '3']), [1, 2, 3])
+    typedAssert(await contract.input_stat_array([1, 2, 3]), [1, 2, 3])
+
+    // TODO: this reverts for some weird reason
+    // typedAssert(await contract.input_tuple('1', '2'), { 0: new BigNumber('1'), 1: new BigNumber('2') })
+    // typedAssert(await contract.input_tuple(1, 2), { 0: '1', 1: '2' })
+
+    typedAssert(await contract.input_struct({ uint256_0: new BigNumber('1'), uint256_1: new BigNumber('2') }), {
+      0: new BigNumber('1'),
+      1: new BigNumber('2'),
+      uint256_0: new BigNumber('1'),
+      uint256_1: new BigNumber('2'),
+    })
+
+    typedAssert(await contract.input_enum('1'), 1)
+    typedAssert(await contract.input_enum(1), 1)
+  })
+})
diff --git a/packages/target-ethers-v5-test/test/Overload.test.ts b/packages/target-ethers-v5-test/test/Overload.test.ts
new file mode 100644
index 000000000..505138867
--- /dev/null
+++ b/packages/target-ethers-v5-test/test/Overload.test.ts
@@ -0,0 +1,27 @@
+import { typedAssert } from 'test-utils'
+
+import { createNewBlockchain, deployContract } from './common'
+import { Overloads } from '../types/Overloads'
+import { BigNumber } from 'ethers/utils'
+
+describe('Overloads', () => {
+  let contract: Overloads
+  let ganache: any
+  beforeEach(async () => {
+    const { ganache: _ganache, signer } = await createNewBlockchain()
+    ganache = _ganache
+    contract = await deployContract<Overloads>(signer, 'Overloads')
+  })
+
+  afterEach(() => ganache.close())
+
+  it('works with 1st overload', async () => {
+    const result = await contract.functions['overload1(int256)'](1)
+    typedAssert(result, new BigNumber(1))
+  })
+
+  it('works with 2n overload', async () => {
+    const result = await contract.functions['overload1(uint256,uint256)'](1, 2)
+    typedAssert(result, new BigNumber(3))
+  })
+})
diff --git a/packages/target-ethers-v5-test/test/common.ts b/packages/target-ethers-v5-test/test/common.ts
new file mode 100644
index 000000000..2de7b97ac
--- /dev/null
+++ b/packages/target-ethers-v5-test/test/common.ts
@@ -0,0 +1,22 @@
+import { JsonRpcProvider } from 'ethers/providers'
+import { ethers } from 'ethers'
+import { loadContract } from 'test-utils'
+
+const ganache = require('ganache-cli')
+
+export const GAS_LIMIT_STANDARD = 6000000
+
+export async function createNewBlockchain() {
+  const server = ganache.server()
+  server.listen(8545, () => {})
+  const provider = new JsonRpcProvider()
+  const signer = provider.getSigner(0)
+  return { ganache: server, signer }
+}
+
+export function deployContract<T>(signer: ethers.Signer, name: string): Promise<T> {
+  const { abi, code } = loadContract(name)
+
+  const factory = new ethers.ContractFactory(abi, code, signer)
+  return (factory.deploy() as any) as Promise<T>
+}
diff --git a/packages/target-ethers-v5-test/test/setup.test.ts b/packages/target-ethers-v5-test/test/setup.test.ts
new file mode 100644
index 000000000..7f17163c8
--- /dev/null
+++ b/packages/target-ethers-v5-test/test/setup.test.ts
@@ -0,0 +1,10 @@
+import chai from 'chai'
+import chaiAsPromised from 'chai-as-promised'
+import sinonChai from 'sinon-chai'
+import chaiHttp from 'chai-http'
+import chaiSubset from 'chai-subset'
+
+chai.use(chaiAsPromised)
+chai.use(sinonChai)
+chai.use(chaiHttp)
+chai.use(chaiSubset)
diff --git a/packages/target-ethers-v5-test/tsconfig.build.json b/packages/target-ethers-v5-test/tsconfig.build.json
new file mode 100644
index 000000000..4e1add83d
--- /dev/null
+++ b/packages/target-ethers-v5-test/tsconfig.build.json
@@ -0,0 +1,8 @@
+{
+  "extends": "./tsconfig.json",
+  "include": ["src"],
+  "compilerOptions": {
+    "outDir": "dist",
+    "rootDir": "src"
+  }
+}
diff --git a/packages/target-ethers-v5-test/tsconfig.json b/packages/target-ethers-v5-test/tsconfig.json
new file mode 100644
index 000000000..eb180f7fb
--- /dev/null
+++ b/packages/target-ethers-v5-test/tsconfig.json
@@ -0,0 +1,8 @@
+{
+  "extends": "../../tsconfig.json",
+  "include": ["src", "test", "types"],
+  "compilerOptions": {
+    "esModuleInterop": true,
+    "skipLibCheck": true
+  }
+}
diff --git a/packages/target-ethers-v5-test/tsconfig.types.json b/packages/target-ethers-v5-test/tsconfig.types.json
new file mode 100644
index 000000000..f9a76de17
--- /dev/null
+++ b/packages/target-ethers-v5-test/tsconfig.types.json
@@ -0,0 +1,9 @@
+{
+  "extends": "../../tsconfig.json",
+  "include": ["types"],
+  "exclude": ["node_modules"],
+  "compilerOptions": {
+    "esModuleInterop": true,
+    "lib": ["ES2018", "DOM"],
+  }
+}
diff --git a/packages/target-ethers-v5-test/types/DataTypesInput.d.ts b/packages/target-ethers-v5-test/types/DataTypesInput.d.ts
new file mode 100644
index 000000000..6ab731907
--- /dev/null
+++ b/packages/target-ethers-v5-test/types/DataTypesInput.d.ts
@@ -0,0 +1,203 @@
+/* Generated by ts-generator ver. 0.0.8 */
+/* tslint:disable */
+
+import { Contract, ContractTransaction, EventFilter, Signer } from "ethers";
+import { Listener, Provider } from "ethers/providers";
+import { Arrayish, BigNumber, BigNumberish, Interface } from "ethers/utils";
+import {
+  TransactionOverrides,
+  TypedEventDescription,
+  TypedFunctionDescription
+} from ".";
+
+interface DataTypesInputInterface extends Interface {
+  functions: {
+    input_address: TypedFunctionDescription<{
+      encode([input1]: [string]): string;
+    }>;
+
+    input_bool: TypedFunctionDescription<{
+      encode([input1]: [boolean]): string;
+    }>;
+
+    input_bytes: TypedFunctionDescription<{
+      encode([input1]: [Arrayish]): string;
+    }>;
+
+    input_bytes1: TypedFunctionDescription<{
+      encode([input1]: [Arrayish]): string;
+    }>;
+
+    input_enum: TypedFunctionDescription<{
+      encode([input1]: [BigNumberish]): string;
+    }>;
+
+    input_int256: TypedFunctionDescription<{
+      encode([input1]: [BigNumberish]): string;
+    }>;
+
+    input_int8: TypedFunctionDescription<{
+      encode([input1]: [BigNumberish]): string;
+    }>;
+
+    input_stat_array: TypedFunctionDescription<{
+      encode([input1]: [BigNumberish[]]): string;
+    }>;
+
+    input_string: TypedFunctionDescription<{
+      encode([input1]: [string]): string;
+    }>;
+
+    input_struct: TypedFunctionDescription<{
+      encode([input1]: [
+        { uint256_0: BigNumberish; uint256_1: BigNumberish }
+      ]): string;
+    }>;
+
+    input_tuple: TypedFunctionDescription<{
+      encode([input1, input2]: [BigNumberish, BigNumberish]): string;
+    }>;
+
+    input_uint256: TypedFunctionDescription<{
+      encode([input1]: [BigNumberish]): string;
+    }>;
+
+    input_uint8: TypedFunctionDescription<{
+      encode([input1]: [BigNumberish]): string;
+    }>;
+  };
+
+  events: {};
+}
+
+export class DataTypesInput extends Contract {
+  connect(signerOrProvider: Signer | Provider | string): DataTypesInput;
+  attach(addressOrName: string): DataTypesInput;
+  deployed(): Promise<DataTypesInput>;
+
+  on(event: EventFilter | string, listener: Listener): DataTypesInput;
+  once(event: EventFilter | string, listener: Listener): DataTypesInput;
+  addListener(
+    eventName: EventFilter | string,
+    listener: Listener
+  ): DataTypesInput;
+  removeAllListeners(eventName: EventFilter | string): DataTypesInput;
+  removeListener(eventName: any, listener: Listener): DataTypesInput;
+
+  interface: DataTypesInputInterface;
+
+  functions: {
+    input_address(input1: string): Promise<string>;
+
+    input_bool(input1: boolean): Promise<boolean>;
+
+    input_bytes(input1: Arrayish): Promise<string>;
+
+    input_bytes1(input1: Arrayish): Promise<string>;
+
+    input_enum(input1: BigNumberish): Promise<number>;
+
+    input_int256(input1: BigNumberish): Promise<BigNumber>;
+
+    input_int8(input1: BigNumberish): Promise<number>;
+
+    input_stat_array(input1: BigNumberish[]): Promise<number[]>;
+
+    input_string(input1: string): Promise<string>;
+
+    input_struct(input1: {
+      uint256_0: BigNumberish;
+      uint256_1: BigNumberish;
+    }): Promise<{
+      uint256_0: BigNumber;
+      uint256_1: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    input_tuple(
+      input1: BigNumberish,
+      input2: BigNumberish
+    ): Promise<{
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    input_uint256(input1: BigNumberish): Promise<BigNumber>;
+
+    input_uint8(input1: BigNumberish): Promise<number>;
+  };
+
+  input_address(input1: string): Promise<string>;
+
+  input_bool(input1: boolean): Promise<boolean>;
+
+  input_bytes(input1: Arrayish): Promise<string>;
+
+  input_bytes1(input1: Arrayish): Promise<string>;
+
+  input_enum(input1: BigNumberish): Promise<number>;
+
+  input_int256(input1: BigNumberish): Promise<BigNumber>;
+
+  input_int8(input1: BigNumberish): Promise<number>;
+
+  input_stat_array(input1: BigNumberish[]): Promise<number[]>;
+
+  input_string(input1: string): Promise<string>;
+
+  input_struct(input1: {
+    uint256_0: BigNumberish;
+    uint256_1: BigNumberish;
+  }): Promise<{
+    uint256_0: BigNumber;
+    uint256_1: BigNumber;
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
+  input_tuple(
+    input1: BigNumberish,
+    input2: BigNumberish
+  ): Promise<{
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
+  input_uint256(input1: BigNumberish): Promise<BigNumber>;
+
+  input_uint8(input1: BigNumberish): Promise<number>;
+
+  filters: {};
+
+  estimate: {
+    input_address(input1: string): Promise<BigNumber>;
+
+    input_bool(input1: boolean): Promise<BigNumber>;
+
+    input_bytes(input1: Arrayish): Promise<BigNumber>;
+
+    input_bytes1(input1: Arrayish): Promise<BigNumber>;
+
+    input_enum(input1: BigNumberish): Promise<BigNumber>;
+
+    input_int256(input1: BigNumberish): Promise<BigNumber>;
+
+    input_int8(input1: BigNumberish): Promise<BigNumber>;
+
+    input_stat_array(input1: BigNumberish[]): Promise<BigNumber>;
+
+    input_string(input1: string): Promise<BigNumber>;
+
+    input_struct(input1: {
+      uint256_0: BigNumberish;
+      uint256_1: BigNumberish;
+    }): Promise<BigNumber>;
+
+    input_tuple(input1: BigNumberish, input2: BigNumberish): Promise<BigNumber>;
+
+    input_uint256(input1: BigNumberish): Promise<BigNumber>;
+
+    input_uint8(input1: BigNumberish): Promise<BigNumber>;
+  };
+}
diff --git a/packages/target-ethers-v5-test/types/DataTypesInputFactory.ts b/packages/target-ethers-v5-test/types/DataTypesInputFactory.ts
new file mode 100644
index 000000000..34f3fcc78
--- /dev/null
+++ b/packages/target-ethers-v5-test/types/DataTypesInputFactory.ts
@@ -0,0 +1,300 @@
+/* Generated by ts-generator ver. 0.0.8 */
+/* tslint:disable */
+
+import { Contract, Signer } from "ethers";
+import { Provider } from "ethers/providers";
+
+import { DataTypesInput } from "./DataTypesInput";
+
+export class DataTypesInputFactory {
+  static connect(
+    address: string,
+    signerOrProvider: Signer | Provider
+  ): DataTypesInput {
+    return new Contract(address, _abi, signerOrProvider) as DataTypesInput;
+  }
+}
+
+const _abi = [
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "input1",
+        type: "address"
+      }
+    ],
+    name: "input_address",
+    outputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bool",
+        name: "input1",
+        type: "bool"
+      }
+    ],
+    name: "input_bool",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "input1",
+        type: "bytes"
+      }
+    ],
+    name: "input_bytes",
+    outputs: [
+      {
+        internalType: "bytes",
+        name: "",
+        type: "bytes"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes1",
+        name: "input1",
+        type: "bytes1"
+      }
+    ],
+    name: "input_bytes1",
+    outputs: [
+      {
+        internalType: "bytes1",
+        name: "",
+        type: "bytes1"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "enum DataTypesInput.Enum1",
+        name: "input1",
+        type: "uint8"
+      }
+    ],
+    name: "input_enum",
+    outputs: [
+      {
+        internalType: "enum DataTypesInput.Enum1",
+        name: "",
+        type: "uint8"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "int256",
+        name: "input1",
+        type: "int256"
+      }
+    ],
+    name: "input_int256",
+    outputs: [
+      {
+        internalType: "int256",
+        name: "",
+        type: "int256"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "int8",
+        name: "input1",
+        type: "int8"
+      }
+    ],
+    name: "input_int8",
+    outputs: [
+      {
+        internalType: "int8",
+        name: "",
+        type: "int8"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint8[3]",
+        name: "input1",
+        type: "uint8[3]"
+      }
+    ],
+    name: "input_stat_array",
+    outputs: [
+      {
+        internalType: "uint8[3]",
+        name: "",
+        type: "uint8[3]"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "string",
+        name: "input1",
+        type: "string"
+      }
+    ],
+    name: "input_string",
+    outputs: [
+      {
+        internalType: "string",
+        name: "",
+        type: "string"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        components: [
+          {
+            internalType: "uint256",
+            name: "uint256_0",
+            type: "uint256"
+          },
+          {
+            internalType: "uint256",
+            name: "uint256_1",
+            type: "uint256"
+          }
+        ],
+        internalType: "struct DataTypesInput.Struct1",
+        name: "input1",
+        type: "tuple"
+      }
+    ],
+    name: "input_struct",
+    outputs: [
+      {
+        components: [
+          {
+            internalType: "uint256",
+            name: "uint256_0",
+            type: "uint256"
+          },
+          {
+            internalType: "uint256",
+            name: "uint256_1",
+            type: "uint256"
+          }
+        ],
+        internalType: "struct DataTypesInput.Struct1",
+        name: "",
+        type: "tuple"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "input1",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "input2",
+        type: "uint256"
+      }
+    ],
+    name: "input_tuple",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "input1",
+        type: "uint256"
+      }
+    ],
+    name: "input_uint256",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint8",
+        name: "input1",
+        type: "uint8"
+      }
+    ],
+    name: "input_uint8",
+    outputs: [
+      {
+        internalType: "uint8",
+        name: "",
+        type: "uint8"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  }
+];
diff --git a/packages/target-ethers-v5-test/types/DataTypesPure.d.ts b/packages/target-ethers-v5-test/types/DataTypesPure.d.ts
new file mode 100644
index 000000000..6e81fa219
--- /dev/null
+++ b/packages/target-ethers-v5-test/types/DataTypesPure.d.ts
@@ -0,0 +1,178 @@
+/* Generated by ts-generator ver. 0.0.8 */
+/* tslint:disable */
+
+import { Contract, ContractTransaction, EventFilter, Signer } from "ethers";
+import { Listener, Provider } from "ethers/providers";
+import { Arrayish, BigNumber, BigNumberish, Interface } from "ethers/utils";
+import {
+  TransactionOverrides,
+  TypedEventDescription,
+  TypedFunctionDescription
+} from ".";
+
+interface DataTypesPureInterface extends Interface {
+  functions: {
+    pure_address: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    pure_bool: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    pure_bytes: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    pure_bytes1: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    pure_enum: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    pure_int256: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    pure_int8: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    pure_named: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    pure_stat_array: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    pure_string: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    pure_struct: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    pure_tuple: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    pure_uint256: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    pure_uint8: TypedFunctionDescription<{ encode([]: []): string }>;
+  };
+
+  events: {};
+}
+
+export class DataTypesPure extends Contract {
+  connect(signerOrProvider: Signer | Provider | string): DataTypesPure;
+  attach(addressOrName: string): DataTypesPure;
+  deployed(): Promise<DataTypesPure>;
+
+  on(event: EventFilter | string, listener: Listener): DataTypesPure;
+  once(event: EventFilter | string, listener: Listener): DataTypesPure;
+  addListener(
+    eventName: EventFilter | string,
+    listener: Listener
+  ): DataTypesPure;
+  removeAllListeners(eventName: EventFilter | string): DataTypesPure;
+  removeListener(eventName: any, listener: Listener): DataTypesPure;
+
+  interface: DataTypesPureInterface;
+
+  functions: {
+    pure_address(): Promise<string>;
+
+    pure_bool(): Promise<boolean>;
+
+    pure_bytes(): Promise<string>;
+
+    pure_bytes1(): Promise<string>;
+
+    pure_enum(): Promise<number>;
+
+    pure_int256(): Promise<BigNumber>;
+
+    pure_int8(): Promise<number>;
+
+    pure_named(): Promise<{
+      uint256_1: BigNumber;
+      uint256_2: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    pure_stat_array(): Promise<number[]>;
+
+    pure_string(): Promise<string>;
+
+    pure_struct(): Promise<{
+      uint256_0: BigNumber;
+      uint256_1: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    pure_tuple(): Promise<{
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    pure_uint256(): Promise<BigNumber>;
+
+    pure_uint8(): Promise<number>;
+  };
+
+  pure_address(): Promise<string>;
+
+  pure_bool(): Promise<boolean>;
+
+  pure_bytes(): Promise<string>;
+
+  pure_bytes1(): Promise<string>;
+
+  pure_enum(): Promise<number>;
+
+  pure_int256(): Promise<BigNumber>;
+
+  pure_int8(): Promise<number>;
+
+  pure_named(): Promise<{
+    uint256_1: BigNumber;
+    uint256_2: BigNumber;
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
+  pure_stat_array(): Promise<number[]>;
+
+  pure_string(): Promise<string>;
+
+  pure_struct(): Promise<{
+    uint256_0: BigNumber;
+    uint256_1: BigNumber;
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
+  pure_tuple(): Promise<{
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
+  pure_uint256(): Promise<BigNumber>;
+
+  pure_uint8(): Promise<number>;
+
+  filters: {};
+
+  estimate: {
+    pure_address(): Promise<BigNumber>;
+
+    pure_bool(): Promise<BigNumber>;
+
+    pure_bytes(): Promise<BigNumber>;
+
+    pure_bytes1(): Promise<BigNumber>;
+
+    pure_enum(): Promise<BigNumber>;
+
+    pure_int256(): Promise<BigNumber>;
+
+    pure_int8(): Promise<BigNumber>;
+
+    pure_named(): Promise<BigNumber>;
+
+    pure_stat_array(): Promise<BigNumber>;
+
+    pure_string(): Promise<BigNumber>;
+
+    pure_struct(): Promise<BigNumber>;
+
+    pure_tuple(): Promise<BigNumber>;
+
+    pure_uint256(): Promise<BigNumber>;
+
+    pure_uint8(): Promise<BigNumber>;
+  };
+}
diff --git a/packages/target-ethers-v5-test/types/DataTypesPureFactory.ts b/packages/target-ethers-v5-test/types/DataTypesPureFactory.ts
new file mode 100644
index 000000000..c0ab0e7af
--- /dev/null
+++ b/packages/target-ethers-v5-test/types/DataTypesPureFactory.ts
@@ -0,0 +1,223 @@
+/* Generated by ts-generator ver. 0.0.8 */
+/* tslint:disable */
+
+import { Contract, Signer } from "ethers";
+import { Provider } from "ethers/providers";
+
+import { DataTypesPure } from "./DataTypesPure";
+
+export class DataTypesPureFactory {
+  static connect(
+    address: string,
+    signerOrProvider: Signer | Provider
+  ): DataTypesPure {
+    return new Contract(address, _abi, signerOrProvider) as DataTypesPure;
+  }
+}
+
+const _abi = [
+  {
+    inputs: [],
+    name: "pure_address",
+    outputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "pure_bool",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "pure_bytes",
+    outputs: [
+      {
+        internalType: "bytes",
+        name: "",
+        type: "bytes"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "pure_bytes1",
+    outputs: [
+      {
+        internalType: "bytes1",
+        name: "",
+        type: "bytes1"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "pure_enum",
+    outputs: [
+      {
+        internalType: "enum DataTypesPure.Enum1",
+        name: "",
+        type: "uint8"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "pure_int256",
+    outputs: [
+      {
+        internalType: "int256",
+        name: "",
+        type: "int256"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "pure_int8",
+    outputs: [
+      {
+        internalType: "int8",
+        name: "",
+        type: "int8"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "pure_named",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "uint256_1",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "uint256_2",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "pure_stat_array",
+    outputs: [
+      {
+        internalType: "uint8[3]",
+        name: "",
+        type: "uint8[3]"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "pure_string",
+    outputs: [
+      {
+        internalType: "string",
+        name: "",
+        type: "string"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "pure_struct",
+    outputs: [
+      {
+        components: [
+          {
+            internalType: "uint256",
+            name: "uint256_0",
+            type: "uint256"
+          },
+          {
+            internalType: "uint256",
+            name: "uint256_1",
+            type: "uint256"
+          }
+        ],
+        internalType: "struct DataTypesPure.Struct1",
+        name: "",
+        type: "tuple"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "pure_tuple",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "pure_uint256",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "pure_uint8",
+    outputs: [
+      {
+        internalType: "uint8",
+        name: "",
+        type: "uint8"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  }
+];
diff --git a/packages/target-ethers-v5-test/types/DataTypesView.d.ts b/packages/target-ethers-v5-test/types/DataTypesView.d.ts
new file mode 100644
index 000000000..d489c6ba3
--- /dev/null
+++ b/packages/target-ethers-v5-test/types/DataTypesView.d.ts
@@ -0,0 +1,178 @@
+/* Generated by ts-generator ver. 0.0.8 */
+/* tslint:disable */
+
+import { Contract, ContractTransaction, EventFilter, Signer } from "ethers";
+import { Listener, Provider } from "ethers/providers";
+import { Arrayish, BigNumber, BigNumberish, Interface } from "ethers/utils";
+import {
+  TransactionOverrides,
+  TypedEventDescription,
+  TypedFunctionDescription
+} from ".";
+
+interface DataTypesViewInterface extends Interface {
+  functions: {
+    view_address: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    view_bool: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    view_bytes: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    view_bytes1: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    view_enum: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    view_int256: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    view_int8: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    view_named: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    view_stat_array: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    view_string: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    view_struct: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    view_tuple: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    view_uint256: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    view_uint8: TypedFunctionDescription<{ encode([]: []): string }>;
+  };
+
+  events: {};
+}
+
+export class DataTypesView extends Contract {
+  connect(signerOrProvider: Signer | Provider | string): DataTypesView;
+  attach(addressOrName: string): DataTypesView;
+  deployed(): Promise<DataTypesView>;
+
+  on(event: EventFilter | string, listener: Listener): DataTypesView;
+  once(event: EventFilter | string, listener: Listener): DataTypesView;
+  addListener(
+    eventName: EventFilter | string,
+    listener: Listener
+  ): DataTypesView;
+  removeAllListeners(eventName: EventFilter | string): DataTypesView;
+  removeListener(eventName: any, listener: Listener): DataTypesView;
+
+  interface: DataTypesViewInterface;
+
+  functions: {
+    view_address(): Promise<string>;
+
+    view_bool(): Promise<boolean>;
+
+    view_bytes(): Promise<string>;
+
+    view_bytes1(): Promise<string>;
+
+    view_enum(): Promise<number>;
+
+    view_int256(): Promise<BigNumber>;
+
+    view_int8(): Promise<number>;
+
+    view_named(): Promise<{
+      uint256_1: BigNumber;
+      uint256_2: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    view_stat_array(): Promise<number[]>;
+
+    view_string(): Promise<string>;
+
+    view_struct(): Promise<{
+      uint256_0: BigNumber;
+      uint256_1: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    view_tuple(): Promise<{
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    view_uint256(): Promise<BigNumber>;
+
+    view_uint8(): Promise<number>;
+  };
+
+  view_address(): Promise<string>;
+
+  view_bool(): Promise<boolean>;
+
+  view_bytes(): Promise<string>;
+
+  view_bytes1(): Promise<string>;
+
+  view_enum(): Promise<number>;
+
+  view_int256(): Promise<BigNumber>;
+
+  view_int8(): Promise<number>;
+
+  view_named(): Promise<{
+    uint256_1: BigNumber;
+    uint256_2: BigNumber;
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
+  view_stat_array(): Promise<number[]>;
+
+  view_string(): Promise<string>;
+
+  view_struct(): Promise<{
+    uint256_0: BigNumber;
+    uint256_1: BigNumber;
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
+  view_tuple(): Promise<{
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
+  view_uint256(): Promise<BigNumber>;
+
+  view_uint8(): Promise<number>;
+
+  filters: {};
+
+  estimate: {
+    view_address(): Promise<BigNumber>;
+
+    view_bool(): Promise<BigNumber>;
+
+    view_bytes(): Promise<BigNumber>;
+
+    view_bytes1(): Promise<BigNumber>;
+
+    view_enum(): Promise<BigNumber>;
+
+    view_int256(): Promise<BigNumber>;
+
+    view_int8(): Promise<BigNumber>;
+
+    view_named(): Promise<BigNumber>;
+
+    view_stat_array(): Promise<BigNumber>;
+
+    view_string(): Promise<BigNumber>;
+
+    view_struct(): Promise<BigNumber>;
+
+    view_tuple(): Promise<BigNumber>;
+
+    view_uint256(): Promise<BigNumber>;
+
+    view_uint8(): Promise<BigNumber>;
+  };
+}
diff --git a/packages/target-ethers-v5-test/types/DataTypesViewFactory.ts b/packages/target-ethers-v5-test/types/DataTypesViewFactory.ts
new file mode 100644
index 000000000..d1a7c9e14
--- /dev/null
+++ b/packages/target-ethers-v5-test/types/DataTypesViewFactory.ts
@@ -0,0 +1,223 @@
+/* Generated by ts-generator ver. 0.0.8 */
+/* tslint:disable */
+
+import { Contract, Signer } from "ethers";
+import { Provider } from "ethers/providers";
+
+import { DataTypesView } from "./DataTypesView";
+
+export class DataTypesViewFactory {
+  static connect(
+    address: string,
+    signerOrProvider: Signer | Provider
+  ): DataTypesView {
+    return new Contract(address, _abi, signerOrProvider) as DataTypesView;
+  }
+}
+
+const _abi = [
+  {
+    inputs: [],
+    name: "view_address",
+    outputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "view_bool",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "view_bytes",
+    outputs: [
+      {
+        internalType: "bytes",
+        name: "",
+        type: "bytes"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "view_bytes1",
+    outputs: [
+      {
+        internalType: "bytes1",
+        name: "",
+        type: "bytes1"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "view_enum",
+    outputs: [
+      {
+        internalType: "enum DataTypesView.Enum1",
+        name: "",
+        type: "uint8"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "view_int256",
+    outputs: [
+      {
+        internalType: "int256",
+        name: "",
+        type: "int256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "view_int8",
+    outputs: [
+      {
+        internalType: "int8",
+        name: "",
+        type: "int8"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "view_named",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "uint256_1",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "uint256_2",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "view_stat_array",
+    outputs: [
+      {
+        internalType: "uint8[3]",
+        name: "",
+        type: "uint8[3]"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "view_string",
+    outputs: [
+      {
+        internalType: "string",
+        name: "",
+        type: "string"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "view_struct",
+    outputs: [
+      {
+        components: [
+          {
+            internalType: "uint256",
+            name: "uint256_0",
+            type: "uint256"
+          },
+          {
+            internalType: "uint256",
+            name: "uint256_1",
+            type: "uint256"
+          }
+        ],
+        internalType: "struct DataTypesView.Struct1",
+        name: "",
+        type: "tuple"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "view_tuple",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "view_uint256",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "view_uint8",
+    outputs: [
+      {
+        internalType: "uint8",
+        name: "",
+        type: "uint8"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  }
+];
diff --git a/packages/target-ethers-v5-test/types/Events.d.ts b/packages/target-ethers-v5-test/types/Events.d.ts
new file mode 100644
index 000000000..21dd4fd1c
--- /dev/null
+++ b/packages/target-ethers-v5-test/types/Events.d.ts
@@ -0,0 +1,105 @@
+/* Generated by ts-generator ver. 0.0.8 */
+/* tslint:disable */
+
+import { Contract, ContractTransaction, EventFilter, Signer } from "ethers";
+import { Listener, Provider } from "ethers/providers";
+import { Arrayish, BigNumber, BigNumberish, Interface } from "ethers/utils";
+import {
+  TransactionOverrides,
+  TypedEventDescription,
+  TypedFunctionDescription
+} from ".";
+
+interface EventsInterface extends Interface {
+  functions: {
+    emit_anon1: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    emit_event1: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    emit_event2: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    emit_event3: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    emit_event3_overloaded: TypedFunctionDescription<{
+      encode([]: []): string;
+    }>;
+  };
+
+  events: {
+    AnonEvent1: TypedEventDescription<{
+      encodeTopics([value1]: [BigNumberish | null]): string[];
+    }>;
+
+    Event1: TypedEventDescription<{
+      encodeTopics([value1, value2]: [BigNumberish | null, null]): string[];
+    }>;
+
+    Event2: TypedEventDescription<{ encodeTopics([]: [null]): string[] }>;
+
+    Event3: TypedEventDescription<{
+      encodeTopics([value1, value2]: [boolean | null, null]): string[];
+    }>;
+  };
+}
+
+export class Events extends Contract {
+  connect(signerOrProvider: Signer | Provider | string): Events;
+  attach(addressOrName: string): Events;
+  deployed(): Promise<Events>;
+
+  on(event: EventFilter | string, listener: Listener): Events;
+  once(event: EventFilter | string, listener: Listener): Events;
+  addListener(eventName: EventFilter | string, listener: Listener): Events;
+  removeAllListeners(eventName: EventFilter | string): Events;
+  removeListener(eventName: any, listener: Listener): Events;
+
+  interface: EventsInterface;
+
+  functions: {
+    emit_anon1(overrides?: TransactionOverrides): Promise<ContractTransaction>;
+
+    emit_event1(overrides?: TransactionOverrides): Promise<ContractTransaction>;
+
+    emit_event2(overrides?: TransactionOverrides): Promise<ContractTransaction>;
+
+    emit_event3(overrides?: TransactionOverrides): Promise<ContractTransaction>;
+
+    emit_event3_overloaded(
+      overrides?: TransactionOverrides
+    ): Promise<ContractTransaction>;
+  };
+
+  emit_anon1(overrides?: TransactionOverrides): Promise<ContractTransaction>;
+
+  emit_event1(overrides?: TransactionOverrides): Promise<ContractTransaction>;
+
+  emit_event2(overrides?: TransactionOverrides): Promise<ContractTransaction>;
+
+  emit_event3(overrides?: TransactionOverrides): Promise<ContractTransaction>;
+
+  emit_event3_overloaded(
+    overrides?: TransactionOverrides
+  ): Promise<ContractTransaction>;
+
+  filters: {
+    AnonEvent1(value1: BigNumberish | null): EventFilter;
+
+    Event1(value1: BigNumberish | null, value2: null): EventFilter;
+
+    Event2(undefined: null): EventFilter;
+
+    Event3(value1: boolean | null, value2: null): EventFilter;
+  };
+
+  estimate: {
+    emit_anon1(): Promise<BigNumber>;
+
+    emit_event1(): Promise<BigNumber>;
+
+    emit_event2(): Promise<BigNumber>;
+
+    emit_event3(): Promise<BigNumber>;
+
+    emit_event3_overloaded(): Promise<BigNumber>;
+  };
+}
diff --git a/packages/target-ethers-v5-test/types/EventsFactory.ts b/packages/target-ethers-v5-test/types/EventsFactory.ts
new file mode 100644
index 000000000..cec0acf94
--- /dev/null
+++ b/packages/target-ethers-v5-test/types/EventsFactory.ts
@@ -0,0 +1,128 @@
+/* Generated by ts-generator ver. 0.0.8 */
+/* tslint:disable */
+
+import { Contract, Signer } from "ethers";
+import { Provider } from "ethers/providers";
+
+import { Events } from "./Events";
+
+export class EventsFactory {
+  static connect(address: string, signerOrProvider: Signer | Provider): Events {
+    return new Contract(address, _abi, signerOrProvider) as Events;
+  }
+}
+
+const _abi = [
+  {
+    anonymous: true,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "uint256",
+        name: "value1",
+        type: "uint256"
+      }
+    ],
+    name: "AnonEvent1",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "uint256",
+        name: "value1",
+        type: "uint256"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "value2",
+        type: "uint256"
+      }
+    ],
+    name: "Event1",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    name: "Event2",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "bool",
+        name: "value1",
+        type: "bool"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "value2",
+        type: "uint256"
+      }
+    ],
+    name: "Event3",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "uint256",
+        name: "value1",
+        type: "uint256"
+      }
+    ],
+    name: "Event3",
+    type: "event"
+  },
+  {
+    inputs: [],
+    name: "emit_anon1",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "emit_event1",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "emit_event2",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "emit_event3",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "emit_event3_overloaded",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
diff --git a/packages/target-ethers-v5-test/types/NameMangling.d.ts b/packages/target-ethers-v5-test/types/NameMangling.d.ts
new file mode 100644
index 000000000..5edbd9e8e
--- /dev/null
+++ b/packages/target-ethers-v5-test/types/NameMangling.d.ts
@@ -0,0 +1,48 @@
+/* Generated by ts-generator ver. 0.0.8 */
+/* tslint:disable */
+
+import { Contract, ContractTransaction, EventFilter, Signer } from "ethers";
+import { Listener, Provider } from "ethers/providers";
+import { Arrayish, BigNumber, BigNumberish, Interface } from "ethers/utils";
+import {
+  TransactionOverrides,
+  TypedEventDescription,
+  TypedFunctionDescription
+} from ".";
+
+interface NameManglingInterface extends Interface {
+  functions: {
+    works: TypedFunctionDescription<{ encode([]: []): string }>;
+  };
+
+  events: {};
+}
+
+export class NameMangling extends Contract {
+  connect(signerOrProvider: Signer | Provider | string): NameMangling;
+  attach(addressOrName: string): NameMangling;
+  deployed(): Promise<NameMangling>;
+
+  on(event: EventFilter | string, listener: Listener): NameMangling;
+  once(event: EventFilter | string, listener: Listener): NameMangling;
+  addListener(
+    eventName: EventFilter | string,
+    listener: Listener
+  ): NameMangling;
+  removeAllListeners(eventName: EventFilter | string): NameMangling;
+  removeListener(eventName: any, listener: Listener): NameMangling;
+
+  interface: NameManglingInterface;
+
+  functions: {
+    works(): Promise<boolean>;
+  };
+
+  works(): Promise<boolean>;
+
+  filters: {};
+
+  estimate: {
+    works(): Promise<BigNumber>;
+  };
+}
diff --git a/packages/target-ethers-v5-test/types/NameManglingFactory.ts b/packages/target-ethers-v5-test/types/NameManglingFactory.ts
new file mode 100644
index 000000000..f2e0b5796
--- /dev/null
+++ b/packages/target-ethers-v5-test/types/NameManglingFactory.ts
@@ -0,0 +1,32 @@
+/* Generated by ts-generator ver. 0.0.8 */
+/* tslint:disable */
+
+import { Contract, Signer } from "ethers";
+import { Provider } from "ethers/providers";
+
+import { NameMangling } from "./NameMangling";
+
+export class NameManglingFactory {
+  static connect(
+    address: string,
+    signerOrProvider: Signer | Provider
+  ): NameMangling {
+    return new Contract(address, _abi, signerOrProvider) as NameMangling;
+  }
+}
+
+const _abi = [
+  {
+    inputs: [],
+    name: "works",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  }
+];
diff --git a/packages/target-ethers-v5-test/types/Overloads.d.ts b/packages/target-ethers-v5-test/types/Overloads.d.ts
new file mode 100644
index 000000000..73ed4f205
--- /dev/null
+++ b/packages/target-ethers-v5-test/types/Overloads.d.ts
@@ -0,0 +1,57 @@
+/* Generated by ts-generator ver. 0.0.8 */
+/* tslint:disable */
+
+import { Contract, ContractTransaction, EventFilter, Signer } from "ethers";
+import { Listener, Provider } from "ethers/providers";
+import { Arrayish, BigNumber, BigNumberish, Interface } from "ethers/utils";
+import {
+  TransactionOverrides,
+  TypedEventDescription,
+  TypedFunctionDescription
+} from ".";
+
+interface OverloadsInterface extends Interface {
+  functions: {
+    overload1: TypedFunctionDescription<{
+      encode([input1]: [BigNumberish]): string;
+    }>;
+  };
+
+  events: {};
+}
+
+export class Overloads extends Contract {
+  connect(signerOrProvider: Signer | Provider | string): Overloads;
+  attach(addressOrName: string): Overloads;
+  deployed(): Promise<Overloads>;
+
+  on(event: EventFilter | string, listener: Listener): Overloads;
+  once(event: EventFilter | string, listener: Listener): Overloads;
+  addListener(eventName: EventFilter | string, listener: Listener): Overloads;
+  removeAllListeners(eventName: EventFilter | string): Overloads;
+  removeListener(eventName: any, listener: Listener): Overloads;
+
+  interface: OverloadsInterface;
+
+  functions: {
+    "overload1(int256)"(input1: BigNumberish): Promise<BigNumber>;
+
+    "overload1(uint256,uint256)"(
+      input1: BigNumberish,
+      input2: BigNumberish
+    ): Promise<BigNumber>;
+  };
+
+  "overload1(int256)"(input1: BigNumberish): Promise<BigNumber>;
+
+  "overload1(uint256,uint256)"(
+    input1: BigNumberish,
+    input2: BigNumberish
+  ): Promise<BigNumber>;
+
+  filters: {};
+
+  estimate: {
+    overload1(input1: BigNumberish): Promise<BigNumber>;
+  };
+}
diff --git a/packages/target-ethers-v5-test/types/OverloadsFactory.ts b/packages/target-ethers-v5-test/types/OverloadsFactory.ts
new file mode 100644
index 000000000..5aa7f5a44
--- /dev/null
+++ b/packages/target-ethers-v5-test/types/OverloadsFactory.ts
@@ -0,0 +1,62 @@
+/* Generated by ts-generator ver. 0.0.8 */
+/* tslint:disable */
+
+import { Contract, Signer } from "ethers";
+import { Provider } from "ethers/providers";
+
+import { Overloads } from "./Overloads";
+
+export class OverloadsFactory {
+  static connect(
+    address: string,
+    signerOrProvider: Signer | Provider
+  ): Overloads {
+    return new Contract(address, _abi, signerOrProvider) as Overloads;
+  }
+}
+
+const _abi = [
+  {
+    inputs: [
+      {
+        internalType: "int256",
+        name: "input1",
+        type: "int256"
+      }
+    ],
+    name: "overload1",
+    outputs: [
+      {
+        internalType: "int256",
+        name: "",
+        type: "int256"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "input1",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "input2",
+        type: "uint256"
+      }
+    ],
+    name: "overload1",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  }
+];
diff --git a/packages/target-ethers-v5-test/types/Payable.d.ts b/packages/target-ethers-v5-test/types/Payable.d.ts
new file mode 100644
index 000000000..c36e141ef
--- /dev/null
+++ b/packages/target-ethers-v5-test/types/Payable.d.ts
@@ -0,0 +1,59 @@
+/* Generated by ts-generator ver. 0.0.8 */
+/* tslint:disable */
+
+import { Contract, ContractTransaction, EventFilter, Signer } from "ethers";
+import { Listener, Provider } from "ethers/providers";
+import { Arrayish, BigNumber, BigNumberish, Interface } from "ethers/utils";
+import {
+  TransactionOverrides,
+  TypedEventDescription,
+  TypedFunctionDescription
+} from ".";
+
+interface PayableInterface extends Interface {
+  functions: {
+    non_payable_func: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    payable_func: TypedFunctionDescription<{ encode([]: []): string }>;
+  };
+
+  events: {};
+}
+
+export class Payable extends Contract {
+  connect(signerOrProvider: Signer | Provider | string): Payable;
+  attach(addressOrName: string): Payable;
+  deployed(): Promise<Payable>;
+
+  on(event: EventFilter | string, listener: Listener): Payable;
+  once(event: EventFilter | string, listener: Listener): Payable;
+  addListener(eventName: EventFilter | string, listener: Listener): Payable;
+  removeAllListeners(eventName: EventFilter | string): Payable;
+  removeListener(eventName: any, listener: Listener): Payable;
+
+  interface: PayableInterface;
+
+  functions: {
+    non_payable_func(
+      overrides?: TransactionOverrides
+    ): Promise<ContractTransaction>;
+
+    payable_func(
+      overrides?: TransactionOverrides
+    ): Promise<ContractTransaction>;
+  };
+
+  non_payable_func(
+    overrides?: TransactionOverrides
+  ): Promise<ContractTransaction>;
+
+  payable_func(overrides?: TransactionOverrides): Promise<ContractTransaction>;
+
+  filters: {};
+
+  estimate: {
+    non_payable_func(): Promise<BigNumber>;
+
+    payable_func(): Promise<BigNumber>;
+  };
+}
diff --git a/packages/target-ethers-v5-test/types/PayableFactory.ts b/packages/target-ethers-v5-test/types/PayableFactory.ts
new file mode 100644
index 000000000..1fbc7d681
--- /dev/null
+++ b/packages/target-ethers-v5-test/types/PayableFactory.ts
@@ -0,0 +1,33 @@
+/* Generated by ts-generator ver. 0.0.8 */
+/* tslint:disable */
+
+import { Contract, Signer } from "ethers";
+import { Provider } from "ethers/providers";
+
+import { Payable } from "./Payable";
+
+export class PayableFactory {
+  static connect(
+    address: string,
+    signerOrProvider: Signer | Provider
+  ): Payable {
+    return new Contract(address, _abi, signerOrProvider) as Payable;
+  }
+}
+
+const _abi = [
+  {
+    inputs: [],
+    name: "non_payable_func",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "payable_func",
+    outputs: [],
+    stateMutability: "payable",
+    type: "function"
+  }
+];
diff --git a/packages/target-ethers-v5-test/types/index.d.ts b/packages/target-ethers-v5-test/types/index.d.ts
new file mode 100644
index 000000000..93c86106f
--- /dev/null
+++ b/packages/target-ethers-v5-test/types/index.d.ts
@@ -0,0 +1,27 @@
+/* Generated by ts-generator ver. 0.0.8 */
+/* tslint:disable */
+import {
+  BigNumberish,
+  EventDescription,
+  FunctionDescription
+} from "ethers/utils";
+
+export class TransactionOverrides {
+  nonce?: BigNumberish | Promise<BigNumberish>;
+  gasLimit?: BigNumberish | Promise<BigNumberish>;
+  gasPrice?: BigNumberish | Promise<BigNumberish>;
+  value?: BigNumberish | Promise<BigNumberish>;
+  chainId?: number | Promise<number>;
+}
+
+export interface TypedEventDescription<
+  T extends Pick<EventDescription, "encodeTopics">
+> extends EventDescription {
+  encodeTopics: T["encodeTopics"];
+}
+
+export interface TypedFunctionDescription<
+  T extends Pick<FunctionDescription, "encode">
+> extends FunctionDescription {
+  encode: T["encode"];
+}

From 79c3fb562fbb92e1054eb98bd1580891666e0f73 Mon Sep 17 00:00:00 2001
From: zemse <sohamzemse143@gmail.com>
Date: Sun, 28 Jun 2020 17:42:07 +0530
Subject: [PATCH 34/64] Install ethers v5

---
 packages/target-ethers-v5-test/package.json |   2 +-
 yarn.lock                                   | 376 ++++++++++++++++++++
 2 files changed, 377 insertions(+), 1 deletion(-)

diff --git a/packages/target-ethers-v5-test/package.json b/packages/target-ethers-v5-test/package.json
index 45a70e872..62bc28e3e 100644
--- a/packages/target-ethers-v5-test/package.json
+++ b/packages/target-ethers-v5-test/package.json
@@ -43,6 +43,6 @@
     "typescript": "3.9.0-beta"
   },
   "dependencies": {
-    "ethers": "^4.0.46"
+    "ethers": "^5.0.2"
   }
 }
diff --git a/yarn.lock b/yarn.lock
index 23bef0b39..b96b4e19d 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -18,6 +18,337 @@
     esutils "^2.0.2"
     js-tokens "^4.0.0"
 
+"@ethersproject/abi@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/abi/-/abi-5.0.1.tgz#b6ba2bfb4278fbd6328b608e09741c2475ddad9c"
+  integrity sha512-9fqSa3jEYV4nN8tijW+jz4UnT/Ma9/b8y4+nHlsvuWqr32E2kYsT9SCIVpk/51iM6NOud7xsA6UxCox9zBeHKg==
+  dependencies:
+    "@ethersproject/address" "^5.0.0"
+    "@ethersproject/bignumber" "^5.0.0"
+    "@ethersproject/bytes" "^5.0.0"
+    "@ethersproject/constants" "^5.0.0"
+    "@ethersproject/hash" "^5.0.0"
+    "@ethersproject/keccak256" "^5.0.0"
+    "@ethersproject/logger" "^5.0.0"
+    "@ethersproject/properties" "^5.0.0"
+    "@ethersproject/strings" "^5.0.0"
+
+"@ethersproject/abstract-provider@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/abstract-provider/-/abstract-provider-5.0.1.tgz#7d4828a3b4690f95f4462abedcba7aeb118dadd5"
+  integrity sha512-/KOw65ayviYPtKLqFE1qozeIJJlfI1wE/tNA+iKUPUai6bU6vg2tbfLFGarRTCQe3HoWV1t7xSsD/z9T9xg74g==
+  dependencies:
+    "@ethersproject/bignumber" "^5.0.0"
+    "@ethersproject/bytes" "^5.0.0"
+    "@ethersproject/logger" "^5.0.0"
+    "@ethersproject/networks" "^5.0.0"
+    "@ethersproject/properties" "^5.0.0"
+    "@ethersproject/transactions" "^5.0.0"
+    "@ethersproject/web" "^5.0.0"
+
+"@ethersproject/abstract-signer@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/abstract-signer/-/abstract-signer-5.0.1.tgz#92149e771366467e86cc44dd0c49d28f93eaa852"
+  integrity sha512-Rp8DP+cLcSNFkd1YhwPSBcgEWLRipNakitwIwHngAmhbo4zdiWgALD/OLqdQ7SKF75CufF1W4BCuXcQgiWaRow==
+  dependencies:
+    "@ethersproject/abstract-provider" "^5.0.0"
+    "@ethersproject/bignumber" "^5.0.0"
+    "@ethersproject/bytes" "^5.0.0"
+    "@ethersproject/logger" "^5.0.0"
+    "@ethersproject/properties" "^5.0.0"
+
+"@ethersproject/address@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/address/-/address-5.0.1.tgz#882424fbbec1111abc1aa3482e647a72683c5377"
+  integrity sha512-kfQtXpBP2pI2TfoRRAYv8grHGiYw8U0c1KbMsC58/W33TIBy7gFSf/oAzOd94lNzdIUenKU0OuSzrHQfVcDDDA==
+  dependencies:
+    "@ethersproject/bignumber" "^5.0.0"
+    "@ethersproject/bytes" "^5.0.0"
+    "@ethersproject/keccak256" "^5.0.0"
+    "@ethersproject/logger" "^5.0.0"
+    "@ethersproject/rlp" "^5.0.0"
+    bn.js "^4.4.0"
+
+"@ethersproject/base64@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/base64/-/base64-5.0.1.tgz#9f067855f59db94edebb6cd80fbe79033406b317"
+  integrity sha512-WZDa+TYl6BQfUm9EQIDDfJFL0GiuYXNZPIWoiZx3uds7P1XMsvcW3k71AyjYUxIkU5AKW7awwPbzCbBeP1uXsA==
+  dependencies:
+    "@ethersproject/bytes" "^5.0.0"
+
+"@ethersproject/basex@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/basex/-/basex-5.0.1.tgz#226ae11bb5c6453398cece08b9548a5f896e24e5"
+  integrity sha512-ssL2+p/A5bZgkZkiWy0iQDVz2mVJxZfzpf7dpw8t0sKF9VpoM3ZiMthRapH/QBhd4Rr6TNbr619pFLAGmMi9Ug==
+  dependencies:
+    "@ethersproject/bytes" "^5.0.0"
+    "@ethersproject/properties" "^5.0.0"
+
+"@ethersproject/bignumber@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/bignumber/-/bignumber-5.0.1.tgz#85edb1026310633ef566cc379e3e0026697f6e6e"
+  integrity sha512-srGDO7ksT0avdDw5pBtj6F81psv5xiJMInwSSatfIKplitubFb6yVwoHGObGRd0Pp3TvrkIDfJkuskoSMj4OHQ==
+  dependencies:
+    "@ethersproject/bytes" "^5.0.0"
+    "@ethersproject/logger" "^5.0.0"
+    "@ethersproject/properties" "^5.0.0"
+    bn.js "^4.4.0"
+
+"@ethersproject/bytes@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/bytes/-/bytes-5.0.1.tgz#da8cd9b3e3b2800be9b46fda7036fc441b334680"
+  integrity sha512-Y198536UW9Jb9RBXuqmCsCa9mYJUsxJn+5aGr2XjNMpLBc6vEn/44GHnbQXYgRCzh4rnWtJ9bTgSwDjme9Hgnw==
+  dependencies:
+    "@ethersproject/logger" "^5.0.0"
+
+"@ethersproject/constants@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/constants/-/constants-5.0.1.tgz#51426b1d673661e905418ddeefca1f634866860d"
+  integrity sha512-Xec07hFCPN4wfC3WDiRay7KipkApl2msiKTrBHCuAwNMOM8M92+mlQp8tgfEL51DPwCZkmdk1f02kArc6caVSw==
+  dependencies:
+    "@ethersproject/bignumber" "^5.0.0"
+
+"@ethersproject/contracts@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/contracts/-/contracts-5.0.1.tgz#b11ad52f98f807e13a4bf0a89e45a2c56db19df3"
+  integrity sha512-1uPajmkvw3Oy/dxs5TKUsGaXzQ3s5qiXKSVpw9ZrhGG6fMRO3gNyUA+uSWk9IXK0ulj5P95F7vW8HmYOkzep/Q==
+  dependencies:
+    "@ethersproject/abi" "^5.0.0"
+    "@ethersproject/abstract-provider" "^5.0.0"
+    "@ethersproject/abstract-signer" "^5.0.0"
+    "@ethersproject/address" "^5.0.0"
+    "@ethersproject/bignumber" "^5.0.0"
+    "@ethersproject/bytes" "^5.0.0"
+    "@ethersproject/constants" "^5.0.0"
+    "@ethersproject/logger" "^5.0.0"
+    "@ethersproject/properties" "^5.0.0"
+
+"@ethersproject/hash@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/hash/-/hash-5.0.1.tgz#8190240d250b9442dd25f1e8ec2d66e7d0d38237"
+  integrity sha512-1ByUXYvkszrSSks07xctBtZfpFnIVmftxWlAAnguxh6Q65vKECd/EPi5uI5xVOvnrYMH9Vb8MK1SofPX/6fArQ==
+  dependencies:
+    "@ethersproject/bytes" "^5.0.0"
+    "@ethersproject/keccak256" "^5.0.0"
+    "@ethersproject/logger" "^5.0.0"
+    "@ethersproject/strings" "^5.0.0"
+
+"@ethersproject/hdnode@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/hdnode/-/hdnode-5.0.1.tgz#28c621c6fdb1a744c870212405e87c64e714e05f"
+  integrity sha512-L2OZP4SKKxNtHUdwfK8cND09kHRH62ncxXW33WAJU9shKo8Sbz31HVqSdov84bMAGm8QfEKZbfbAJV/7DM6DjQ==
+  dependencies:
+    "@ethersproject/abstract-signer" "^5.0.0"
+    "@ethersproject/basex" "^5.0.0"
+    "@ethersproject/bignumber" "^5.0.0"
+    "@ethersproject/bytes" "^5.0.0"
+    "@ethersproject/logger" "^5.0.0"
+    "@ethersproject/pbkdf2" "^5.0.0"
+    "@ethersproject/properties" "^5.0.0"
+    "@ethersproject/sha2" "^5.0.0"
+    "@ethersproject/signing-key" "^5.0.0"
+    "@ethersproject/strings" "^5.0.0"
+    "@ethersproject/transactions" "^5.0.0"
+    "@ethersproject/wordlists" "^5.0.0"
+
+"@ethersproject/json-wallets@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/json-wallets/-/json-wallets-5.0.1.tgz#a04a728cbf1974fc0a618794ef348335d4522848"
+  integrity sha512-QjqQCh1a0a6wRVHdnqVccCLWX0vAgxnvGZeGqpOk2NbyNE8HTzV7GpOE+4LU+iCc8oonfy1gYd4hpsf+iEUWGg==
+  dependencies:
+    "@ethersproject/abstract-signer" "^5.0.0"
+    "@ethersproject/address" "^5.0.0"
+    "@ethersproject/bytes" "^5.0.0"
+    "@ethersproject/hdnode" "^5.0.0"
+    "@ethersproject/keccak256" "^5.0.0"
+    "@ethersproject/logger" "^5.0.0"
+    "@ethersproject/pbkdf2" "^5.0.0"
+    "@ethersproject/properties" "^5.0.0"
+    "@ethersproject/random" "^5.0.0"
+    "@ethersproject/strings" "^5.0.0"
+    "@ethersproject/transactions" "^5.0.0"
+    aes-js "3.0.0"
+    scrypt-js "3.0.1"
+    uuid "2.0.1"
+
+"@ethersproject/keccak256@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/keccak256/-/keccak256-5.0.1.tgz#be91c11a8bdf4e94c8b900502d2a46b223fbdeb3"
+  integrity sha512-AtFm/4qHRQUvZcG3WYmaT7zV79dz72+N01w0XphcIBaD/7UZXyW85Uf08sirVlckHmh9fvc4UDWyHiroKsBT6Q==
+  dependencies:
+    "@ethersproject/bytes" "^5.0.0"
+    js-sha3 "0.5.7"
+
+"@ethersproject/logger@^5.0.0":
+  version "5.0.2"
+  resolved "https://registry.yarnpkg.com/@ethersproject/logger/-/logger-5.0.2.tgz#f24aa14a738a428d711c1828b44d50114a461b8b"
+  integrity sha512-NQe3O1/Nwkcp6bto6hsTvrcCeR/cOGK+RhOMn0Zi2FND6gdWsf1g+5ie8gQ1REqDX4MTGP/Y131dZas985ls/g==
+
+"@ethersproject/networks@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/networks/-/networks-5.0.1.tgz#c06ac151d0dfec421c1cb98a9153c109b3117111"
+  integrity sha512-Pe34JCTC6Apm/DkK3z97xotvEyu9YHKIFlDIu5hGV6yFDb4/sUfY2SHKYSGdUrV0418ZZVrwYDveJtBFMmYu2Q==
+  dependencies:
+    "@ethersproject/logger" "^5.0.0"
+
+"@ethersproject/pbkdf2@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/pbkdf2/-/pbkdf2-5.0.1.tgz#86d4340f88ebb97254c7e0d26830c24fb45b1642"
+  integrity sha512-4wc8Aov0iJmiomu6Dv1JNGOlhm3L7omITjLmChz/vgeDnW4Unv4J/nGybCeWKgY4hnjyQMVXkdkQ15BCRbkaYg==
+  dependencies:
+    "@ethersproject/bytes" "^5.0.0"
+    "@ethersproject/sha2" "^5.0.0"
+
+"@ethersproject/properties@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/properties/-/properties-5.0.1.tgz#e1fecbfcb24f23bf3b64a2ac74f2751113d116e0"
+  integrity sha512-b3VZ/NpYIf64/hFXeWNxVCbY1xoMPIYM3n6Qnu6Ayr3bLt1olFPQfAaaRB0aOsLz7tMtmkT3DrA1KG/IrOgBRw==
+  dependencies:
+    "@ethersproject/logger" "^5.0.0"
+
+"@ethersproject/providers@^5.0.0":
+  version "5.0.2"
+  resolved "https://registry.yarnpkg.com/@ethersproject/providers/-/providers-5.0.2.tgz#d738235db8235cf3471f4e7c4fac99b8830e4bf1"
+  integrity sha512-28ABJmHB9ii/73F3P9CXLBvlRkitiOGHCrUZqjQ6FELuAtKEROqA/yDklT9o/r/BpGcGTeeWpWfvdfgDHjshiw==
+  dependencies:
+    "@ethersproject/abstract-provider" "^5.0.0"
+    "@ethersproject/abstract-signer" "^5.0.0"
+    "@ethersproject/address" "^5.0.0"
+    "@ethersproject/bignumber" "^5.0.0"
+    "@ethersproject/bytes" "^5.0.0"
+    "@ethersproject/constants" "^5.0.0"
+    "@ethersproject/hash" "^5.0.0"
+    "@ethersproject/logger" "^5.0.0"
+    "@ethersproject/networks" "^5.0.0"
+    "@ethersproject/properties" "^5.0.0"
+    "@ethersproject/random" "^5.0.0"
+    "@ethersproject/rlp" "^5.0.0"
+    "@ethersproject/strings" "^5.0.0"
+    "@ethersproject/transactions" "^5.0.0"
+    "@ethersproject/web" "^5.0.0"
+    ws "7.2.3"
+
+"@ethersproject/random@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/random/-/random-5.0.1.tgz#cc5433c54e26faddf7c036e07a4f125d64503edb"
+  integrity sha512-nYzNhcp5Th4dCocV3yceZmh80bRmSQxqNRgND7Y/YgEgYJSSnknScpfRHACG//kgbsY8zui8ajXJeEnzS7yFbQ==
+  dependencies:
+    "@ethersproject/bytes" "^5.0.0"
+    "@ethersproject/logger" "^5.0.0"
+
+"@ethersproject/rlp@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/rlp/-/rlp-5.0.1.tgz#3407b0cb78f82a1a219aecff57578c0558ae26c8"
+  integrity sha512-3F8XE1zS4w8w4xiK1hMtFuVs6UnhQlmrEHLT85GanqK8vG5wGi81IQmkukL9tQIu2a5jykoO46ibja+6N1fpFg==
+  dependencies:
+    "@ethersproject/bytes" "^5.0.0"
+    "@ethersproject/logger" "^5.0.0"
+
+"@ethersproject/sha2@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/sha2/-/sha2-5.0.1.tgz#46b1b06cfd7d557ae4deab4cc85773f7512c4022"
+  integrity sha512-5wNdULNDMJKwyzqrTH66e2TZPZTSqqluS7RNtuuuQSTP+yIALoID7ewLjDoj31g4kZyq/pqQbackKJLOXejTKw==
+  dependencies:
+    "@ethersproject/bytes" "^5.0.0"
+    "@ethersproject/logger" "^5.0.0"
+    hash.js "1.1.3"
+
+"@ethersproject/signing-key@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/signing-key/-/signing-key-5.0.1.tgz#90957e42c69e857dc741c8fbeeff0f36bcee9cf7"
+  integrity sha512-Z3yMPFFf4KkWltndDNi/tpese7qZh6ZWKbGu3DHd8xOX0PJqbScdAs6gCfFeMatO06qyX307Y52soc/Ayf8ZSg==
+  dependencies:
+    "@ethersproject/bytes" "^5.0.0"
+    "@ethersproject/logger" "^5.0.0"
+    "@ethersproject/properties" "^5.0.0"
+    elliptic "6.5.2"
+
+"@ethersproject/solidity@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/solidity/-/solidity-5.0.1.tgz#df561603ba1c420e2ea309fca746698c55710a6d"
+  integrity sha512-3L+xI1LaJmd2zBJxnK9Y4cd1vb2aJLFvL6fxvjWpzcMiFiZ4dbPwj3kharv5f5mAlbGwAs6NiPJaFWvbOpm96Q==
+  dependencies:
+    "@ethersproject/bignumber" "^5.0.0"
+    "@ethersproject/bytes" "^5.0.0"
+    "@ethersproject/keccak256" "^5.0.0"
+    "@ethersproject/sha2" "^5.0.0"
+    "@ethersproject/strings" "^5.0.0"
+
+"@ethersproject/strings@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/strings/-/strings-5.0.1.tgz#a93aafeede100c4aad7f48e25aad1ddc42eeccc7"
+  integrity sha512-N8LxdHGBT7GZdogkEOV5xKXYTz5PNHuNzcxLNPYfH3kpvWSyXshZBgAz8YE1a8sMZagGj+Ic6d3mHijdCTSkGA==
+  dependencies:
+    "@ethersproject/bytes" "^5.0.0"
+    "@ethersproject/constants" "^5.0.0"
+    "@ethersproject/logger" "^5.0.0"
+
+"@ethersproject/transactions@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/transactions/-/transactions-5.0.1.tgz#61480dc600f4a49eb99627778e3b46b381f8bdd9"
+  integrity sha512-IGc6/5hri3PrqR/ZCj89osDiq3Lt0CSrycn6vlRl8SjpBKYDdcT+Ru5xkeC7YcsnqcdBmTL+jyR3SLudU+x2Kw==
+  dependencies:
+    "@ethersproject/address" "^5.0.0"
+    "@ethersproject/bignumber" "^5.0.0"
+    "@ethersproject/bytes" "^5.0.0"
+    "@ethersproject/constants" "^5.0.0"
+    "@ethersproject/keccak256" "^5.0.0"
+    "@ethersproject/logger" "^5.0.0"
+    "@ethersproject/properties" "^5.0.0"
+    "@ethersproject/rlp" "^5.0.0"
+    "@ethersproject/signing-key" "^5.0.0"
+
+"@ethersproject/units@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/units/-/units-5.0.1.tgz#f9fd97d0bfa0c23d55084b428053a29b42082a1f"
+  integrity sha512-7J7Jmm4hMZ+yFiqEd7D5oeVK/V74GDwQlT0Om1yxXLYX6UPcV5ChHkUz/xpHPT9JXQlQ+2D69HBf1dzvdflrmQ==
+  dependencies:
+    "@ethersproject/bignumber" "^5.0.0"
+    "@ethersproject/constants" "^5.0.0"
+    "@ethersproject/logger" "^5.0.0"
+
+"@ethersproject/wallet@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/wallet/-/wallet-5.0.1.tgz#595077365c674654e90d3884594a86d70ba07e7e"
+  integrity sha512-1/QPpFngJtUGtdVOLSoIN3vf+zEWyEVxQ0lhRCwGkiBqL2SoVoDHB7/nCfcv7wwlZkdnegFfo/8DxeyYjTZN7w==
+  dependencies:
+    "@ethersproject/abstract-provider" "^5.0.0"
+    "@ethersproject/abstract-signer" "^5.0.0"
+    "@ethersproject/address" "^5.0.0"
+    "@ethersproject/bignumber" "^5.0.0"
+    "@ethersproject/bytes" "^5.0.0"
+    "@ethersproject/hash" "^5.0.0"
+    "@ethersproject/hdnode" "^5.0.0"
+    "@ethersproject/json-wallets" "^5.0.0"
+    "@ethersproject/keccak256" "^5.0.0"
+    "@ethersproject/logger" "^5.0.0"
+    "@ethersproject/properties" "^5.0.0"
+    "@ethersproject/random" "^5.0.0"
+    "@ethersproject/signing-key" "^5.0.0"
+    "@ethersproject/transactions" "^5.0.0"
+    "@ethersproject/wordlists" "^5.0.0"
+
+"@ethersproject/web@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/web/-/web-5.0.1.tgz#b741096b5ad9465a1148b7dba8988c1da16f592a"
+  integrity sha512-lWPg8BR6KoyiIKYRIM6j+XO9bT9vGM1JnxFj2HmhIvOrOjba7ZRd8ANBOsDVGfw5igLUdfqAUOf9WpSsH//TzA==
+  dependencies:
+    "@ethersproject/base64" "^5.0.0"
+    "@ethersproject/logger" "^5.0.0"
+    "@ethersproject/properties" "^5.0.0"
+    "@ethersproject/strings" "^5.0.0"
+
+"@ethersproject/wordlists@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/wordlists/-/wordlists-5.0.1.tgz#4b1ef0894665fc8e7898235d3aa155f1724efa75"
+  integrity sha512-R7boLmpewucz5v4jD7cWwI0BGHR/DstiZtjdhUOft6XdMqM1OGb1UTL0GBQeS4vDXzCLuJEHddjJ69beGVN/4Q==
+  dependencies:
+    "@ethersproject/bytes" "^5.0.0"
+    "@ethersproject/hash" "^5.0.0"
+    "@ethersproject/logger" "^5.0.0"
+    "@ethersproject/properties" "^5.0.0"
+    "@ethersproject/strings" "^5.0.0"
+
 "@jest/types@^24.9.0":
   version "24.9.0"
   resolved "https://registry.yarnpkg.com/@jest/types/-/types-24.9.0.tgz#63cb26cb7500d069e5a389441a7c6ab5e909fc59"
@@ -1641,6 +1972,41 @@ ethers@^4.0.46:
     uuid "2.0.1"
     xmlhttprequest "1.8.0"
 
+ethers@^5.0.2:
+  version "5.0.2"
+  resolved "https://registry.yarnpkg.com/ethers/-/ethers-5.0.2.tgz#b7ccca12592c8f5f45e172c3c32fd13d77225048"
+  integrity sha512-hAWTPQXvjFlrtnPLCnOOJJuqiqmJv820egPHpOwcWTIQxXRrcfZyse2692eaqsXMeYLNM2CRfYgEomBiBGvgjw==
+  dependencies:
+    "@ethersproject/abi" "^5.0.0"
+    "@ethersproject/abstract-provider" "^5.0.0"
+    "@ethersproject/abstract-signer" "^5.0.0"
+    "@ethersproject/address" "^5.0.0"
+    "@ethersproject/base64" "^5.0.0"
+    "@ethersproject/bignumber" "^5.0.0"
+    "@ethersproject/bytes" "^5.0.0"
+    "@ethersproject/constants" "^5.0.0"
+    "@ethersproject/contracts" "^5.0.0"
+    "@ethersproject/hash" "^5.0.0"
+    "@ethersproject/hdnode" "^5.0.0"
+    "@ethersproject/json-wallets" "^5.0.0"
+    "@ethersproject/keccak256" "^5.0.0"
+    "@ethersproject/logger" "^5.0.0"
+    "@ethersproject/networks" "^5.0.0"
+    "@ethersproject/pbkdf2" "^5.0.0"
+    "@ethersproject/properties" "^5.0.0"
+    "@ethersproject/providers" "^5.0.0"
+    "@ethersproject/random" "^5.0.0"
+    "@ethersproject/rlp" "^5.0.0"
+    "@ethersproject/sha2" "^5.0.0"
+    "@ethersproject/signing-key" "^5.0.0"
+    "@ethersproject/solidity" "^5.0.0"
+    "@ethersproject/strings" "^5.0.0"
+    "@ethersproject/transactions" "^5.0.0"
+    "@ethersproject/units" "^5.0.0"
+    "@ethersproject/wallet" "^5.0.0"
+    "@ethersproject/web" "^5.0.0"
+    "@ethersproject/wordlists" "^5.0.0"
+
 ethjs-unit@0.1.6:
   version "0.1.6"
   resolved "https://registry.yarnpkg.com/ethjs-unit/-/ethjs-unit-0.1.6.tgz#c665921e476e87bce2a9d588a6fe0405b2c41699"
@@ -3746,6 +4112,11 @@ scrypt-js@2.0.4:
   resolved "https://registry.yarnpkg.com/scrypt-js/-/scrypt-js-2.0.4.tgz#32f8c5149f0797672e551c07e230f834b6af5f16"
   integrity sha512-4KsaGcPnuhtCZQCxFxN3GVYIhKFPTdLd8PLC552XwbMndtD0cjRFAhDuuydXQ0h08ZfPgzqe6EKHozpuH74iDw==
 
+scrypt-js@3.0.1:
+  version "3.0.1"
+  resolved "https://registry.yarnpkg.com/scrypt-js/-/scrypt-js-3.0.1.tgz#d314a57c2aef69d1ad98a138a21fe9eafa9ee312"
+  integrity sha512-cdwTTnqPu0Hyvf5in5asVdZocVDTNRmR7XEcJuIzMjJeSHybHl7vpB66AzwTaIg6CLSbtjcxc8fqcySfnTkccA==
+
 scryptsy@^2.1.0:
   version "2.1.0"
   resolved "https://registry.yarnpkg.com/scryptsy/-/scryptsy-2.1.0.tgz#8d1e8d0c025b58fdd25b6fa9a0dc905ee8faa790"
@@ -4849,6 +5220,11 @@ write@1.0.3:
   dependencies:
     mkdirp "^0.5.1"
 
+ws@7.2.3:
+  version "7.2.3"
+  resolved "https://registry.yarnpkg.com/ws/-/ws-7.2.3.tgz#a5411e1fb04d5ed0efee76d26d5c46d830c39b46"
+  integrity sha512-HTDl9G9hbkNDk98naoR/cHDws7+EyYMOdL1BmjsZXRUjf7d+MficC4B7HLUPlSiho0vg+CWKrGIt/VJBd1xunQ==
+
 ws@^3.0.0:
   version "3.3.3"
   resolved "https://registry.yarnpkg.com/ws/-/ws-3.3.3.tgz#f1cf84fe2d5e901ebce94efaece785f187a228f2"

From bc554ad801db714e6b35e03de3b211ae435585cd Mon Sep 17 00:00:00 2001
From: zemse <sohamzemse143@gmail.com>
Date: Sun, 28 Jun 2020 17:44:57 +0530
Subject: [PATCH 35/64] Update types

---
 packages/target-ethers-v5-test/package.json   |   2 +-
 .../types/DataTypesInput.d.ts                 | 440 +++++++++++++-----
 ...utFactory.ts => DataTypesInputContract.ts} |   2 +-
 .../types/DataTypesPure.d.ts                  | 345 ++++++++++----
 ...ureFactory.ts => DataTypesPureContract.ts} |   2 +-
 .../types/DataTypesView.d.ts                  | 345 ++++++++++----
 ...iewFactory.ts => DataTypesViewContract.ts} |   2 +-
 .../target-ethers-v5-test/types/Events.d.ts   | 157 ++++---
 .../{EventsFactory.ts => EventsContract.ts}   |   2 +-
 .../types/NameMangling.d.ts                   |  69 ++-
 ...lingFactory.ts => NameManglingContract.ts} |   2 +-
 .../types/Overloads.d.ts                      |  92 +++-
 ...erloadsFactory.ts => OverloadsContract.ts} |   2 +-
 .../target-ethers-v5-test/types/Payable.d.ts  |  89 ++--
 .../{PayableFactory.ts => PayableContract.ts} |   2 +-
 .../target-ethers-v5-test/types/index.d.ts    |  27 --
 packages/target-ethers-v5-test/types/index.ts |   2 +
 17 files changed, 1098 insertions(+), 484 deletions(-)
 rename packages/target-ethers-v5-test/types/{DataTypesInputFactory.ts => DataTypesInputContract.ts} (99%)
 rename packages/target-ethers-v5-test/types/{DataTypesPureFactory.ts => DataTypesPureContract.ts} (98%)
 rename packages/target-ethers-v5-test/types/{DataTypesViewFactory.ts => DataTypesViewContract.ts} (98%)
 rename packages/target-ethers-v5-test/types/{EventsFactory.ts => EventsContract.ts} (97%)
 rename packages/target-ethers-v5-test/types/{NameManglingFactory.ts => NameManglingContract.ts} (91%)
 rename packages/target-ethers-v5-test/types/{OverloadsFactory.ts => OverloadsContract.ts} (95%)
 rename packages/target-ethers-v5-test/types/{PayableFactory.ts => PayableContract.ts} (92%)
 delete mode 100644 packages/target-ethers-v5-test/types/index.d.ts
 create mode 100644 packages/target-ethers-v5-test/types/index.ts

diff --git a/packages/target-ethers-v5-test/package.json b/packages/target-ethers-v5-test/package.json
index 62bc28e3e..07b88e227 100644
--- a/packages/target-ethers-v5-test/package.json
+++ b/packages/target-ethers-v5-test/package.json
@@ -11,7 +11,7 @@
     "lint:fix": "yarn lint --fix",
     "typecheck": "tsc --noEmit --incremental false --composite false && tsc --noEmit --incremental false --composite false -p tsconfig.types.json",
     "clean": "rm -rf dist contracts/* && rm -f tsconfig.build.tsbuildinfo && rm -rf build",
-    "generate-types": "../typechain/dist/cli/cli.js --target=`pwd`/../target-ethers-v4/dist/index.js --outDir ./types/ '../../contracts/compiled/*.abi'",
+    "generate-types": "../typechain/dist/cli/cli.js --target=`pwd`/../target-ethers-v5/dist/index.js --outDir ./types/ '../../contracts/compiled/*.abi'",
     "test": "yarn generate-types && mocha --config ../../.mocharc.js",
     "test:fix": "yarn lint:fix && yarn format:fix && yarn test && yarn typecheck"
   },
diff --git a/packages/target-ethers-v5-test/types/DataTypesInput.d.ts b/packages/target-ethers-v5-test/types/DataTypesInput.d.ts
index 6ab731907..e95cd8ccb 100644
--- a/packages/target-ethers-v5-test/types/DataTypesInput.d.ts
+++ b/packages/target-ethers-v5-test/types/DataTypesInput.d.ts
@@ -1,155 +1,278 @@
 /* Generated by ts-generator ver. 0.0.8 */
 /* tslint:disable */
 
-import { Contract, ContractTransaction, EventFilter, Signer } from "ethers";
-import { Listener, Provider } from "ethers/providers";
-import { Arrayish, BigNumber, BigNumberish, Interface } from "ethers/utils";
 import {
-  TransactionOverrides,
-  TypedEventDescription,
-  TypedFunctionDescription
-} from ".";
-
-interface DataTypesInputInterface extends Interface {
+  ethers,
+  EventFilter,
+  Signer,
+  BigNumber,
+  BigNumberish,
+  PopulatedTransaction
+} from "ethers";
+import {
+  Contract,
+  ContractTransaction,
+  CallOverrides
+} from "@ethersproject/contracts";
+import { BytesLike } from "@ethersproject/bytes";
+import { Listener, Provider } from "@ethersproject/providers";
+import { FunctionFragment, EventFragment, Result } from "@ethersproject/abi";
+
+interface DataTypesInputInterface extends ethers.utils.Interface {
   functions: {
-    input_address: TypedFunctionDescription<{
-      encode([input1]: [string]): string;
-    }>;
+    "input_address(address)": FunctionFragment;
+    "input_bool(bool)": FunctionFragment;
+    "input_bytes(bytes)": FunctionFragment;
+    "input_bytes1(bytes1)": FunctionFragment;
+    "input_enum(uint8)": FunctionFragment;
+    "input_int256(int256)": FunctionFragment;
+    "input_int8(int8)": FunctionFragment;
+    "input_stat_array(uint8[3])": FunctionFragment;
+    "input_string(string)": FunctionFragment;
+    "input_struct(tuple)": FunctionFragment;
+    "input_tuple(uint256,uint256)": FunctionFragment;
+    "input_uint256(uint256)": FunctionFragment;
+    "input_uint8(uint8)": FunctionFragment;
+  };
 
-    input_bool: TypedFunctionDescription<{
-      encode([input1]: [boolean]): string;
-    }>;
+  encodeFunctionData(
+    functionFragment: "input_address",
+    values: [string]
+  ): string;
+  encodeFunctionData(functionFragment: "input_bool", values: [boolean]): string;
+  encodeFunctionData(
+    functionFragment: "input_bytes",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "input_bytes1",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "input_enum",
+    values: [BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "input_int256",
+    values: [BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "input_int8",
+    values: [BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "input_stat_array",
+    values: [BigNumberish[]]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "input_string",
+    values: [string]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "input_struct",
+    values: [{ uint256_0: BigNumberish; uint256_1: BigNumberish }]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "input_tuple",
+    values: [BigNumberish, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "input_uint256",
+    values: [BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "input_uint8",
+    values: [BigNumberish]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "input_address",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "input_bool", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "input_bytes",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "input_bytes1",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "input_enum", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "input_int256",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "input_int8", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "input_stat_array",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "input_string",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "input_struct",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "input_tuple",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "input_uint256",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "input_uint8",
+    data: BytesLike
+  ): Result;
 
-    input_bytes: TypedFunctionDescription<{
-      encode([input1]: [Arrayish]): string;
-    }>;
+  events: {};
+}
 
-    input_bytes1: TypedFunctionDescription<{
-      encode([input1]: [Arrayish]): string;
-    }>;
+export class DataTypesInput extends Contract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
 
-    input_enum: TypedFunctionDescription<{
-      encode([input1]: [BigNumberish]): string;
-    }>;
+  on(event: EventFilter | string, listener: Listener): this;
+  once(event: EventFilter | string, listener: Listener): this;
+  addListener(eventName: EventFilter | string, listener: Listener): this;
+  removeAllListeners(eventName: EventFilter | string): this;
+  removeListener(eventName: any, listener: Listener): this;
 
-    input_int256: TypedFunctionDescription<{
-      encode([input1]: [BigNumberish]): string;
-    }>;
+  interface: DataTypesInputInterface;
 
-    input_int8: TypedFunctionDescription<{
-      encode([input1]: [BigNumberish]): string;
+  functions: {
+    input_address(
+      input1: string,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
     }>;
 
-    input_stat_array: TypedFunctionDescription<{
-      encode([input1]: [BigNumberish[]]): string;
+    input_bool(
+      input1: boolean,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: boolean;
     }>;
 
-    input_string: TypedFunctionDescription<{
-      encode([input1]: [string]): string;
+    input_bytes(
+      input1: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
     }>;
 
-    input_struct: TypedFunctionDescription<{
-      encode([input1]: [
-        { uint256_0: BigNumberish; uint256_1: BigNumberish }
-      ]): string;
+    input_bytes1(
+      input1: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
     }>;
 
-    input_tuple: TypedFunctionDescription<{
-      encode([input1, input2]: [BigNumberish, BigNumberish]): string;
+    input_enum(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number;
     }>;
 
-    input_uint256: TypedFunctionDescription<{
-      encode([input1]: [BigNumberish]): string;
+    input_int256(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
     }>;
 
-    input_uint8: TypedFunctionDescription<{
-      encode([input1]: [BigNumberish]): string;
+    input_int8(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number;
     }>;
-  };
-
-  events: {};
-}
 
-export class DataTypesInput extends Contract {
-  connect(signerOrProvider: Signer | Provider | string): DataTypesInput;
-  attach(addressOrName: string): DataTypesInput;
-  deployed(): Promise<DataTypesInput>;
-
-  on(event: EventFilter | string, listener: Listener): DataTypesInput;
-  once(event: EventFilter | string, listener: Listener): DataTypesInput;
-  addListener(
-    eventName: EventFilter | string,
-    listener: Listener
-  ): DataTypesInput;
-  removeAllListeners(eventName: EventFilter | string): DataTypesInput;
-  removeListener(eventName: any, listener: Listener): DataTypesInput;
-
-  interface: DataTypesInputInterface;
-
-  functions: {
-    input_address(input1: string): Promise<string>;
-
-    input_bool(input1: boolean): Promise<boolean>;
-
-    input_bytes(input1: Arrayish): Promise<string>;
-
-    input_bytes1(input1: Arrayish): Promise<string>;
-
-    input_enum(input1: BigNumberish): Promise<number>;
-
-    input_int256(input1: BigNumberish): Promise<BigNumber>;
-
-    input_int8(input1: BigNumberish): Promise<number>;
-
-    input_stat_array(input1: BigNumberish[]): Promise<number[]>;
+    input_stat_array(
+      input1: BigNumberish[],
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number[];
+    }>;
 
-    input_string(input1: string): Promise<string>;
+    input_string(
+      input1: string,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
 
-    input_struct(input1: {
-      uint256_0: BigNumberish;
-      uint256_1: BigNumberish;
-    }): Promise<{
-      uint256_0: BigNumber;
-      uint256_1: BigNumber;
-      0: BigNumber;
-      1: BigNumber;
+    input_struct(
+      input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
+      overrides?: CallOverrides
+    ): Promise<{
+      0: {
+        uint256_0: BigNumber;
+        uint256_1: BigNumber;
+        0: BigNumber;
+        1: BigNumber;
+      };
     }>;
 
     input_tuple(
       input1: BigNumberish,
-      input2: BigNumberish
+      input2: BigNumberish,
+      overrides?: CallOverrides
     ): Promise<{
       0: BigNumber;
       1: BigNumber;
     }>;
 
-    input_uint256(input1: BigNumberish): Promise<BigNumber>;
+    input_uint256(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+    }>;
 
-    input_uint8(input1: BigNumberish): Promise<number>;
+    input_uint8(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number;
+    }>;
   };
 
-  input_address(input1: string): Promise<string>;
+  input_address(input1: string, overrides?: CallOverrides): Promise<string>;
 
-  input_bool(input1: boolean): Promise<boolean>;
+  input_bool(input1: boolean, overrides?: CallOverrides): Promise<boolean>;
 
-  input_bytes(input1: Arrayish): Promise<string>;
+  input_bytes(input1: BytesLike, overrides?: CallOverrides): Promise<string>;
 
-  input_bytes1(input1: Arrayish): Promise<string>;
+  input_bytes1(input1: BytesLike, overrides?: CallOverrides): Promise<string>;
 
-  input_enum(input1: BigNumberish): Promise<number>;
+  input_enum(input1: BigNumberish, overrides?: CallOverrides): Promise<number>;
 
-  input_int256(input1: BigNumberish): Promise<BigNumber>;
+  input_int256(
+    input1: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
 
-  input_int8(input1: BigNumberish): Promise<number>;
+  input_int8(input1: BigNumberish, overrides?: CallOverrides): Promise<number>;
 
-  input_stat_array(input1: BigNumberish[]): Promise<number[]>;
+  input_stat_array(
+    input1: BigNumberish[],
+    overrides?: CallOverrides
+  ): Promise<number[]>;
 
-  input_string(input1: string): Promise<string>;
+  input_string(input1: string, overrides?: CallOverrides): Promise<string>;
 
-  input_struct(input1: {
-    uint256_0: BigNumberish;
-    uint256_1: BigNumberish;
-  }): Promise<{
+  input_struct(
+    input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
+    overrides?: CallOverrides
+  ): Promise<{
     uint256_0: BigNumber;
     uint256_1: BigNumber;
     0: BigNumber;
@@ -158,46 +281,121 @@ export class DataTypesInput extends Contract {
 
   input_tuple(
     input1: BigNumberish,
-    input2: BigNumberish
+    input2: BigNumberish,
+    overrides?: CallOverrides
   ): Promise<{
     0: BigNumber;
     1: BigNumber;
   }>;
 
-  input_uint256(input1: BigNumberish): Promise<BigNumber>;
+  input_uint256(
+    input1: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
 
-  input_uint8(input1: BigNumberish): Promise<number>;
+  input_uint8(input1: BigNumberish, overrides?: CallOverrides): Promise<number>;
 
-  filters: {};
+  staticCall: {
+    input_address(input1: string, overrides?: CallOverrides): Promise<string>;
 
-  estimate: {
-    input_address(input1: string): Promise<BigNumber>;
+    input_bool(input1: boolean, overrides?: CallOverrides): Promise<boolean>;
 
-    input_bool(input1: boolean): Promise<BigNumber>;
+    input_bytes(input1: BytesLike, overrides?: CallOverrides): Promise<string>;
 
-    input_bytes(input1: Arrayish): Promise<BigNumber>;
+    input_bytes1(input1: BytesLike, overrides?: CallOverrides): Promise<string>;
 
-    input_bytes1(input1: Arrayish): Promise<BigNumber>;
+    input_enum(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<number>;
 
-    input_enum(input1: BigNumberish): Promise<BigNumber>;
+    input_int256(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
 
-    input_int256(input1: BigNumberish): Promise<BigNumber>;
+    input_int8(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<number>;
 
-    input_int8(input1: BigNumberish): Promise<BigNumber>;
+    input_stat_array(
+      input1: BigNumberish[],
+      overrides?: CallOverrides
+    ): Promise<number[]>;
 
-    input_stat_array(input1: BigNumberish[]): Promise<BigNumber>;
+    input_string(input1: string, overrides?: CallOverrides): Promise<string>;
 
-    input_string(input1: string): Promise<BigNumber>;
+    input_struct(
+      input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
+      overrides?: CallOverrides
+    ): Promise<{
+      uint256_0: BigNumber;
+      uint256_1: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
 
+    input_tuple(
+      input1: BigNumberish,
+      input2: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    input_uint256(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    input_uint8(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<number>;
+  };
+
+  filters: {};
+
+  estimateGas: {
+    input_address(input1: string): Promise<BigNumber>;
+    input_bool(input1: boolean): Promise<BigNumber>;
+    input_bytes(input1: BytesLike): Promise<BigNumber>;
+    input_bytes1(input1: BytesLike): Promise<BigNumber>;
+    input_enum(input1: BigNumberish): Promise<BigNumber>;
+    input_int256(input1: BigNumberish): Promise<BigNumber>;
+    input_int8(input1: BigNumberish): Promise<BigNumber>;
+    input_stat_array(input1: BigNumberish[]): Promise<BigNumber>;
+    input_string(input1: string): Promise<BigNumber>;
     input_struct(input1: {
       uint256_0: BigNumberish;
       uint256_1: BigNumberish;
     }): Promise<BigNumber>;
-
     input_tuple(input1: BigNumberish, input2: BigNumberish): Promise<BigNumber>;
-
     input_uint256(input1: BigNumberish): Promise<BigNumber>;
-
     input_uint8(input1: BigNumberish): Promise<BigNumber>;
   };
+
+  populateTransaction: {
+    input_address(input1: string): Promise<PopulatedTransaction>;
+    input_bool(input1: boolean): Promise<PopulatedTransaction>;
+    input_bytes(input1: BytesLike): Promise<PopulatedTransaction>;
+    input_bytes1(input1: BytesLike): Promise<PopulatedTransaction>;
+    input_enum(input1: BigNumberish): Promise<PopulatedTransaction>;
+    input_int256(input1: BigNumberish): Promise<PopulatedTransaction>;
+    input_int8(input1: BigNumberish): Promise<PopulatedTransaction>;
+    input_stat_array(input1: BigNumberish[]): Promise<PopulatedTransaction>;
+    input_string(input1: string): Promise<PopulatedTransaction>;
+    input_struct(input1: {
+      uint256_0: BigNumberish;
+      uint256_1: BigNumberish;
+    }): Promise<PopulatedTransaction>;
+    input_tuple(
+      input1: BigNumberish,
+      input2: BigNumberish
+    ): Promise<PopulatedTransaction>;
+    input_uint256(input1: BigNumberish): Promise<PopulatedTransaction>;
+    input_uint8(input1: BigNumberish): Promise<PopulatedTransaction>;
+  };
 }
diff --git a/packages/target-ethers-v5-test/types/DataTypesInputFactory.ts b/packages/target-ethers-v5-test/types/DataTypesInputContract.ts
similarity index 99%
rename from packages/target-ethers-v5-test/types/DataTypesInputFactory.ts
rename to packages/target-ethers-v5-test/types/DataTypesInputContract.ts
index 34f3fcc78..7305cb107 100644
--- a/packages/target-ethers-v5-test/types/DataTypesInputFactory.ts
+++ b/packages/target-ethers-v5-test/types/DataTypesInputContract.ts
@@ -2,7 +2,7 @@
 /* tslint:disable */
 
 import { Contract, Signer } from "ethers";
-import { Provider } from "ethers/providers";
+import { Provider } from "@ethersproject/providers";
 
 import { DataTypesInput } from "./DataTypesInput";
 
diff --git a/packages/target-ethers-v5-test/types/DataTypesPure.d.ts b/packages/target-ethers-v5-test/types/DataTypesPure.d.ts
index 6e81fa219..6c13e9923 100644
--- a/packages/target-ethers-v5-test/types/DataTypesPure.d.ts
+++ b/packages/target-ethers-v5-test/types/DataTypesPure.d.ts
@@ -1,178 +1,335 @@
 /* Generated by ts-generator ver. 0.0.8 */
 /* tslint:disable */
 
-import { Contract, ContractTransaction, EventFilter, Signer } from "ethers";
-import { Listener, Provider } from "ethers/providers";
-import { Arrayish, BigNumber, BigNumberish, Interface } from "ethers/utils";
 import {
-  TransactionOverrides,
-  TypedEventDescription,
-  TypedFunctionDescription
-} from ".";
-
-interface DataTypesPureInterface extends Interface {
+  ethers,
+  EventFilter,
+  Signer,
+  BigNumber,
+  BigNumberish,
+  PopulatedTransaction
+} from "ethers";
+import {
+  Contract,
+  ContractTransaction,
+  CallOverrides
+} from "@ethersproject/contracts";
+import { BytesLike } from "@ethersproject/bytes";
+import { Listener, Provider } from "@ethersproject/providers";
+import { FunctionFragment, EventFragment, Result } from "@ethersproject/abi";
+
+interface DataTypesPureInterface extends ethers.utils.Interface {
   functions: {
-    pure_address: TypedFunctionDescription<{ encode([]: []): string }>;
-
-    pure_bool: TypedFunctionDescription<{ encode([]: []): string }>;
-
-    pure_bytes: TypedFunctionDescription<{ encode([]: []): string }>;
-
-    pure_bytes1: TypedFunctionDescription<{ encode([]: []): string }>;
-
-    pure_enum: TypedFunctionDescription<{ encode([]: []): string }>;
-
-    pure_int256: TypedFunctionDescription<{ encode([]: []): string }>;
-
-    pure_int8: TypedFunctionDescription<{ encode([]: []): string }>;
-
-    pure_named: TypedFunctionDescription<{ encode([]: []): string }>;
-
-    pure_stat_array: TypedFunctionDescription<{ encode([]: []): string }>;
-
-    pure_string: TypedFunctionDescription<{ encode([]: []): string }>;
-
-    pure_struct: TypedFunctionDescription<{ encode([]: []): string }>;
-
-    pure_tuple: TypedFunctionDescription<{ encode([]: []): string }>;
-
-    pure_uint256: TypedFunctionDescription<{ encode([]: []): string }>;
-
-    pure_uint8: TypedFunctionDescription<{ encode([]: []): string }>;
+    "pure_address()": FunctionFragment;
+    "pure_bool()": FunctionFragment;
+    "pure_bytes()": FunctionFragment;
+    "pure_bytes1()": FunctionFragment;
+    "pure_enum()": FunctionFragment;
+    "pure_int256()": FunctionFragment;
+    "pure_int8()": FunctionFragment;
+    "pure_named()": FunctionFragment;
+    "pure_stat_array()": FunctionFragment;
+    "pure_string()": FunctionFragment;
+    "pure_struct()": FunctionFragment;
+    "pure_tuple()": FunctionFragment;
+    "pure_uint256()": FunctionFragment;
+    "pure_uint8()": FunctionFragment;
   };
 
+  encodeFunctionData(functionFragment: "pure_address", values?: void): string;
+  encodeFunctionData(functionFragment: "pure_bool", values?: void): string;
+  encodeFunctionData(functionFragment: "pure_bytes", values?: void): string;
+  encodeFunctionData(functionFragment: "pure_bytes1", values?: void): string;
+  encodeFunctionData(functionFragment: "pure_enum", values?: void): string;
+  encodeFunctionData(functionFragment: "pure_int256", values?: void): string;
+  encodeFunctionData(functionFragment: "pure_int8", values?: void): string;
+  encodeFunctionData(functionFragment: "pure_named", values?: void): string;
+  encodeFunctionData(
+    functionFragment: "pure_stat_array",
+    values?: void
+  ): string;
+  encodeFunctionData(functionFragment: "pure_string", values?: void): string;
+  encodeFunctionData(functionFragment: "pure_struct", values?: void): string;
+  encodeFunctionData(functionFragment: "pure_tuple", values?: void): string;
+  encodeFunctionData(functionFragment: "pure_uint256", values?: void): string;
+  encodeFunctionData(functionFragment: "pure_uint8", values?: void): string;
+
+  decodeFunctionResult(
+    functionFragment: "pure_address",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "pure_bool", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "pure_bytes", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "pure_bytes1",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "pure_enum", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "pure_int256",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "pure_int8", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "pure_named", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "pure_stat_array",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "pure_string",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "pure_struct",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "pure_tuple", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "pure_uint256",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "pure_uint8", data: BytesLike): Result;
+
   events: {};
 }
 
 export class DataTypesPure extends Contract {
-  connect(signerOrProvider: Signer | Provider | string): DataTypesPure;
-  attach(addressOrName: string): DataTypesPure;
-  deployed(): Promise<DataTypesPure>;
-
-  on(event: EventFilter | string, listener: Listener): DataTypesPure;
-  once(event: EventFilter | string, listener: Listener): DataTypesPure;
-  addListener(
-    eventName: EventFilter | string,
-    listener: Listener
-  ): DataTypesPure;
-  removeAllListeners(eventName: EventFilter | string): DataTypesPure;
-  removeListener(eventName: any, listener: Listener): DataTypesPure;
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  on(event: EventFilter | string, listener: Listener): this;
+  once(event: EventFilter | string, listener: Listener): this;
+  addListener(eventName: EventFilter | string, listener: Listener): this;
+  removeAllListeners(eventName: EventFilter | string): this;
+  removeListener(eventName: any, listener: Listener): this;
 
   interface: DataTypesPureInterface;
 
   functions: {
-    pure_address(): Promise<string>;
+    pure_address(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
 
-    pure_bool(): Promise<boolean>;
+    pure_bool(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: boolean;
+    }>;
 
-    pure_bytes(): Promise<string>;
+    pure_bytes(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
 
-    pure_bytes1(): Promise<string>;
+    pure_bytes1(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
 
-    pure_enum(): Promise<number>;
+    pure_enum(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number;
+    }>;
 
-    pure_int256(): Promise<BigNumber>;
+    pure_int256(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+    }>;
 
-    pure_int8(): Promise<number>;
+    pure_int8(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number;
+    }>;
 
-    pure_named(): Promise<{
+    pure_named(
+      overrides?: CallOverrides
+    ): Promise<{
       uint256_1: BigNumber;
       uint256_2: BigNumber;
       0: BigNumber;
       1: BigNumber;
     }>;
 
-    pure_stat_array(): Promise<number[]>;
+    pure_stat_array(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number[];
+    }>;
 
-    pure_string(): Promise<string>;
+    pure_string(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
 
-    pure_struct(): Promise<{
-      uint256_0: BigNumber;
-      uint256_1: BigNumber;
-      0: BigNumber;
-      1: BigNumber;
+    pure_struct(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: {
+        uint256_0: BigNumber;
+        uint256_1: BigNumber;
+        0: BigNumber;
+        1: BigNumber;
+      };
     }>;
 
-    pure_tuple(): Promise<{
+    pure_tuple(
+      overrides?: CallOverrides
+    ): Promise<{
       0: BigNumber;
       1: BigNumber;
     }>;
 
-    pure_uint256(): Promise<BigNumber>;
+    pure_uint256(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+    }>;
 
-    pure_uint8(): Promise<number>;
+    pure_uint8(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number;
+    }>;
   };
 
-  pure_address(): Promise<string>;
+  pure_address(overrides?: CallOverrides): Promise<string>;
 
-  pure_bool(): Promise<boolean>;
+  pure_bool(overrides?: CallOverrides): Promise<boolean>;
 
-  pure_bytes(): Promise<string>;
+  pure_bytes(overrides?: CallOverrides): Promise<string>;
 
-  pure_bytes1(): Promise<string>;
+  pure_bytes1(overrides?: CallOverrides): Promise<string>;
 
-  pure_enum(): Promise<number>;
+  pure_enum(overrides?: CallOverrides): Promise<number>;
 
-  pure_int256(): Promise<BigNumber>;
+  pure_int256(overrides?: CallOverrides): Promise<BigNumber>;
 
-  pure_int8(): Promise<number>;
+  pure_int8(overrides?: CallOverrides): Promise<number>;
 
-  pure_named(): Promise<{
+  pure_named(
+    overrides?: CallOverrides
+  ): Promise<{
     uint256_1: BigNumber;
     uint256_2: BigNumber;
     0: BigNumber;
     1: BigNumber;
   }>;
 
-  pure_stat_array(): Promise<number[]>;
+  pure_stat_array(overrides?: CallOverrides): Promise<number[]>;
 
-  pure_string(): Promise<string>;
+  pure_string(overrides?: CallOverrides): Promise<string>;
 
-  pure_struct(): Promise<{
+  pure_struct(
+    overrides?: CallOverrides
+  ): Promise<{
     uint256_0: BigNumber;
     uint256_1: BigNumber;
     0: BigNumber;
     1: BigNumber;
   }>;
 
-  pure_tuple(): Promise<{
+  pure_tuple(
+    overrides?: CallOverrides
+  ): Promise<{
     0: BigNumber;
     1: BigNumber;
   }>;
 
-  pure_uint256(): Promise<BigNumber>;
+  pure_uint256(overrides?: CallOverrides): Promise<BigNumber>;
+
+  pure_uint8(overrides?: CallOverrides): Promise<number>;
+
+  staticCall: {
+    pure_address(overrides?: CallOverrides): Promise<string>;
+
+    pure_bool(overrides?: CallOverrides): Promise<boolean>;
+
+    pure_bytes(overrides?: CallOverrides): Promise<string>;
 
-  pure_uint8(): Promise<number>;
+    pure_bytes1(overrides?: CallOverrides): Promise<string>;
+
+    pure_enum(overrides?: CallOverrides): Promise<number>;
+
+    pure_int256(overrides?: CallOverrides): Promise<BigNumber>;
+
+    pure_int8(overrides?: CallOverrides): Promise<number>;
+
+    pure_named(
+      overrides?: CallOverrides
+    ): Promise<{
+      uint256_1: BigNumber;
+      uint256_2: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    pure_stat_array(overrides?: CallOverrides): Promise<number[]>;
+
+    pure_string(overrides?: CallOverrides): Promise<string>;
+
+    pure_struct(
+      overrides?: CallOverrides
+    ): Promise<{
+      uint256_0: BigNumber;
+      uint256_1: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    pure_tuple(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    pure_uint256(overrides?: CallOverrides): Promise<BigNumber>;
+
+    pure_uint8(overrides?: CallOverrides): Promise<number>;
+  };
 
   filters: {};
 
-  estimate: {
+  estimateGas: {
     pure_address(): Promise<BigNumber>;
-
     pure_bool(): Promise<BigNumber>;
-
     pure_bytes(): Promise<BigNumber>;
-
     pure_bytes1(): Promise<BigNumber>;
-
     pure_enum(): Promise<BigNumber>;
-
     pure_int256(): Promise<BigNumber>;
-
     pure_int8(): Promise<BigNumber>;
-
     pure_named(): Promise<BigNumber>;
-
     pure_stat_array(): Promise<BigNumber>;
-
     pure_string(): Promise<BigNumber>;
-
     pure_struct(): Promise<BigNumber>;
-
     pure_tuple(): Promise<BigNumber>;
-
     pure_uint256(): Promise<BigNumber>;
-
     pure_uint8(): Promise<BigNumber>;
   };
+
+  populateTransaction: {
+    pure_address(): Promise<PopulatedTransaction>;
+    pure_bool(): Promise<PopulatedTransaction>;
+    pure_bytes(): Promise<PopulatedTransaction>;
+    pure_bytes1(): Promise<PopulatedTransaction>;
+    pure_enum(): Promise<PopulatedTransaction>;
+    pure_int256(): Promise<PopulatedTransaction>;
+    pure_int8(): Promise<PopulatedTransaction>;
+    pure_named(): Promise<PopulatedTransaction>;
+    pure_stat_array(): Promise<PopulatedTransaction>;
+    pure_string(): Promise<PopulatedTransaction>;
+    pure_struct(): Promise<PopulatedTransaction>;
+    pure_tuple(): Promise<PopulatedTransaction>;
+    pure_uint256(): Promise<PopulatedTransaction>;
+    pure_uint8(): Promise<PopulatedTransaction>;
+  };
 }
diff --git a/packages/target-ethers-v5-test/types/DataTypesPureFactory.ts b/packages/target-ethers-v5-test/types/DataTypesPureContract.ts
similarity index 98%
rename from packages/target-ethers-v5-test/types/DataTypesPureFactory.ts
rename to packages/target-ethers-v5-test/types/DataTypesPureContract.ts
index c0ab0e7af..b42b99a4c 100644
--- a/packages/target-ethers-v5-test/types/DataTypesPureFactory.ts
+++ b/packages/target-ethers-v5-test/types/DataTypesPureContract.ts
@@ -2,7 +2,7 @@
 /* tslint:disable */
 
 import { Contract, Signer } from "ethers";
-import { Provider } from "ethers/providers";
+import { Provider } from "@ethersproject/providers";
 
 import { DataTypesPure } from "./DataTypesPure";
 
diff --git a/packages/target-ethers-v5-test/types/DataTypesView.d.ts b/packages/target-ethers-v5-test/types/DataTypesView.d.ts
index d489c6ba3..80b9334f9 100644
--- a/packages/target-ethers-v5-test/types/DataTypesView.d.ts
+++ b/packages/target-ethers-v5-test/types/DataTypesView.d.ts
@@ -1,178 +1,335 @@
 /* Generated by ts-generator ver. 0.0.8 */
 /* tslint:disable */
 
-import { Contract, ContractTransaction, EventFilter, Signer } from "ethers";
-import { Listener, Provider } from "ethers/providers";
-import { Arrayish, BigNumber, BigNumberish, Interface } from "ethers/utils";
 import {
-  TransactionOverrides,
-  TypedEventDescription,
-  TypedFunctionDescription
-} from ".";
-
-interface DataTypesViewInterface extends Interface {
+  ethers,
+  EventFilter,
+  Signer,
+  BigNumber,
+  BigNumberish,
+  PopulatedTransaction
+} from "ethers";
+import {
+  Contract,
+  ContractTransaction,
+  CallOverrides
+} from "@ethersproject/contracts";
+import { BytesLike } from "@ethersproject/bytes";
+import { Listener, Provider } from "@ethersproject/providers";
+import { FunctionFragment, EventFragment, Result } from "@ethersproject/abi";
+
+interface DataTypesViewInterface extends ethers.utils.Interface {
   functions: {
-    view_address: TypedFunctionDescription<{ encode([]: []): string }>;
-
-    view_bool: TypedFunctionDescription<{ encode([]: []): string }>;
-
-    view_bytes: TypedFunctionDescription<{ encode([]: []): string }>;
-
-    view_bytes1: TypedFunctionDescription<{ encode([]: []): string }>;
-
-    view_enum: TypedFunctionDescription<{ encode([]: []): string }>;
-
-    view_int256: TypedFunctionDescription<{ encode([]: []): string }>;
-
-    view_int8: TypedFunctionDescription<{ encode([]: []): string }>;
-
-    view_named: TypedFunctionDescription<{ encode([]: []): string }>;
-
-    view_stat_array: TypedFunctionDescription<{ encode([]: []): string }>;
-
-    view_string: TypedFunctionDescription<{ encode([]: []): string }>;
-
-    view_struct: TypedFunctionDescription<{ encode([]: []): string }>;
-
-    view_tuple: TypedFunctionDescription<{ encode([]: []): string }>;
-
-    view_uint256: TypedFunctionDescription<{ encode([]: []): string }>;
-
-    view_uint8: TypedFunctionDescription<{ encode([]: []): string }>;
+    "view_address()": FunctionFragment;
+    "view_bool()": FunctionFragment;
+    "view_bytes()": FunctionFragment;
+    "view_bytes1()": FunctionFragment;
+    "view_enum()": FunctionFragment;
+    "view_int256()": FunctionFragment;
+    "view_int8()": FunctionFragment;
+    "view_named()": FunctionFragment;
+    "view_stat_array()": FunctionFragment;
+    "view_string()": FunctionFragment;
+    "view_struct()": FunctionFragment;
+    "view_tuple()": FunctionFragment;
+    "view_uint256()": FunctionFragment;
+    "view_uint8()": FunctionFragment;
   };
 
+  encodeFunctionData(functionFragment: "view_address", values?: void): string;
+  encodeFunctionData(functionFragment: "view_bool", values?: void): string;
+  encodeFunctionData(functionFragment: "view_bytes", values?: void): string;
+  encodeFunctionData(functionFragment: "view_bytes1", values?: void): string;
+  encodeFunctionData(functionFragment: "view_enum", values?: void): string;
+  encodeFunctionData(functionFragment: "view_int256", values?: void): string;
+  encodeFunctionData(functionFragment: "view_int8", values?: void): string;
+  encodeFunctionData(functionFragment: "view_named", values?: void): string;
+  encodeFunctionData(
+    functionFragment: "view_stat_array",
+    values?: void
+  ): string;
+  encodeFunctionData(functionFragment: "view_string", values?: void): string;
+  encodeFunctionData(functionFragment: "view_struct", values?: void): string;
+  encodeFunctionData(functionFragment: "view_tuple", values?: void): string;
+  encodeFunctionData(functionFragment: "view_uint256", values?: void): string;
+  encodeFunctionData(functionFragment: "view_uint8", values?: void): string;
+
+  decodeFunctionResult(
+    functionFragment: "view_address",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "view_bool", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "view_bytes", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "view_bytes1",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "view_enum", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "view_int256",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "view_int8", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "view_named", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "view_stat_array",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "view_string",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "view_struct",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "view_tuple", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "view_uint256",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "view_uint8", data: BytesLike): Result;
+
   events: {};
 }
 
 export class DataTypesView extends Contract {
-  connect(signerOrProvider: Signer | Provider | string): DataTypesView;
-  attach(addressOrName: string): DataTypesView;
-  deployed(): Promise<DataTypesView>;
-
-  on(event: EventFilter | string, listener: Listener): DataTypesView;
-  once(event: EventFilter | string, listener: Listener): DataTypesView;
-  addListener(
-    eventName: EventFilter | string,
-    listener: Listener
-  ): DataTypesView;
-  removeAllListeners(eventName: EventFilter | string): DataTypesView;
-  removeListener(eventName: any, listener: Listener): DataTypesView;
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  on(event: EventFilter | string, listener: Listener): this;
+  once(event: EventFilter | string, listener: Listener): this;
+  addListener(eventName: EventFilter | string, listener: Listener): this;
+  removeAllListeners(eventName: EventFilter | string): this;
+  removeListener(eventName: any, listener: Listener): this;
 
   interface: DataTypesViewInterface;
 
   functions: {
-    view_address(): Promise<string>;
+    view_address(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
 
-    view_bool(): Promise<boolean>;
+    view_bool(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: boolean;
+    }>;
 
-    view_bytes(): Promise<string>;
+    view_bytes(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
 
-    view_bytes1(): Promise<string>;
+    view_bytes1(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
 
-    view_enum(): Promise<number>;
+    view_enum(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number;
+    }>;
 
-    view_int256(): Promise<BigNumber>;
+    view_int256(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+    }>;
 
-    view_int8(): Promise<number>;
+    view_int8(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number;
+    }>;
 
-    view_named(): Promise<{
+    view_named(
+      overrides?: CallOverrides
+    ): Promise<{
       uint256_1: BigNumber;
       uint256_2: BigNumber;
       0: BigNumber;
       1: BigNumber;
     }>;
 
-    view_stat_array(): Promise<number[]>;
+    view_stat_array(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number[];
+    }>;
 
-    view_string(): Promise<string>;
+    view_string(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
 
-    view_struct(): Promise<{
-      uint256_0: BigNumber;
-      uint256_1: BigNumber;
-      0: BigNumber;
-      1: BigNumber;
+    view_struct(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: {
+        uint256_0: BigNumber;
+        uint256_1: BigNumber;
+        0: BigNumber;
+        1: BigNumber;
+      };
     }>;
 
-    view_tuple(): Promise<{
+    view_tuple(
+      overrides?: CallOverrides
+    ): Promise<{
       0: BigNumber;
       1: BigNumber;
     }>;
 
-    view_uint256(): Promise<BigNumber>;
+    view_uint256(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+    }>;
 
-    view_uint8(): Promise<number>;
+    view_uint8(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number;
+    }>;
   };
 
-  view_address(): Promise<string>;
+  view_address(overrides?: CallOverrides): Promise<string>;
 
-  view_bool(): Promise<boolean>;
+  view_bool(overrides?: CallOverrides): Promise<boolean>;
 
-  view_bytes(): Promise<string>;
+  view_bytes(overrides?: CallOverrides): Promise<string>;
 
-  view_bytes1(): Promise<string>;
+  view_bytes1(overrides?: CallOverrides): Promise<string>;
 
-  view_enum(): Promise<number>;
+  view_enum(overrides?: CallOverrides): Promise<number>;
 
-  view_int256(): Promise<BigNumber>;
+  view_int256(overrides?: CallOverrides): Promise<BigNumber>;
 
-  view_int8(): Promise<number>;
+  view_int8(overrides?: CallOverrides): Promise<number>;
 
-  view_named(): Promise<{
+  view_named(
+    overrides?: CallOverrides
+  ): Promise<{
     uint256_1: BigNumber;
     uint256_2: BigNumber;
     0: BigNumber;
     1: BigNumber;
   }>;
 
-  view_stat_array(): Promise<number[]>;
+  view_stat_array(overrides?: CallOverrides): Promise<number[]>;
 
-  view_string(): Promise<string>;
+  view_string(overrides?: CallOverrides): Promise<string>;
 
-  view_struct(): Promise<{
+  view_struct(
+    overrides?: CallOverrides
+  ): Promise<{
     uint256_0: BigNumber;
     uint256_1: BigNumber;
     0: BigNumber;
     1: BigNumber;
   }>;
 
-  view_tuple(): Promise<{
+  view_tuple(
+    overrides?: CallOverrides
+  ): Promise<{
     0: BigNumber;
     1: BigNumber;
   }>;
 
-  view_uint256(): Promise<BigNumber>;
+  view_uint256(overrides?: CallOverrides): Promise<BigNumber>;
+
+  view_uint8(overrides?: CallOverrides): Promise<number>;
+
+  staticCall: {
+    view_address(overrides?: CallOverrides): Promise<string>;
+
+    view_bool(overrides?: CallOverrides): Promise<boolean>;
+
+    view_bytes(overrides?: CallOverrides): Promise<string>;
 
-  view_uint8(): Promise<number>;
+    view_bytes1(overrides?: CallOverrides): Promise<string>;
+
+    view_enum(overrides?: CallOverrides): Promise<number>;
+
+    view_int256(overrides?: CallOverrides): Promise<BigNumber>;
+
+    view_int8(overrides?: CallOverrides): Promise<number>;
+
+    view_named(
+      overrides?: CallOverrides
+    ): Promise<{
+      uint256_1: BigNumber;
+      uint256_2: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    view_stat_array(overrides?: CallOverrides): Promise<number[]>;
+
+    view_string(overrides?: CallOverrides): Promise<string>;
+
+    view_struct(
+      overrides?: CallOverrides
+    ): Promise<{
+      uint256_0: BigNumber;
+      uint256_1: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    view_tuple(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    view_uint256(overrides?: CallOverrides): Promise<BigNumber>;
+
+    view_uint8(overrides?: CallOverrides): Promise<number>;
+  };
 
   filters: {};
 
-  estimate: {
+  estimateGas: {
     view_address(): Promise<BigNumber>;
-
     view_bool(): Promise<BigNumber>;
-
     view_bytes(): Promise<BigNumber>;
-
     view_bytes1(): Promise<BigNumber>;
-
     view_enum(): Promise<BigNumber>;
-
     view_int256(): Promise<BigNumber>;
-
     view_int8(): Promise<BigNumber>;
-
     view_named(): Promise<BigNumber>;
-
     view_stat_array(): Promise<BigNumber>;
-
     view_string(): Promise<BigNumber>;
-
     view_struct(): Promise<BigNumber>;
-
     view_tuple(): Promise<BigNumber>;
-
     view_uint256(): Promise<BigNumber>;
-
     view_uint8(): Promise<BigNumber>;
   };
+
+  populateTransaction: {
+    view_address(): Promise<PopulatedTransaction>;
+    view_bool(): Promise<PopulatedTransaction>;
+    view_bytes(): Promise<PopulatedTransaction>;
+    view_bytes1(): Promise<PopulatedTransaction>;
+    view_enum(): Promise<PopulatedTransaction>;
+    view_int256(): Promise<PopulatedTransaction>;
+    view_int8(): Promise<PopulatedTransaction>;
+    view_named(): Promise<PopulatedTransaction>;
+    view_stat_array(): Promise<PopulatedTransaction>;
+    view_string(): Promise<PopulatedTransaction>;
+    view_struct(): Promise<PopulatedTransaction>;
+    view_tuple(): Promise<PopulatedTransaction>;
+    view_uint256(): Promise<PopulatedTransaction>;
+    view_uint8(): Promise<PopulatedTransaction>;
+  };
 }
diff --git a/packages/target-ethers-v5-test/types/DataTypesViewFactory.ts b/packages/target-ethers-v5-test/types/DataTypesViewContract.ts
similarity index 98%
rename from packages/target-ethers-v5-test/types/DataTypesViewFactory.ts
rename to packages/target-ethers-v5-test/types/DataTypesViewContract.ts
index d1a7c9e14..2140a2f31 100644
--- a/packages/target-ethers-v5-test/types/DataTypesViewFactory.ts
+++ b/packages/target-ethers-v5-test/types/DataTypesViewContract.ts
@@ -2,7 +2,7 @@
 /* tslint:disable */
 
 import { Contract, Signer } from "ethers";
-import { Provider } from "ethers/providers";
+import { Provider } from "@ethersproject/providers";
 
 import { DataTypesView } from "./DataTypesView";
 
diff --git a/packages/target-ethers-v5-test/types/Events.d.ts b/packages/target-ethers-v5-test/types/Events.d.ts
index 21dd4fd1c..152164cd3 100644
--- a/packages/target-ethers-v5-test/types/Events.d.ts
+++ b/packages/target-ethers-v5-test/types/Events.d.ts
@@ -1,85 +1,118 @@
 /* Generated by ts-generator ver. 0.0.8 */
 /* tslint:disable */
 
-import { Contract, ContractTransaction, EventFilter, Signer } from "ethers";
-import { Listener, Provider } from "ethers/providers";
-import { Arrayish, BigNumber, BigNumberish, Interface } from "ethers/utils";
 import {
-  TransactionOverrides,
-  TypedEventDescription,
-  TypedFunctionDescription
-} from ".";
-
-interface EventsInterface extends Interface {
+  ethers,
+  EventFilter,
+  Signer,
+  BigNumber,
+  BigNumberish,
+  PopulatedTransaction
+} from "ethers";
+import {
+  Contract,
+  ContractTransaction,
+  Overrides
+} from "@ethersproject/contracts";
+import { BytesLike } from "@ethersproject/bytes";
+import { Listener, Provider } from "@ethersproject/providers";
+import { FunctionFragment, EventFragment, Result } from "@ethersproject/abi";
+
+interface EventsInterface extends ethers.utils.Interface {
   functions: {
-    emit_anon1: TypedFunctionDescription<{ encode([]: []): string }>;
-
-    emit_event1: TypedFunctionDescription<{ encode([]: []): string }>;
-
-    emit_event2: TypedFunctionDescription<{ encode([]: []): string }>;
-
-    emit_event3: TypedFunctionDescription<{ encode([]: []): string }>;
-
-    emit_event3_overloaded: TypedFunctionDescription<{
-      encode([]: []): string;
-    }>;
+    "emit_anon1()": FunctionFragment;
+    "emit_event1()": FunctionFragment;
+    "emit_event2()": FunctionFragment;
+    "emit_event3()": FunctionFragment;
+    "emit_event3_overloaded()": FunctionFragment;
   };
 
-  events: {
-    AnonEvent1: TypedEventDescription<{
-      encodeTopics([value1]: [BigNumberish | null]): string[];
-    }>;
-
-    Event1: TypedEventDescription<{
-      encodeTopics([value1, value2]: [BigNumberish | null, null]): string[];
-    }>;
-
-    Event2: TypedEventDescription<{ encodeTopics([]: [null]): string[] }>;
+  encodeFunctionData(functionFragment: "emit_anon1", values?: void): string;
+  encodeFunctionData(functionFragment: "emit_event1", values?: void): string;
+  encodeFunctionData(functionFragment: "emit_event2", values?: void): string;
+  encodeFunctionData(functionFragment: "emit_event3", values?: void): string;
+  encodeFunctionData(
+    functionFragment: "emit_event3_overloaded",
+    values?: void
+  ): string;
+
+  decodeFunctionResult(functionFragment: "emit_anon1", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "emit_event1",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "emit_event2",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "emit_event3",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "emit_event3_overloaded",
+    data: BytesLike
+  ): Result;
 
-    Event3: TypedEventDescription<{
-      encodeTopics([value1, value2]: [boolean | null, null]): string[];
-    }>;
+  events: {
+    "AnonEvent1(uint256)": EventFragment;
+    "Event1(uint256,uint256)": EventFragment;
+    "Event2(uint256)": EventFragment;
+    "Event3(bool,uint256)": EventFragment;
   };
+
+  getEvent(nameOrSignatureOrTopic: "AnonEvent1"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "Event1"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "Event2"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "Event3"): EventFragment;
 }
 
 export class Events extends Contract {
-  connect(signerOrProvider: Signer | Provider | string): Events;
-  attach(addressOrName: string): Events;
-  deployed(): Promise<Events>;
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
 
-  on(event: EventFilter | string, listener: Listener): Events;
-  once(event: EventFilter | string, listener: Listener): Events;
-  addListener(eventName: EventFilter | string, listener: Listener): Events;
-  removeAllListeners(eventName: EventFilter | string): Events;
-  removeListener(eventName: any, listener: Listener): Events;
+  on(event: EventFilter | string, listener: Listener): this;
+  once(event: EventFilter | string, listener: Listener): this;
+  addListener(eventName: EventFilter | string, listener: Listener): this;
+  removeAllListeners(eventName: EventFilter | string): this;
+  removeListener(eventName: any, listener: Listener): this;
 
   interface: EventsInterface;
 
   functions: {
-    emit_anon1(overrides?: TransactionOverrides): Promise<ContractTransaction>;
+    emit_anon1(overrides?: Overrides): Promise<ContractTransaction>;
 
-    emit_event1(overrides?: TransactionOverrides): Promise<ContractTransaction>;
+    emit_event1(overrides?: Overrides): Promise<ContractTransaction>;
 
-    emit_event2(overrides?: TransactionOverrides): Promise<ContractTransaction>;
+    emit_event2(overrides?: Overrides): Promise<ContractTransaction>;
 
-    emit_event3(overrides?: TransactionOverrides): Promise<ContractTransaction>;
+    emit_event3(overrides?: Overrides): Promise<ContractTransaction>;
 
-    emit_event3_overloaded(
-      overrides?: TransactionOverrides
-    ): Promise<ContractTransaction>;
+    emit_event3_overloaded(overrides?: Overrides): Promise<ContractTransaction>;
   };
 
-  emit_anon1(overrides?: TransactionOverrides): Promise<ContractTransaction>;
+  emit_anon1(overrides?: Overrides): Promise<ContractTransaction>;
+
+  emit_event1(overrides?: Overrides): Promise<ContractTransaction>;
 
-  emit_event1(overrides?: TransactionOverrides): Promise<ContractTransaction>;
+  emit_event2(overrides?: Overrides): Promise<ContractTransaction>;
 
-  emit_event2(overrides?: TransactionOverrides): Promise<ContractTransaction>;
+  emit_event3(overrides?: Overrides): Promise<ContractTransaction>;
 
-  emit_event3(overrides?: TransactionOverrides): Promise<ContractTransaction>;
+  emit_event3_overloaded(overrides?: Overrides): Promise<ContractTransaction>;
 
-  emit_event3_overloaded(
-    overrides?: TransactionOverrides
-  ): Promise<ContractTransaction>;
+  staticCall: {
+    emit_anon1(overrides?: Overrides): Promise<void>;
+
+    emit_event1(overrides?: Overrides): Promise<void>;
+
+    emit_event2(overrides?: Overrides): Promise<void>;
+
+    emit_event3(overrides?: Overrides): Promise<void>;
+
+    emit_event3_overloaded(overrides?: Overrides): Promise<void>;
+  };
 
   filters: {
     AnonEvent1(value1: BigNumberish | null): EventFilter;
@@ -91,15 +124,19 @@ export class Events extends Contract {
     Event3(value1: boolean | null, value2: null): EventFilter;
   };
 
-  estimate: {
+  estimateGas: {
     emit_anon1(): Promise<BigNumber>;
-
     emit_event1(): Promise<BigNumber>;
-
     emit_event2(): Promise<BigNumber>;
-
     emit_event3(): Promise<BigNumber>;
-
     emit_event3_overloaded(): Promise<BigNumber>;
   };
+
+  populateTransaction: {
+    emit_anon1(): Promise<PopulatedTransaction>;
+    emit_event1(): Promise<PopulatedTransaction>;
+    emit_event2(): Promise<PopulatedTransaction>;
+    emit_event3(): Promise<PopulatedTransaction>;
+    emit_event3_overloaded(): Promise<PopulatedTransaction>;
+  };
 }
diff --git a/packages/target-ethers-v5-test/types/EventsFactory.ts b/packages/target-ethers-v5-test/types/EventsContract.ts
similarity index 97%
rename from packages/target-ethers-v5-test/types/EventsFactory.ts
rename to packages/target-ethers-v5-test/types/EventsContract.ts
index cec0acf94..b9c613478 100644
--- a/packages/target-ethers-v5-test/types/EventsFactory.ts
+++ b/packages/target-ethers-v5-test/types/EventsContract.ts
@@ -2,7 +2,7 @@
 /* tslint:disable */
 
 import { Contract, Signer } from "ethers";
-import { Provider } from "ethers/providers";
+import { Provider } from "@ethersproject/providers";
 
 import { Events } from "./Events";
 
diff --git a/packages/target-ethers-v5-test/types/NameMangling.d.ts b/packages/target-ethers-v5-test/types/NameMangling.d.ts
index 5edbd9e8e..df5c38b79 100644
--- a/packages/target-ethers-v5-test/types/NameMangling.d.ts
+++ b/packages/target-ethers-v5-test/types/NameMangling.d.ts
@@ -1,48 +1,69 @@
 /* Generated by ts-generator ver. 0.0.8 */
 /* tslint:disable */
 
-import { Contract, ContractTransaction, EventFilter, Signer } from "ethers";
-import { Listener, Provider } from "ethers/providers";
-import { Arrayish, BigNumber, BigNumberish, Interface } from "ethers/utils";
 import {
-  TransactionOverrides,
-  TypedEventDescription,
-  TypedFunctionDescription
-} from ".";
+  ethers,
+  EventFilter,
+  Signer,
+  BigNumber,
+  BigNumberish,
+  PopulatedTransaction
+} from "ethers";
+import {
+  Contract,
+  ContractTransaction,
+  CallOverrides
+} from "@ethersproject/contracts";
+import { BytesLike } from "@ethersproject/bytes";
+import { Listener, Provider } from "@ethersproject/providers";
+import { FunctionFragment, EventFragment, Result } from "@ethersproject/abi";
 
-interface NameManglingInterface extends Interface {
+interface NameManglingInterface extends ethers.utils.Interface {
   functions: {
-    works: TypedFunctionDescription<{ encode([]: []): string }>;
+    "works()": FunctionFragment;
   };
 
+  encodeFunctionData(functionFragment: "works", values?: void): string;
+
+  decodeFunctionResult(functionFragment: "works", data: BytesLike): Result;
+
   events: {};
 }
 
 export class NameMangling extends Contract {
-  connect(signerOrProvider: Signer | Provider | string): NameMangling;
-  attach(addressOrName: string): NameMangling;
-  deployed(): Promise<NameMangling>;
-
-  on(event: EventFilter | string, listener: Listener): NameMangling;
-  once(event: EventFilter | string, listener: Listener): NameMangling;
-  addListener(
-    eventName: EventFilter | string,
-    listener: Listener
-  ): NameMangling;
-  removeAllListeners(eventName: EventFilter | string): NameMangling;
-  removeListener(eventName: any, listener: Listener): NameMangling;
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  on(event: EventFilter | string, listener: Listener): this;
+  once(event: EventFilter | string, listener: Listener): this;
+  addListener(eventName: EventFilter | string, listener: Listener): this;
+  removeAllListeners(eventName: EventFilter | string): this;
+  removeListener(eventName: any, listener: Listener): this;
 
   interface: NameManglingInterface;
 
   functions: {
-    works(): Promise<boolean>;
+    works(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: boolean;
+    }>;
   };
 
-  works(): Promise<boolean>;
+  works(overrides?: CallOverrides): Promise<boolean>;
+
+  staticCall: {
+    works(overrides?: CallOverrides): Promise<boolean>;
+  };
 
   filters: {};
 
-  estimate: {
+  estimateGas: {
     works(): Promise<BigNumber>;
   };
+
+  populateTransaction: {
+    works(): Promise<PopulatedTransaction>;
+  };
 }
diff --git a/packages/target-ethers-v5-test/types/NameManglingFactory.ts b/packages/target-ethers-v5-test/types/NameManglingContract.ts
similarity index 91%
rename from packages/target-ethers-v5-test/types/NameManglingFactory.ts
rename to packages/target-ethers-v5-test/types/NameManglingContract.ts
index f2e0b5796..af158f2a5 100644
--- a/packages/target-ethers-v5-test/types/NameManglingFactory.ts
+++ b/packages/target-ethers-v5-test/types/NameManglingContract.ts
@@ -2,7 +2,7 @@
 /* tslint:disable */
 
 import { Contract, Signer } from "ethers";
-import { Provider } from "ethers/providers";
+import { Provider } from "@ethersproject/providers";
 
 import { NameMangling } from "./NameMangling";
 
diff --git a/packages/target-ethers-v5-test/types/Overloads.d.ts b/packages/target-ethers-v5-test/types/Overloads.d.ts
index 73ed4f205..1d4b534ad 100644
--- a/packages/target-ethers-v5-test/types/Overloads.d.ts
+++ b/packages/target-ethers-v5-test/types/Overloads.d.ts
@@ -1,57 +1,99 @@
 /* Generated by ts-generator ver. 0.0.8 */
 /* tslint:disable */
 
-import { Contract, ContractTransaction, EventFilter, Signer } from "ethers";
-import { Listener, Provider } from "ethers/providers";
-import { Arrayish, BigNumber, BigNumberish, Interface } from "ethers/utils";
 import {
-  TransactionOverrides,
-  TypedEventDescription,
-  TypedFunctionDescription
-} from ".";
+  ethers,
+  EventFilter,
+  Signer,
+  BigNumber,
+  BigNumberish,
+  PopulatedTransaction
+} from "ethers";
+import {
+  Contract,
+  ContractTransaction,
+  CallOverrides
+} from "@ethersproject/contracts";
+import { BytesLike } from "@ethersproject/bytes";
+import { Listener, Provider } from "@ethersproject/providers";
+import { FunctionFragment, EventFragment, Result } from "@ethersproject/abi";
 
-interface OverloadsInterface extends Interface {
+interface OverloadsInterface extends ethers.utils.Interface {
   functions: {
-    overload1: TypedFunctionDescription<{
-      encode([input1]: [BigNumberish]): string;
-    }>;
+    "overload1(int256)": FunctionFragment;
   };
 
+  encodeFunctionData(
+    functionFragment: "overload1",
+    values: [BigNumberish]
+  ): string;
+
+  decodeFunctionResult(functionFragment: "overload1", data: BytesLike): Result;
+
   events: {};
 }
 
 export class Overloads extends Contract {
-  connect(signerOrProvider: Signer | Provider | string): Overloads;
-  attach(addressOrName: string): Overloads;
-  deployed(): Promise<Overloads>;
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
 
-  on(event: EventFilter | string, listener: Listener): Overloads;
-  once(event: EventFilter | string, listener: Listener): Overloads;
-  addListener(eventName: EventFilter | string, listener: Listener): Overloads;
-  removeAllListeners(eventName: EventFilter | string): Overloads;
-  removeListener(eventName: any, listener: Listener): Overloads;
+  on(event: EventFilter | string, listener: Listener): this;
+  once(event: EventFilter | string, listener: Listener): this;
+  addListener(eventName: EventFilter | string, listener: Listener): this;
+  removeAllListeners(eventName: EventFilter | string): this;
+  removeListener(eventName: any, listener: Listener): this;
 
   interface: OverloadsInterface;
 
   functions: {
-    "overload1(int256)"(input1: BigNumberish): Promise<BigNumber>;
+    "overload1(int256)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+    }>;
 
     "overload1(uint256,uint256)"(
       input1: BigNumberish,
-      input2: BigNumberish
-    ): Promise<BigNumber>;
+      input2: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+    }>;
   };
 
-  "overload1(int256)"(input1: BigNumberish): Promise<BigNumber>;
+  "overload1(int256)"(
+    input1: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
 
   "overload1(uint256,uint256)"(
     input1: BigNumberish,
-    input2: BigNumberish
+    input2: BigNumberish,
+    overrides?: CallOverrides
   ): Promise<BigNumber>;
 
+  staticCall: {
+    "overload1(int256)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    "overload1(uint256,uint256)"(
+      input1: BigNumberish,
+      input2: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+  };
+
   filters: {};
 
-  estimate: {
+  estimateGas: {
     overload1(input1: BigNumberish): Promise<BigNumber>;
   };
+
+  populateTransaction: {
+    overload1(input1: BigNumberish): Promise<PopulatedTransaction>;
+  };
 }
diff --git a/packages/target-ethers-v5-test/types/OverloadsFactory.ts b/packages/target-ethers-v5-test/types/OverloadsContract.ts
similarity index 95%
rename from packages/target-ethers-v5-test/types/OverloadsFactory.ts
rename to packages/target-ethers-v5-test/types/OverloadsContract.ts
index 5aa7f5a44..9abb149e9 100644
--- a/packages/target-ethers-v5-test/types/OverloadsFactory.ts
+++ b/packages/target-ethers-v5-test/types/OverloadsContract.ts
@@ -2,7 +2,7 @@
 /* tslint:disable */
 
 import { Contract, Signer } from "ethers";
-import { Provider } from "ethers/providers";
+import { Provider } from "@ethersproject/providers";
 
 import { Overloads } from "./Overloads";
 
diff --git a/packages/target-ethers-v5-test/types/Payable.d.ts b/packages/target-ethers-v5-test/types/Payable.d.ts
index c36e141ef..8dc833a20 100644
--- a/packages/target-ethers-v5-test/types/Payable.d.ts
+++ b/packages/target-ethers-v5-test/types/Payable.d.ts
@@ -1,59 +1,86 @@
 /* Generated by ts-generator ver. 0.0.8 */
 /* tslint:disable */
 
-import { Contract, ContractTransaction, EventFilter, Signer } from "ethers";
-import { Listener, Provider } from "ethers/providers";
-import { Arrayish, BigNumber, BigNumberish, Interface } from "ethers/utils";
 import {
-  TransactionOverrides,
-  TypedEventDescription,
-  TypedFunctionDescription
-} from ".";
+  ethers,
+  EventFilter,
+  Signer,
+  BigNumber,
+  BigNumberish,
+  PopulatedTransaction
+} from "ethers";
+import {
+  Contract,
+  ContractTransaction,
+  Overrides,
+  PayableOverrides
+} from "@ethersproject/contracts";
+import { BytesLike } from "@ethersproject/bytes";
+import { Listener, Provider } from "@ethersproject/providers";
+import { FunctionFragment, EventFragment, Result } from "@ethersproject/abi";
 
-interface PayableInterface extends Interface {
+interface PayableInterface extends ethers.utils.Interface {
   functions: {
-    non_payable_func: TypedFunctionDescription<{ encode([]: []): string }>;
-
-    payable_func: TypedFunctionDescription<{ encode([]: []): string }>;
+    "non_payable_func()": FunctionFragment;
+    "payable_func()": FunctionFragment;
   };
 
+  encodeFunctionData(
+    functionFragment: "non_payable_func",
+    values?: void
+  ): string;
+  encodeFunctionData(functionFragment: "payable_func", values?: void): string;
+
+  decodeFunctionResult(
+    functionFragment: "non_payable_func",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "payable_func",
+    data: BytesLike
+  ): Result;
+
   events: {};
 }
 
 export class Payable extends Contract {
-  connect(signerOrProvider: Signer | Provider | string): Payable;
-  attach(addressOrName: string): Payable;
-  deployed(): Promise<Payable>;
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
 
-  on(event: EventFilter | string, listener: Listener): Payable;
-  once(event: EventFilter | string, listener: Listener): Payable;
-  addListener(eventName: EventFilter | string, listener: Listener): Payable;
-  removeAllListeners(eventName: EventFilter | string): Payable;
-  removeListener(eventName: any, listener: Listener): Payable;
+  on(event: EventFilter | string, listener: Listener): this;
+  once(event: EventFilter | string, listener: Listener): this;
+  addListener(eventName: EventFilter | string, listener: Listener): this;
+  removeAllListeners(eventName: EventFilter | string): this;
+  removeListener(eventName: any, listener: Listener): this;
 
   interface: PayableInterface;
 
   functions: {
-    non_payable_func(
-      overrides?: TransactionOverrides
-    ): Promise<ContractTransaction>;
+    non_payable_func(overrides?: Overrides): Promise<ContractTransaction>;
 
-    payable_func(
-      overrides?: TransactionOverrides
-    ): Promise<ContractTransaction>;
+    payable_func(overrides?: PayableOverrides): Promise<ContractTransaction>;
   };
 
-  non_payable_func(
-    overrides?: TransactionOverrides
-  ): Promise<ContractTransaction>;
+  non_payable_func(overrides?: Overrides): Promise<ContractTransaction>;
+
+  payable_func(overrides?: PayableOverrides): Promise<ContractTransaction>;
 
-  payable_func(overrides?: TransactionOverrides): Promise<ContractTransaction>;
+  staticCall: {
+    non_payable_func(overrides?: Overrides): Promise<void>;
+
+    payable_func(overrides?: PayableOverrides): Promise<void>;
+  };
 
   filters: {};
 
-  estimate: {
+  estimateGas: {
     non_payable_func(): Promise<BigNumber>;
-
     payable_func(): Promise<BigNumber>;
   };
+
+  populateTransaction: {
+    non_payable_func(): Promise<PopulatedTransaction>;
+    payable_func(): Promise<PopulatedTransaction>;
+  };
 }
diff --git a/packages/target-ethers-v5-test/types/PayableFactory.ts b/packages/target-ethers-v5-test/types/PayableContract.ts
similarity index 92%
rename from packages/target-ethers-v5-test/types/PayableFactory.ts
rename to packages/target-ethers-v5-test/types/PayableContract.ts
index 1fbc7d681..dd9dbf766 100644
--- a/packages/target-ethers-v5-test/types/PayableFactory.ts
+++ b/packages/target-ethers-v5-test/types/PayableContract.ts
@@ -2,7 +2,7 @@
 /* tslint:disable */
 
 import { Contract, Signer } from "ethers";
-import { Provider } from "ethers/providers";
+import { Provider } from "@ethersproject/providers";
 
 import { Payable } from "./Payable";
 
diff --git a/packages/target-ethers-v5-test/types/index.d.ts b/packages/target-ethers-v5-test/types/index.d.ts
deleted file mode 100644
index 93c86106f..000000000
--- a/packages/target-ethers-v5-test/types/index.d.ts
+++ /dev/null
@@ -1,27 +0,0 @@
-/* Generated by ts-generator ver. 0.0.8 */
-/* tslint:disable */
-import {
-  BigNumberish,
-  EventDescription,
-  FunctionDescription
-} from "ethers/utils";
-
-export class TransactionOverrides {
-  nonce?: BigNumberish | Promise<BigNumberish>;
-  gasLimit?: BigNumberish | Promise<BigNumberish>;
-  gasPrice?: BigNumberish | Promise<BigNumberish>;
-  value?: BigNumberish | Promise<BigNumberish>;
-  chainId?: number | Promise<number>;
-}
-
-export interface TypedEventDescription<
-  T extends Pick<EventDescription, "encodeTopics">
-> extends EventDescription {
-  encodeTopics: T["encodeTopics"];
-}
-
-export interface TypedFunctionDescription<
-  T extends Pick<FunctionDescription, "encode">
-> extends FunctionDescription {
-  encode: T["encode"];
-}
diff --git a/packages/target-ethers-v5-test/types/index.ts b/packages/target-ethers-v5-test/types/index.ts
new file mode 100644
index 000000000..ce9f1dac4
--- /dev/null
+++ b/packages/target-ethers-v5-test/types/index.ts
@@ -0,0 +1,2 @@
+/* Generated by ts-generator ver. 0.0.8 */
+/* tslint:disable */

From 4c57d755dadc0f38c34b5c418b8f4622e014913b Mon Sep 17 00:00:00 2001
From: zemse <sohamzemse143@gmail.com>
Date: Sun, 28 Jun 2020 17:50:35 +0530
Subject: [PATCH 36/64] Update tests for ethers v5

---
 .../test/DataTypesInput.test.ts               | 22 +++++++++----------
 .../test/Overload.test.ts                     | 10 ++++-----
 packages/target-ethers-v5-test/test/common.ts |  2 +-
 3 files changed, 17 insertions(+), 17 deletions(-)

diff --git a/packages/target-ethers-v5-test/test/DataTypesInput.test.ts b/packages/target-ethers-v5-test/test/DataTypesInput.test.ts
index e090cb78f..3be442d0b 100644
--- a/packages/target-ethers-v5-test/test/DataTypesInput.test.ts
+++ b/packages/target-ethers-v5-test/test/DataTypesInput.test.ts
@@ -1,5 +1,5 @@
 import { typedAssert, q18 } from 'test-utils'
-import { BigNumber, formatBytes32String } from 'ethers/utils'
+import { ethers, BigNumber } from 'ethers'
 
 import { createNewBlockchain, deployContract } from './common'
 import { DataTypesInput } from '../types/DataTypesInput'
@@ -19,14 +19,14 @@ describe('DataTypesInput', () => {
     typedAssert(await contract.input_uint8('42'), 42)
     typedAssert(await contract.input_uint8(42), 42)
 
-    typedAssert(await contract.input_uint256(q18(1)), new BigNumber(q18(1)))
-    typedAssert(await contract.input_uint256(1), new BigNumber(1))
+    typedAssert(await contract.input_uint256(q18(1)), BigNumber.from(q18(1)))
+    typedAssert(await contract.input_uint256(1), BigNumber.from(1))
 
     typedAssert(await contract.input_int8('42'), 42)
     typedAssert(await contract.input_int8(42), 42)
 
-    typedAssert(await contract.input_int256(q18(1)), new BigNumber(q18(1)))
-    typedAssert(await contract.input_int256(1), new BigNumber('1'))
+    typedAssert(await contract.input_int256(q18(1)), BigNumber.from(q18(1)))
+    typedAssert(await contract.input_int256(1), BigNumber.from('1'))
 
     typedAssert(await contract.input_bool(true), true)
 
@@ -39,7 +39,7 @@ describe('DataTypesInput', () => {
     typedAssert(await contract.input_bytes1([0]), '0x00')
 
     typedAssert(
-      await contract.input_bytes(formatBytes32String('TypeChain')),
+      await contract.input_bytes(ethers.utils.formatBytes32String('TypeChain')),
       '0x54797065436861696e0000000000000000000000000000000000000000000000',
     )
 
@@ -52,11 +52,11 @@ describe('DataTypesInput', () => {
     // typedAssert(await contract.input_tuple('1', '2'), { 0: new BigNumber('1'), 1: new BigNumber('2') })
     // typedAssert(await contract.input_tuple(1, 2), { 0: '1', 1: '2' })
 
-    typedAssert(await contract.input_struct({ uint256_0: new BigNumber('1'), uint256_1: new BigNumber('2') }), {
-      0: new BigNumber('1'),
-      1: new BigNumber('2'),
-      uint256_0: new BigNumber('1'),
-      uint256_1: new BigNumber('2'),
+    typedAssert(await contract.input_struct({ uint256_0: BigNumber.from('1'), uint256_1: BigNumber.from('2') }), {
+      0: BigNumber.from('1'),
+      1: BigNumber.from('2'),
+      uint256_0: BigNumber.from('1'),
+      uint256_1: BigNumber.from('2'),
     })
 
     typedAssert(await contract.input_enum('1'), 1)
diff --git a/packages/target-ethers-v5-test/test/Overload.test.ts b/packages/target-ethers-v5-test/test/Overload.test.ts
index 505138867..940aea13b 100644
--- a/packages/target-ethers-v5-test/test/Overload.test.ts
+++ b/packages/target-ethers-v5-test/test/Overload.test.ts
@@ -2,7 +2,7 @@ import { typedAssert } from 'test-utils'
 
 import { createNewBlockchain, deployContract } from './common'
 import { Overloads } from '../types/Overloads'
-import { BigNumber } from 'ethers/utils'
+import { BigNumber } from 'ethers'
 
 describe('Overloads', () => {
   let contract: Overloads
@@ -16,12 +16,12 @@ describe('Overloads', () => {
   afterEach(() => ganache.close())
 
   it('works with 1st overload', async () => {
-    const result = await contract.functions['overload1(int256)'](1)
-    typedAssert(result, new BigNumber(1))
+    const result = await contract['overload1(int256)'](1)
+    typedAssert(result, BigNumber.from(1))
   })
 
   it('works with 2n overload', async () => {
-    const result = await contract.functions['overload1(uint256,uint256)'](1, 2)
-    typedAssert(result, new BigNumber(3))
+    const result = await contract['overload1(uint256,uint256)'](1, 2)
+    typedAssert(result, BigNumber.from(3))
   })
 })
diff --git a/packages/target-ethers-v5-test/test/common.ts b/packages/target-ethers-v5-test/test/common.ts
index 2de7b97ac..113554a9c 100644
--- a/packages/target-ethers-v5-test/test/common.ts
+++ b/packages/target-ethers-v5-test/test/common.ts
@@ -1,4 +1,4 @@
-import { JsonRpcProvider } from 'ethers/providers'
+import { JsonRpcProvider } from '@ethersproject/providers'
 import { ethers } from 'ethers'
 import { loadContract } from 'test-utils'
 

From 7c1d12219ca6e83287aecc35e9d9db80acdcdac2 Mon Sep 17 00:00:00 2001
From: zemse <sohamzemse143@gmail.com>
Date: Sun, 28 Jun 2020 18:07:25 +0530
Subject: [PATCH 37/64] Fix bug of empty parameter type

---
 packages/target-ethers-v5/src/codegen/index.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/target-ethers-v5/src/codegen/index.ts b/packages/target-ethers-v5/src/codegen/index.ts
index 550de921d..e6bd416bb 100644
--- a/packages/target-ethers-v5/src/codegen/index.ts
+++ b/packages/target-ethers-v5/src/codegen/index.ts
@@ -249,7 +249,7 @@ function generateEncodeFunctionDataOverload(fn: FunctionDeclaration): string {
   if (fn.inputs.length) {
     methodInputs.push(`values: [${fn.inputs.map((input) => generateInputType(input.type)).join(', ')}]`)
   } else {
-    methodInputs.push('values?: void')
+    methodInputs.push('values?: undefined')
   }
 
   return `encodeFunctionData(${methodInputs.join(', ')}): string;`

From 0ca6e8996ec6c4125291eedde96614101eca8704 Mon Sep 17 00:00:00 2001
From: zemse <sohamzemse143@gmail.com>
Date: Sun, 28 Jun 2020 18:08:35 +0530
Subject: [PATCH 38/64] Update types

---
 .../types/DataTypesPure.d.ts                  | 58 ++++++++++++++-----
 .../types/DataTypesView.d.ts                  | 58 ++++++++++++++-----
 .../target-ethers-v5-test/types/Events.d.ts   | 22 +++++--
 .../types/NameMangling.d.ts                   |  2 +-
 .../target-ethers-v5-test/types/Payable.d.ts  |  7 ++-
 5 files changed, 111 insertions(+), 36 deletions(-)

diff --git a/packages/target-ethers-v5-test/types/DataTypesPure.d.ts b/packages/target-ethers-v5-test/types/DataTypesPure.d.ts
index 6c13e9923..2a8b0524a 100644
--- a/packages/target-ethers-v5-test/types/DataTypesPure.d.ts
+++ b/packages/target-ethers-v5-test/types/DataTypesPure.d.ts
@@ -36,23 +36,53 @@ interface DataTypesPureInterface extends ethers.utils.Interface {
     "pure_uint8()": FunctionFragment;
   };
 
-  encodeFunctionData(functionFragment: "pure_address", values?: void): string;
-  encodeFunctionData(functionFragment: "pure_bool", values?: void): string;
-  encodeFunctionData(functionFragment: "pure_bytes", values?: void): string;
-  encodeFunctionData(functionFragment: "pure_bytes1", values?: void): string;
-  encodeFunctionData(functionFragment: "pure_enum", values?: void): string;
-  encodeFunctionData(functionFragment: "pure_int256", values?: void): string;
-  encodeFunctionData(functionFragment: "pure_int8", values?: void): string;
-  encodeFunctionData(functionFragment: "pure_named", values?: void): string;
+  encodeFunctionData(
+    functionFragment: "pure_address",
+    values?: undefined
+  ): string;
+  encodeFunctionData(functionFragment: "pure_bool", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "pure_bytes",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "pure_bytes1",
+    values?: undefined
+  ): string;
+  encodeFunctionData(functionFragment: "pure_enum", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "pure_int256",
+    values?: undefined
+  ): string;
+  encodeFunctionData(functionFragment: "pure_int8", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "pure_named",
+    values?: undefined
+  ): string;
   encodeFunctionData(
     functionFragment: "pure_stat_array",
-    values?: void
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "pure_string",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "pure_struct",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "pure_tuple",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "pure_uint256",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "pure_uint8",
+    values?: undefined
   ): string;
-  encodeFunctionData(functionFragment: "pure_string", values?: void): string;
-  encodeFunctionData(functionFragment: "pure_struct", values?: void): string;
-  encodeFunctionData(functionFragment: "pure_tuple", values?: void): string;
-  encodeFunctionData(functionFragment: "pure_uint256", values?: void): string;
-  encodeFunctionData(functionFragment: "pure_uint8", values?: void): string;
 
   decodeFunctionResult(
     functionFragment: "pure_address",
diff --git a/packages/target-ethers-v5-test/types/DataTypesView.d.ts b/packages/target-ethers-v5-test/types/DataTypesView.d.ts
index 80b9334f9..5a3b7b9f0 100644
--- a/packages/target-ethers-v5-test/types/DataTypesView.d.ts
+++ b/packages/target-ethers-v5-test/types/DataTypesView.d.ts
@@ -36,23 +36,53 @@ interface DataTypesViewInterface extends ethers.utils.Interface {
     "view_uint8()": FunctionFragment;
   };
 
-  encodeFunctionData(functionFragment: "view_address", values?: void): string;
-  encodeFunctionData(functionFragment: "view_bool", values?: void): string;
-  encodeFunctionData(functionFragment: "view_bytes", values?: void): string;
-  encodeFunctionData(functionFragment: "view_bytes1", values?: void): string;
-  encodeFunctionData(functionFragment: "view_enum", values?: void): string;
-  encodeFunctionData(functionFragment: "view_int256", values?: void): string;
-  encodeFunctionData(functionFragment: "view_int8", values?: void): string;
-  encodeFunctionData(functionFragment: "view_named", values?: void): string;
+  encodeFunctionData(
+    functionFragment: "view_address",
+    values?: undefined
+  ): string;
+  encodeFunctionData(functionFragment: "view_bool", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "view_bytes",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "view_bytes1",
+    values?: undefined
+  ): string;
+  encodeFunctionData(functionFragment: "view_enum", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "view_int256",
+    values?: undefined
+  ): string;
+  encodeFunctionData(functionFragment: "view_int8", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "view_named",
+    values?: undefined
+  ): string;
   encodeFunctionData(
     functionFragment: "view_stat_array",
-    values?: void
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "view_string",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "view_struct",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "view_tuple",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "view_uint256",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "view_uint8",
+    values?: undefined
   ): string;
-  encodeFunctionData(functionFragment: "view_string", values?: void): string;
-  encodeFunctionData(functionFragment: "view_struct", values?: void): string;
-  encodeFunctionData(functionFragment: "view_tuple", values?: void): string;
-  encodeFunctionData(functionFragment: "view_uint256", values?: void): string;
-  encodeFunctionData(functionFragment: "view_uint8", values?: void): string;
 
   decodeFunctionResult(
     functionFragment: "view_address",
diff --git a/packages/target-ethers-v5-test/types/Events.d.ts b/packages/target-ethers-v5-test/types/Events.d.ts
index 152164cd3..480aaceea 100644
--- a/packages/target-ethers-v5-test/types/Events.d.ts
+++ b/packages/target-ethers-v5-test/types/Events.d.ts
@@ -27,13 +27,25 @@ interface EventsInterface extends ethers.utils.Interface {
     "emit_event3_overloaded()": FunctionFragment;
   };
 
-  encodeFunctionData(functionFragment: "emit_anon1", values?: void): string;
-  encodeFunctionData(functionFragment: "emit_event1", values?: void): string;
-  encodeFunctionData(functionFragment: "emit_event2", values?: void): string;
-  encodeFunctionData(functionFragment: "emit_event3", values?: void): string;
+  encodeFunctionData(
+    functionFragment: "emit_anon1",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "emit_event1",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "emit_event2",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "emit_event3",
+    values?: undefined
+  ): string;
   encodeFunctionData(
     functionFragment: "emit_event3_overloaded",
-    values?: void
+    values?: undefined
   ): string;
 
   decodeFunctionResult(functionFragment: "emit_anon1", data: BytesLike): Result;
diff --git a/packages/target-ethers-v5-test/types/NameMangling.d.ts b/packages/target-ethers-v5-test/types/NameMangling.d.ts
index df5c38b79..479775c58 100644
--- a/packages/target-ethers-v5-test/types/NameMangling.d.ts
+++ b/packages/target-ethers-v5-test/types/NameMangling.d.ts
@@ -23,7 +23,7 @@ interface NameManglingInterface extends ethers.utils.Interface {
     "works()": FunctionFragment;
   };
 
-  encodeFunctionData(functionFragment: "works", values?: void): string;
+  encodeFunctionData(functionFragment: "works", values?: undefined): string;
 
   decodeFunctionResult(functionFragment: "works", data: BytesLike): Result;
 
diff --git a/packages/target-ethers-v5-test/types/Payable.d.ts b/packages/target-ethers-v5-test/types/Payable.d.ts
index 8dc833a20..e13a0a229 100644
--- a/packages/target-ethers-v5-test/types/Payable.d.ts
+++ b/packages/target-ethers-v5-test/types/Payable.d.ts
@@ -27,9 +27,12 @@ interface PayableInterface extends ethers.utils.Interface {
 
   encodeFunctionData(
     functionFragment: "non_payable_func",
-    values?: void
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "payable_func",
+    values?: undefined
   ): string;
-  encodeFunctionData(functionFragment: "payable_func", values?: void): string;
 
   decodeFunctionResult(
     functionFragment: "non_payable_func",

From a1de3d1f97704eeb9c6dce982f6dd477ba93f1aa Mon Sep 17 00:00:00 2001
From: Krzysztof Kaczor <krzkaczor@gmail.com>
Date: Tue, 30 Jun 2020 21:32:29 +0200
Subject: [PATCH 39/64] Recreate locks

---
 packages/target-ethers-v5/package.json |  2 +-
 yarn.lock                              | 39 +++++++++++++++++---------
 2 files changed, 27 insertions(+), 14 deletions(-)

diff --git a/packages/target-ethers-v5/package.json b/packages/target-ethers-v5/package.json
index 7273bb99b..4da32b070 100644
--- a/packages/target-ethers-v5/package.json
+++ b/packages/target-ethers-v5/package.json
@@ -34,7 +34,7 @@
   },
   "peerDependencies": {
     "typechain": "^2.0.0",
-    "ethers": "^4.0.0"
+    "ethers": "^5.0.0"
   },
   "devDependencies": {
     "@types/chai": "^4.2.7",
diff --git a/yarn.lock b/yarn.lock
index b96b4e19d..e7f5ade54 100644
--- a/yarn.lock
+++ b/yarn.lock
@@ -85,9 +85,9 @@
     "@ethersproject/properties" "^5.0.0"
 
 "@ethersproject/bignumber@^5.0.0":
-  version "5.0.1"
-  resolved "https://registry.yarnpkg.com/@ethersproject/bignumber/-/bignumber-5.0.1.tgz#85edb1026310633ef566cc379e3e0026697f6e6e"
-  integrity sha512-srGDO7ksT0avdDw5pBtj6F81psv5xiJMInwSSatfIKplitubFb6yVwoHGObGRd0Pp3TvrkIDfJkuskoSMj4OHQ==
+  version "5.0.2"
+  resolved "https://registry.yarnpkg.com/@ethersproject/bignumber/-/bignumber-5.0.2.tgz#797e0b8955e49509d297a42e50db9159a902ed83"
+  integrity sha512-fy27wYrrgXCHSG1Y8WMrcZQC8L28X2+yRHvSMr/dXAS0BDqIjcT+QdiVAynbIzShALklZdMkKHBe0qA45nLNEQ==
   dependencies:
     "@ethersproject/bytes" "^5.0.0"
     "@ethersproject/logger" "^5.0.0"
@@ -207,9 +207,9 @@
     "@ethersproject/logger" "^5.0.0"
 
 "@ethersproject/providers@^5.0.0":
-  version "5.0.2"
-  resolved "https://registry.yarnpkg.com/@ethersproject/providers/-/providers-5.0.2.tgz#d738235db8235cf3471f4e7c4fac99b8830e4bf1"
-  integrity sha512-28ABJmHB9ii/73F3P9CXLBvlRkitiOGHCrUZqjQ6FELuAtKEROqA/yDklT9o/r/BpGcGTeeWpWfvdfgDHjshiw==
+  version "5.0.3"
+  resolved "https://registry.yarnpkg.com/@ethersproject/providers/-/providers-5.0.3.tgz#0181f3ef225365356064dc2015c3756842ca04bc"
+  integrity sha512-HuZf+QSq3R/TKEOQE2ZrEqXy8r6wtXwxOC3+ZayHAiVisy9hL/VRTljhVd2XwHwu/1GSn4FmXyCT3OzZxXpiQg==
   dependencies:
     "@ethersproject/abstract-provider" "^5.0.0"
     "@ethersproject/abstract-signer" "^5.0.0"
@@ -254,14 +254,14 @@
     hash.js "1.1.3"
 
 "@ethersproject/signing-key@^5.0.0":
-  version "5.0.1"
-  resolved "https://registry.yarnpkg.com/@ethersproject/signing-key/-/signing-key-5.0.1.tgz#90957e42c69e857dc741c8fbeeff0f36bcee9cf7"
-  integrity sha512-Z3yMPFFf4KkWltndDNi/tpese7qZh6ZWKbGu3DHd8xOX0PJqbScdAs6gCfFeMatO06qyX307Y52soc/Ayf8ZSg==
+  version "5.0.2"
+  resolved "https://registry.yarnpkg.com/@ethersproject/signing-key/-/signing-key-5.0.2.tgz#ca3cff00d92220fcf7d124e03a139182d627cff3"
+  integrity sha512-kgpCdtgoLoKXJTwJPw3ggRW7EO93YCQ98zY8hBpIb4OK3FxFCR3UUjlrGEwjMnLHDjFrxpKCeJagGWf477RyMQ==
   dependencies:
     "@ethersproject/bytes" "^5.0.0"
     "@ethersproject/logger" "^5.0.0"
     "@ethersproject/properties" "^5.0.0"
-    elliptic "6.5.2"
+    elliptic "6.5.3"
 
 "@ethersproject/solidity@^5.0.0":
   version "5.0.1"
@@ -1638,6 +1638,19 @@ elliptic@6.5.2, elliptic@^6.0.0, elliptic@^6.4.0, elliptic@^6.5.2:
     minimalistic-assert "^1.0.0"
     minimalistic-crypto-utils "^1.0.0"
 
+elliptic@6.5.3:
+  version "6.5.3"
+  resolved "https://registry.yarnpkg.com/elliptic/-/elliptic-6.5.3.tgz#cb59eb2efdaf73a0bd78ccd7015a62ad6e0f93d6"
+  integrity sha512-IMqzv5wNQf+E6aHeIqATs0tOLeOTwj1QKbRcS3jBbYkl5oLAserA8yJTT7/VyHUYG91PRmPyeQDObKLPpeS4dw==
+  dependencies:
+    bn.js "^4.4.0"
+    brorand "^1.0.1"
+    hash.js "^1.0.0"
+    hmac-drbg "^1.0.0"
+    inherits "^2.0.1"
+    minimalistic-assert "^1.0.0"
+    minimalistic-crypto-utils "^1.0.0"
+
 emoji-regex@^7.0.1:
   version "7.0.3"
   resolved "https://registry.yarnpkg.com/emoji-regex/-/emoji-regex-7.0.3.tgz#933a04052860c85e83c122479c4748a8e4c72156"
@@ -1973,9 +1986,9 @@ ethers@^4.0.46:
     xmlhttprequest "1.8.0"
 
 ethers@^5.0.2:
-  version "5.0.2"
-  resolved "https://registry.yarnpkg.com/ethers/-/ethers-5.0.2.tgz#b7ccca12592c8f5f45e172c3c32fd13d77225048"
-  integrity sha512-hAWTPQXvjFlrtnPLCnOOJJuqiqmJv820egPHpOwcWTIQxXRrcfZyse2692eaqsXMeYLNM2CRfYgEomBiBGvgjw==
+  version "5.0.3"
+  resolved "https://registry.yarnpkg.com/ethers/-/ethers-5.0.3.tgz#41587a09934fb4dd5960cfe1fbc67560a53df7d5"
+  integrity sha512-Y9ud5W9Gtuzibyc8tEEkFRd/+uQciUoy0j7PTHF0i8H9521i67NQPXYOIA0NS0fRD2TolNTFeRLNNEY7EA98qg==
   dependencies:
     "@ethersproject/abi" "^5.0.0"
     "@ethersproject/abstract-provider" "^5.0.0"

From 55c2bfc175ddf50f532ab7cba3ea902d68952080 Mon Sep 17 00:00:00 2001
From: Krzysztof Kaczor <krzkaczor@gmail.com>
Date: Tue, 30 Jun 2020 22:09:13 +0200
Subject: [PATCH 40/64] Add v5 example

---
 .gitignore                                    |   4 +-
 examples/ethers-v4/README.md                  |   2 +-
 .../ethers-v4/types/ethers-contracts/Dai.d.ts | 393 ---------
 .../types/ethers-contracts/DaiFactory.ts      | 577 ------------
 .../types/ethers-contracts/index.d.ts         |  27 -
 examples/ethers-v5/README.md                  |  11 +
 examples/ethers-v5/abi/dai.json               | 277 ++++++
 examples/ethers-v5/package.json               |  23 +
 examples/ethers-v5/src/index.ts               |  22 +
 examples/ethers-v5/tsconfig.json              |  11 +
 examples/ethers-v5/yarn.lock                  | 820 ++++++++++++++++++
 packages/target-ethers-v5/package.json        |   2 +-
 12 files changed, 1169 insertions(+), 1000 deletions(-)
 delete mode 100644 examples/ethers-v4/types/ethers-contracts/Dai.d.ts
 delete mode 100644 examples/ethers-v4/types/ethers-contracts/DaiFactory.ts
 delete mode 100644 examples/ethers-v4/types/ethers-contracts/index.d.ts
 create mode 100644 examples/ethers-v5/README.md
 create mode 100644 examples/ethers-v5/abi/dai.json
 create mode 100644 examples/ethers-v5/package.json
 create mode 100644 examples/ethers-v5/src/index.ts
 create mode 100644 examples/ethers-v5/tsconfig.json
 create mode 100644 examples/ethers-v5/yarn.lock

diff --git a/.gitignore b/.gitignore
index 0c04882ee..a95a3f90c 100644
--- a/.gitignore
+++ b/.gitignore
@@ -13,4 +13,6 @@ examples/web3-v1/types
 examples/truffle-v4/types
 examples/truffle-v4/migrations
 examples/truffle-v5/types
-examples/truffle-v5/migrations
\ No newline at end of file
+examples/truffle-v5/migrations
+# examples/ethers-v4/types
+examples/ethers-v5/types
diff --git a/examples/ethers-v4/README.md b/examples/ethers-v4/README.md
index 530d7bed1..cc17210dc 100644
--- a/examples/ethers-v4/README.md
+++ b/examples/ethers-v4/README.md
@@ -1,4 +1,4 @@
-# TypeChain x Web3 v1 example
+# TypeChain x Ethers-v4 example
 
 ## Running
 
diff --git a/examples/ethers-v4/types/ethers-contracts/Dai.d.ts b/examples/ethers-v4/types/ethers-contracts/Dai.d.ts
deleted file mode 100644
index 4164d8e14..000000000
--- a/examples/ethers-v4/types/ethers-contracts/Dai.d.ts
+++ /dev/null
@@ -1,393 +0,0 @@
-/* Generated by ts-generator ver. 0.0.8 */
-/* tslint:disable */
-
-import { Contract, ContractTransaction, EventFilter, Signer } from "ethers";
-import { Listener, Provider } from "ethers/providers";
-import { Arrayish, BigNumber, BigNumberish, Interface } from "ethers/utils";
-import {
-  TransactionOverrides,
-  TypedEventDescription,
-  TypedFunctionDescription
-} from ".";
-
-interface DaiInterface extends Interface {
-  functions: {
-    DOMAIN_SEPARATOR: TypedFunctionDescription<{ encode([]: []): string }>;
-
-    PERMIT_TYPEHASH: TypedFunctionDescription<{ encode([]: []): string }>;
-
-    allowance: TypedFunctionDescription<{
-      encode([,]: [string, string]): string;
-    }>;
-
-    approve: TypedFunctionDescription<{
-      encode([usr, wad]: [string, BigNumberish]): string;
-    }>;
-
-    balanceOf: TypedFunctionDescription<{ encode([]: [string]): string }>;
-
-    burn: TypedFunctionDescription<{
-      encode([usr, wad]: [string, BigNumberish]): string;
-    }>;
-
-    decimals: TypedFunctionDescription<{ encode([]: []): string }>;
-
-    deny: TypedFunctionDescription<{ encode([guy]: [string]): string }>;
-
-    mint: TypedFunctionDescription<{
-      encode([usr, wad]: [string, BigNumberish]): string;
-    }>;
-
-    move: TypedFunctionDescription<{
-      encode([src, dst, wad]: [string, string, BigNumberish]): string;
-    }>;
-
-    name: TypedFunctionDescription<{ encode([]: []): string }>;
-
-    nonces: TypedFunctionDescription<{ encode([]: [string]): string }>;
-
-    permit: TypedFunctionDescription<{
-      encode([holder, spender, nonce, expiry, allowed, v, r, s]: [
-        string,
-        string,
-        BigNumberish,
-        BigNumberish,
-        boolean,
-        BigNumberish,
-        Arrayish,
-        Arrayish
-      ]): string;
-    }>;
-
-    pull: TypedFunctionDescription<{
-      encode([usr, wad]: [string, BigNumberish]): string;
-    }>;
-
-    push: TypedFunctionDescription<{
-      encode([usr, wad]: [string, BigNumberish]): string;
-    }>;
-
-    rely: TypedFunctionDescription<{ encode([guy]: [string]): string }>;
-
-    symbol: TypedFunctionDescription<{ encode([]: []): string }>;
-
-    totalSupply: TypedFunctionDescription<{ encode([]: []): string }>;
-
-    transfer: TypedFunctionDescription<{
-      encode([dst, wad]: [string, BigNumberish]): string;
-    }>;
-
-    transferFrom: TypedFunctionDescription<{
-      encode([src, dst, wad]: [string, string, BigNumberish]): string;
-    }>;
-
-    version: TypedFunctionDescription<{ encode([]: []): string }>;
-
-    wards: TypedFunctionDescription<{ encode([]: [string]): string }>;
-  };
-
-  events: {
-    Approval: TypedEventDescription<{
-      encodeTopics([src, guy, wad]: [
-        string | null,
-        string | null,
-        null
-      ]): string[];
-    }>;
-
-    LogNote: TypedEventDescription<{
-      encodeTopics([sig, usr, arg1, arg2, data]: [
-        Arrayish | null,
-        string | null,
-        Arrayish | null,
-        Arrayish | null,
-        null
-      ]): string[];
-    }>;
-
-    Transfer: TypedEventDescription<{
-      encodeTopics([src, dst, wad]: [
-        string | null,
-        string | null,
-        null
-      ]): string[];
-    }>;
-  };
-}
-
-export class Dai extends Contract {
-  connect(signerOrProvider: Signer | Provider | string): Dai;
-  attach(addressOrName: string): Dai;
-  deployed(): Promise<Dai>;
-
-  on(event: EventFilter | string, listener: Listener): Dai;
-  once(event: EventFilter | string, listener: Listener): Dai;
-  addListener(eventName: EventFilter | string, listener: Listener): Dai;
-  removeAllListeners(eventName: EventFilter | string): Dai;
-  removeListener(eventName: any, listener: Listener): Dai;
-
-  interface: DaiInterface;
-
-  functions: {
-    DOMAIN_SEPARATOR(): Promise<string>;
-
-    PERMIT_TYPEHASH(): Promise<string>;
-
-    allowance(arg0: string, arg1: string): Promise<BigNumber>;
-
-    approve(
-      usr: string,
-      wad: BigNumberish,
-      overrides?: TransactionOverrides
-    ): Promise<ContractTransaction>;
-
-    balanceOf(arg0: string): Promise<BigNumber>;
-
-    burn(
-      usr: string,
-      wad: BigNumberish,
-      overrides?: TransactionOverrides
-    ): Promise<ContractTransaction>;
-
-    decimals(): Promise<number>;
-
-    deny(
-      guy: string,
-      overrides?: TransactionOverrides
-    ): Promise<ContractTransaction>;
-
-    mint(
-      usr: string,
-      wad: BigNumberish,
-      overrides?: TransactionOverrides
-    ): Promise<ContractTransaction>;
-
-    move(
-      src: string,
-      dst: string,
-      wad: BigNumberish,
-      overrides?: TransactionOverrides
-    ): Promise<ContractTransaction>;
-
-    name(): Promise<string>;
-
-    nonces(arg0: string): Promise<BigNumber>;
-
-    permit(
-      holder: string,
-      spender: string,
-      nonce: BigNumberish,
-      expiry: BigNumberish,
-      allowed: boolean,
-      v: BigNumberish,
-      r: Arrayish,
-      s: Arrayish,
-      overrides?: TransactionOverrides
-    ): Promise<ContractTransaction>;
-
-    pull(
-      usr: string,
-      wad: BigNumberish,
-      overrides?: TransactionOverrides
-    ): Promise<ContractTransaction>;
-
-    push(
-      usr: string,
-      wad: BigNumberish,
-      overrides?: TransactionOverrides
-    ): Promise<ContractTransaction>;
-
-    rely(
-      guy: string,
-      overrides?: TransactionOverrides
-    ): Promise<ContractTransaction>;
-
-    symbol(): Promise<string>;
-
-    totalSupply(): Promise<BigNumber>;
-
-    transfer(
-      dst: string,
-      wad: BigNumberish,
-      overrides?: TransactionOverrides
-    ): Promise<ContractTransaction>;
-
-    transferFrom(
-      src: string,
-      dst: string,
-      wad: BigNumberish,
-      overrides?: TransactionOverrides
-    ): Promise<ContractTransaction>;
-
-    version(): Promise<string>;
-
-    wards(arg0: string): Promise<BigNumber>;
-  };
-
-  DOMAIN_SEPARATOR(): Promise<string>;
-
-  PERMIT_TYPEHASH(): Promise<string>;
-
-  allowance(arg0: string, arg1: string): Promise<BigNumber>;
-
-  approve(
-    usr: string,
-    wad: BigNumberish,
-    overrides?: TransactionOverrides
-  ): Promise<ContractTransaction>;
-
-  balanceOf(arg0: string): Promise<BigNumber>;
-
-  burn(
-    usr: string,
-    wad: BigNumberish,
-    overrides?: TransactionOverrides
-  ): Promise<ContractTransaction>;
-
-  decimals(): Promise<number>;
-
-  deny(
-    guy: string,
-    overrides?: TransactionOverrides
-  ): Promise<ContractTransaction>;
-
-  mint(
-    usr: string,
-    wad: BigNumberish,
-    overrides?: TransactionOverrides
-  ): Promise<ContractTransaction>;
-
-  move(
-    src: string,
-    dst: string,
-    wad: BigNumberish,
-    overrides?: TransactionOverrides
-  ): Promise<ContractTransaction>;
-
-  name(): Promise<string>;
-
-  nonces(arg0: string): Promise<BigNumber>;
-
-  permit(
-    holder: string,
-    spender: string,
-    nonce: BigNumberish,
-    expiry: BigNumberish,
-    allowed: boolean,
-    v: BigNumberish,
-    r: Arrayish,
-    s: Arrayish,
-    overrides?: TransactionOverrides
-  ): Promise<ContractTransaction>;
-
-  pull(
-    usr: string,
-    wad: BigNumberish,
-    overrides?: TransactionOverrides
-  ): Promise<ContractTransaction>;
-
-  push(
-    usr: string,
-    wad: BigNumberish,
-    overrides?: TransactionOverrides
-  ): Promise<ContractTransaction>;
-
-  rely(
-    guy: string,
-    overrides?: TransactionOverrides
-  ): Promise<ContractTransaction>;
-
-  symbol(): Promise<string>;
-
-  totalSupply(): Promise<BigNumber>;
-
-  transfer(
-    dst: string,
-    wad: BigNumberish,
-    overrides?: TransactionOverrides
-  ): Promise<ContractTransaction>;
-
-  transferFrom(
-    src: string,
-    dst: string,
-    wad: BigNumberish,
-    overrides?: TransactionOverrides
-  ): Promise<ContractTransaction>;
-
-  version(): Promise<string>;
-
-  wards(arg0: string): Promise<BigNumber>;
-
-  filters: {
-    Approval(src: string | null, guy: string | null, wad: null): EventFilter;
-
-    LogNote(
-      sig: Arrayish | null,
-      usr: string | null,
-      arg1: Arrayish | null,
-      arg2: Arrayish | null,
-      data: null
-    ): EventFilter;
-
-    Transfer(src: string | null, dst: string | null, wad: null): EventFilter;
-  };
-
-  estimate: {
-    DOMAIN_SEPARATOR(): Promise<BigNumber>;
-
-    PERMIT_TYPEHASH(): Promise<BigNumber>;
-
-    allowance(arg0: string, arg1: string): Promise<BigNumber>;
-
-    approve(usr: string, wad: BigNumberish): Promise<BigNumber>;
-
-    balanceOf(arg0: string): Promise<BigNumber>;
-
-    burn(usr: string, wad: BigNumberish): Promise<BigNumber>;
-
-    decimals(): Promise<BigNumber>;
-
-    deny(guy: string): Promise<BigNumber>;
-
-    mint(usr: string, wad: BigNumberish): Promise<BigNumber>;
-
-    move(src: string, dst: string, wad: BigNumberish): Promise<BigNumber>;
-
-    name(): Promise<BigNumber>;
-
-    nonces(arg0: string): Promise<BigNumber>;
-
-    permit(
-      holder: string,
-      spender: string,
-      nonce: BigNumberish,
-      expiry: BigNumberish,
-      allowed: boolean,
-      v: BigNumberish,
-      r: Arrayish,
-      s: Arrayish
-    ): Promise<BigNumber>;
-
-    pull(usr: string, wad: BigNumberish): Promise<BigNumber>;
-
-    push(usr: string, wad: BigNumberish): Promise<BigNumber>;
-
-    rely(guy: string): Promise<BigNumber>;
-
-    symbol(): Promise<BigNumber>;
-
-    totalSupply(): Promise<BigNumber>;
-
-    transfer(dst: string, wad: BigNumberish): Promise<BigNumber>;
-
-    transferFrom(
-      src: string,
-      dst: string,
-      wad: BigNumberish
-    ): Promise<BigNumber>;
-
-    version(): Promise<BigNumber>;
-
-    wards(arg0: string): Promise<BigNumber>;
-  };
-}
diff --git a/examples/ethers-v4/types/ethers-contracts/DaiFactory.ts b/examples/ethers-v4/types/ethers-contracts/DaiFactory.ts
deleted file mode 100644
index 18ea9a93f..000000000
--- a/examples/ethers-v4/types/ethers-contracts/DaiFactory.ts
+++ /dev/null
@@ -1,577 +0,0 @@
-/* Generated by ts-generator ver. 0.0.8 */
-/* tslint:disable */
-
-import { Contract, Signer } from "ethers";
-import { Provider } from "ethers/providers";
-
-import { Dai } from "./Dai";
-
-export class DaiFactory {
-  static connect(address: string, signerOrProvider: Signer | Provider): Dai {
-    return new Contract(address, _abi, signerOrProvider) as Dai;
-  }
-}
-
-const _abi = [
-  {
-    inputs: [
-      {
-        internalType: "uint256",
-        name: "chainId_",
-        type: "uint256"
-      }
-    ],
-    payable: false,
-    stateMutability: "nonpayable",
-    type: "constructor"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      {
-        indexed: true,
-        internalType: "address",
-        name: "src",
-        type: "address"
-      },
-      {
-        indexed: true,
-        internalType: "address",
-        name: "guy",
-        type: "address"
-      },
-      {
-        indexed: false,
-        internalType: "uint256",
-        name: "wad",
-        type: "uint256"
-      }
-    ],
-    name: "Approval",
-    type: "event"
-  },
-  {
-    anonymous: true,
-    inputs: [
-      {
-        indexed: true,
-        internalType: "bytes4",
-        name: "sig",
-        type: "bytes4"
-      },
-      {
-        indexed: true,
-        internalType: "address",
-        name: "usr",
-        type: "address"
-      },
-      {
-        indexed: true,
-        internalType: "bytes32",
-        name: "arg1",
-        type: "bytes32"
-      },
-      {
-        indexed: true,
-        internalType: "bytes32",
-        name: "arg2",
-        type: "bytes32"
-      },
-      {
-        indexed: false,
-        internalType: "bytes",
-        name: "data",
-        type: "bytes"
-      }
-    ],
-    name: "LogNote",
-    type: "event"
-  },
-  {
-    anonymous: false,
-    inputs: [
-      {
-        indexed: true,
-        internalType: "address",
-        name: "src",
-        type: "address"
-      },
-      {
-        indexed: true,
-        internalType: "address",
-        name: "dst",
-        type: "address"
-      },
-      {
-        indexed: false,
-        internalType: "uint256",
-        name: "wad",
-        type: "uint256"
-      }
-    ],
-    name: "Transfer",
-    type: "event"
-  },
-  {
-    constant: true,
-    inputs: [],
-    name: "DOMAIN_SEPARATOR",
-    outputs: [
-      {
-        internalType: "bytes32",
-        name: "",
-        type: "bytes32"
-      }
-    ],
-    payable: false,
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    constant: true,
-    inputs: [],
-    name: "PERMIT_TYPEHASH",
-    outputs: [
-      {
-        internalType: "bytes32",
-        name: "",
-        type: "bytes32"
-      }
-    ],
-    payable: false,
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    constant: true,
-    inputs: [
-      {
-        internalType: "address",
-        name: "",
-        type: "address"
-      },
-      {
-        internalType: "address",
-        name: "",
-        type: "address"
-      }
-    ],
-    name: "allowance",
-    outputs: [
-      {
-        internalType: "uint256",
-        name: "",
-        type: "uint256"
-      }
-    ],
-    payable: false,
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    constant: false,
-    inputs: [
-      {
-        internalType: "address",
-        name: "usr",
-        type: "address"
-      },
-      {
-        internalType: "uint256",
-        name: "wad",
-        type: "uint256"
-      }
-    ],
-    name: "approve",
-    outputs: [
-      {
-        internalType: "bool",
-        name: "",
-        type: "bool"
-      }
-    ],
-    payable: false,
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    constant: true,
-    inputs: [
-      {
-        internalType: "address",
-        name: "",
-        type: "address"
-      }
-    ],
-    name: "balanceOf",
-    outputs: [
-      {
-        internalType: "uint256",
-        name: "",
-        type: "uint256"
-      }
-    ],
-    payable: false,
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    constant: false,
-    inputs: [
-      {
-        internalType: "address",
-        name: "usr",
-        type: "address"
-      },
-      {
-        internalType: "uint256",
-        name: "wad",
-        type: "uint256"
-      }
-    ],
-    name: "burn",
-    outputs: [],
-    payable: false,
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    constant: true,
-    inputs: [],
-    name: "decimals",
-    outputs: [
-      {
-        internalType: "uint8",
-        name: "",
-        type: "uint8"
-      }
-    ],
-    payable: false,
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    constant: false,
-    inputs: [
-      {
-        internalType: "address",
-        name: "guy",
-        type: "address"
-      }
-    ],
-    name: "deny",
-    outputs: [],
-    payable: false,
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    constant: false,
-    inputs: [
-      {
-        internalType: "address",
-        name: "usr",
-        type: "address"
-      },
-      {
-        internalType: "uint256",
-        name: "wad",
-        type: "uint256"
-      }
-    ],
-    name: "mint",
-    outputs: [],
-    payable: false,
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    constant: false,
-    inputs: [
-      {
-        internalType: "address",
-        name: "src",
-        type: "address"
-      },
-      {
-        internalType: "address",
-        name: "dst",
-        type: "address"
-      },
-      {
-        internalType: "uint256",
-        name: "wad",
-        type: "uint256"
-      }
-    ],
-    name: "move",
-    outputs: [],
-    payable: false,
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    constant: true,
-    inputs: [],
-    name: "name",
-    outputs: [
-      {
-        internalType: "string",
-        name: "",
-        type: "string"
-      }
-    ],
-    payable: false,
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    constant: true,
-    inputs: [
-      {
-        internalType: "address",
-        name: "",
-        type: "address"
-      }
-    ],
-    name: "nonces",
-    outputs: [
-      {
-        internalType: "uint256",
-        name: "",
-        type: "uint256"
-      }
-    ],
-    payable: false,
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    constant: false,
-    inputs: [
-      {
-        internalType: "address",
-        name: "holder",
-        type: "address"
-      },
-      {
-        internalType: "address",
-        name: "spender",
-        type: "address"
-      },
-      {
-        internalType: "uint256",
-        name: "nonce",
-        type: "uint256"
-      },
-      {
-        internalType: "uint256",
-        name: "expiry",
-        type: "uint256"
-      },
-      {
-        internalType: "bool",
-        name: "allowed",
-        type: "bool"
-      },
-      {
-        internalType: "uint8",
-        name: "v",
-        type: "uint8"
-      },
-      {
-        internalType: "bytes32",
-        name: "r",
-        type: "bytes32"
-      },
-      {
-        internalType: "bytes32",
-        name: "s",
-        type: "bytes32"
-      }
-    ],
-    name: "permit",
-    outputs: [],
-    payable: false,
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    constant: false,
-    inputs: [
-      {
-        internalType: "address",
-        name: "usr",
-        type: "address"
-      },
-      {
-        internalType: "uint256",
-        name: "wad",
-        type: "uint256"
-      }
-    ],
-    name: "pull",
-    outputs: [],
-    payable: false,
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    constant: false,
-    inputs: [
-      {
-        internalType: "address",
-        name: "usr",
-        type: "address"
-      },
-      {
-        internalType: "uint256",
-        name: "wad",
-        type: "uint256"
-      }
-    ],
-    name: "push",
-    outputs: [],
-    payable: false,
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    constant: false,
-    inputs: [
-      {
-        internalType: "address",
-        name: "guy",
-        type: "address"
-      }
-    ],
-    name: "rely",
-    outputs: [],
-    payable: false,
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    constant: true,
-    inputs: [],
-    name: "symbol",
-    outputs: [
-      {
-        internalType: "string",
-        name: "",
-        type: "string"
-      }
-    ],
-    payable: false,
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    constant: true,
-    inputs: [],
-    name: "totalSupply",
-    outputs: [
-      {
-        internalType: "uint256",
-        name: "",
-        type: "uint256"
-      }
-    ],
-    payable: false,
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    constant: false,
-    inputs: [
-      {
-        internalType: "address",
-        name: "dst",
-        type: "address"
-      },
-      {
-        internalType: "uint256",
-        name: "wad",
-        type: "uint256"
-      }
-    ],
-    name: "transfer",
-    outputs: [
-      {
-        internalType: "bool",
-        name: "",
-        type: "bool"
-      }
-    ],
-    payable: false,
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    constant: false,
-    inputs: [
-      {
-        internalType: "address",
-        name: "src",
-        type: "address"
-      },
-      {
-        internalType: "address",
-        name: "dst",
-        type: "address"
-      },
-      {
-        internalType: "uint256",
-        name: "wad",
-        type: "uint256"
-      }
-    ],
-    name: "transferFrom",
-    outputs: [
-      {
-        internalType: "bool",
-        name: "",
-        type: "bool"
-      }
-    ],
-    payable: false,
-    stateMutability: "nonpayable",
-    type: "function"
-  },
-  {
-    constant: true,
-    inputs: [],
-    name: "version",
-    outputs: [
-      {
-        internalType: "string",
-        name: "",
-        type: "string"
-      }
-    ],
-    payable: false,
-    stateMutability: "view",
-    type: "function"
-  },
-  {
-    constant: true,
-    inputs: [
-      {
-        internalType: "address",
-        name: "",
-        type: "address"
-      }
-    ],
-    name: "wards",
-    outputs: [
-      {
-        internalType: "uint256",
-        name: "",
-        type: "uint256"
-      }
-    ],
-    payable: false,
-    stateMutability: "view",
-    type: "function"
-  }
-];
diff --git a/examples/ethers-v4/types/ethers-contracts/index.d.ts b/examples/ethers-v4/types/ethers-contracts/index.d.ts
deleted file mode 100644
index 93c86106f..000000000
--- a/examples/ethers-v4/types/ethers-contracts/index.d.ts
+++ /dev/null
@@ -1,27 +0,0 @@
-/* Generated by ts-generator ver. 0.0.8 */
-/* tslint:disable */
-import {
-  BigNumberish,
-  EventDescription,
-  FunctionDescription
-} from "ethers/utils";
-
-export class TransactionOverrides {
-  nonce?: BigNumberish | Promise<BigNumberish>;
-  gasLimit?: BigNumberish | Promise<BigNumberish>;
-  gasPrice?: BigNumberish | Promise<BigNumberish>;
-  value?: BigNumberish | Promise<BigNumberish>;
-  chainId?: number | Promise<number>;
-}
-
-export interface TypedEventDescription<
-  T extends Pick<EventDescription, "encodeTopics">
-> extends EventDescription {
-  encodeTopics: T["encodeTopics"];
-}
-
-export interface TypedFunctionDescription<
-  T extends Pick<FunctionDescription, "encode">
-> extends FunctionDescription {
-  encode: T["encode"];
-}
diff --git a/examples/ethers-v5/README.md b/examples/ethers-v5/README.md
new file mode 100644
index 000000000..a4cbcba22
--- /dev/null
+++ b/examples/ethers-v5/README.md
@@ -0,0 +1,11 @@
+# TypeChain x Ethers-v5 example
+
+## Running
+
+```sh
+yarn # it will automatically run TypeChain types generation
+
+# yarn generate-types to manually regenerate them
+
+yarn start
+```
diff --git a/examples/ethers-v5/abi/dai.json b/examples/ethers-v5/abi/dai.json
new file mode 100644
index 000000000..ee0d4c48f
--- /dev/null
+++ b/examples/ethers-v5/abi/dai.json
@@ -0,0 +1,277 @@
+[
+
+  {
+    "inputs": [{ "internalType": "uint256", "name": "chainId_", "type": "uint256" }],
+    "payable": false,
+    "stateMutability": "nonpayable",
+    "type": "constructor"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      { "indexed": true, "internalType": "address", "name": "src", "type": "address" },
+      { "indexed": true, "internalType": "address", "name": "guy", "type": "address" },
+      { "indexed": false, "internalType": "uint256", "name": "wad", "type": "uint256" }
+    ],
+    "name": "Approval",
+    "type": "event"
+  },
+  {
+    "anonymous": true,
+    "inputs": [
+      { "indexed": true, "internalType": "bytes4", "name": "sig", "type": "bytes4" },
+      { "indexed": true, "internalType": "address", "name": "usr", "type": "address" },
+      { "indexed": true, "internalType": "bytes32", "name": "arg1", "type": "bytes32" },
+      { "indexed": true, "internalType": "bytes32", "name": "arg2", "type": "bytes32" },
+      { "indexed": false, "internalType": "bytes", "name": "data", "type": "bytes" }
+    ],
+    "name": "LogNote",
+    "type": "event"
+  },
+  {
+    "anonymous": false,
+    "inputs": [
+      { "indexed": true, "internalType": "address", "name": "src", "type": "address" },
+      { "indexed": true, "internalType": "address", "name": "dst", "type": "address" },
+      { "indexed": false, "internalType": "uint256", "name": "wad", "type": "uint256" }
+    ],
+    "name": "Transfer",
+    "type": "event"
+  },
+  {
+    "constant": true,
+    "inputs": [],
+    "name": "DOMAIN_SEPARATOR",
+    "outputs": [{ "internalType": "bytes32", "name": "", "type": "bytes32" }],
+    "payable": false,
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "constant": true,
+    "inputs": [],
+    "name": "PERMIT_TYPEHASH",
+    "outputs": [{ "internalType": "bytes32", "name": "", "type": "bytes32" }],
+    "payable": false,
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "constant": true,
+    "inputs": [
+      { "internalType": "address", "name": "", "type": "address" },
+      { "internalType": "address", "name": "", "type": "address" }
+    ],
+    "name": "allowance",
+    "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }],
+    "payable": false,
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "constant": false,
+    "inputs": [
+      { "internalType": "address", "name": "usr", "type": "address" },
+      { "internalType": "uint256", "name": "wad", "type": "uint256" }
+    ],
+    "name": "approve",
+    "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }],
+    "payable": false,
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "constant": true,
+    "inputs": [{ "internalType": "address", "name": "", "type": "address" }],
+    "name": "balanceOf",
+    "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }],
+    "payable": false,
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "constant": false,
+    "inputs": [
+      { "internalType": "address", "name": "usr", "type": "address" },
+      { "internalType": "uint256", "name": "wad", "type": "uint256" }
+    ],
+    "name": "burn",
+    "outputs": [],
+    "payable": false,
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "constant": true,
+    "inputs": [],
+    "name": "decimals",
+    "outputs": [{ "internalType": "uint8", "name": "", "type": "uint8" }],
+    "payable": false,
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "constant": false,
+    "inputs": [{ "internalType": "address", "name": "guy", "type": "address" }],
+    "name": "deny",
+    "outputs": [],
+    "payable": false,
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "constant": false,
+    "inputs": [
+      { "internalType": "address", "name": "usr", "type": "address" },
+      { "internalType": "uint256", "name": "wad", "type": "uint256" }
+    ],
+    "name": "mint",
+    "outputs": [],
+    "payable": false,
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "constant": false,
+    "inputs": [
+      { "internalType": "address", "name": "src", "type": "address" },
+      { "internalType": "address", "name": "dst", "type": "address" },
+      { "internalType": "uint256", "name": "wad", "type": "uint256" }
+    ],
+    "name": "move",
+    "outputs": [],
+    "payable": false,
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "constant": true,
+    "inputs": [],
+    "name": "name",
+    "outputs": [{ "internalType": "string", "name": "", "type": "string" }],
+    "payable": false,
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "constant": true,
+    "inputs": [{ "internalType": "address", "name": "", "type": "address" }],
+    "name": "nonces",
+    "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }],
+    "payable": false,
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "constant": false,
+    "inputs": [
+      { "internalType": "address", "name": "holder", "type": "address" },
+      { "internalType": "address", "name": "spender", "type": "address" },
+      { "internalType": "uint256", "name": "nonce", "type": "uint256" },
+      { "internalType": "uint256", "name": "expiry", "type": "uint256" },
+      { "internalType": "bool", "name": "allowed", "type": "bool" },
+      { "internalType": "uint8", "name": "v", "type": "uint8" },
+      { "internalType": "bytes32", "name": "r", "type": "bytes32" },
+      { "internalType": "bytes32", "name": "s", "type": "bytes32" }
+    ],
+    "name": "permit",
+    "outputs": [],
+    "payable": false,
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "constant": false,
+    "inputs": [
+      { "internalType": "address", "name": "usr", "type": "address" },
+      { "internalType": "uint256", "name": "wad", "type": "uint256" }
+    ],
+    "name": "pull",
+    "outputs": [],
+    "payable": false,
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "constant": false,
+    "inputs": [
+      { "internalType": "address", "name": "usr", "type": "address" },
+      { "internalType": "uint256", "name": "wad", "type": "uint256" }
+    ],
+    "name": "push",
+    "outputs": [],
+    "payable": false,
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "constant": false,
+    "inputs": [{ "internalType": "address", "name": "guy", "type": "address" }],
+    "name": "rely",
+    "outputs": [],
+    "payable": false,
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "constant": true,
+    "inputs": [],
+    "name": "symbol",
+    "outputs": [{ "internalType": "string", "name": "", "type": "string" }],
+    "payable": false,
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "constant": true,
+    "inputs": [],
+    "name": "totalSupply",
+    "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }],
+    "payable": false,
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "constant": false,
+    "inputs": [
+      { "internalType": "address", "name": "dst", "type": "address" },
+      { "internalType": "uint256", "name": "wad", "type": "uint256" }
+    ],
+    "name": "transfer",
+    "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }],
+    "payable": false,
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "constant": false,
+    "inputs": [
+      { "internalType": "address", "name": "src", "type": "address" },
+      { "internalType": "address", "name": "dst", "type": "address" },
+      { "internalType": "uint256", "name": "wad", "type": "uint256" }
+    ],
+    "name": "transferFrom",
+    "outputs": [{ "internalType": "bool", "name": "", "type": "bool" }],
+    "payable": false,
+    "stateMutability": "nonpayable",
+    "type": "function"
+  },
+  {
+    "constant": true,
+    "inputs": [],
+    "name": "version",
+    "outputs": [{ "internalType": "string", "name": "", "type": "string" }],
+    "payable": false,
+    "stateMutability": "view",
+    "type": "function"
+  },
+  {
+    "constant": true,
+    "inputs": [{ "internalType": "address", "name": "", "type": "address" }],
+    "name": "wards",
+    "outputs": [{ "internalType": "uint256", "name": "", "type": "uint256" }],
+    "payable": false,
+    "stateMutability": "view",
+    "type": "function"
+  }
+]
diff --git a/examples/ethers-v5/package.json b/examples/ethers-v5/package.json
new file mode 100644
index 000000000..cd01528e7
--- /dev/null
+++ b/examples/ethers-v5/package.json
@@ -0,0 +1,23 @@
+{
+  "name": "example-ethers-v4",
+  "private": true,
+  "version": "0.0.1",
+  "main": "index.js",
+  "license": "MIT",
+  "scripts": {
+    "generate-types": "typechain --target=ethers-v5 'abi/*.json'",
+    "postinstall": "yarn generate-types",
+    "start": "ts-node ./src/index.ts",
+    "typecheck": "tsc --noEmit"
+  },
+  "devDependencies": {
+    "@typechain/ethers-v5": "^0.0.1",
+    "@types/bn.js": "^4.11.6",
+    "ts-node": "^8.8.2",
+    "typechain": "^2.0.0",
+    "typescript": "^3.8.3"
+  },
+  "dependencies": {
+    "ethers": "^5.0.3"
+  }
+}
diff --git a/examples/ethers-v5/src/index.ts b/examples/ethers-v5/src/index.ts
new file mode 100644
index 000000000..e2b68b3e7
--- /dev/null
+++ b/examples/ethers-v5/src/index.ts
@@ -0,0 +1,22 @@
+import * as ethers from 'ethers'
+import { Dai } from '../types/ethers-contracts/Dai'
+
+const abi = require('../abi/dai.json')
+
+const RPC_HOST = 'https://mainnet.infura.io/v3/6d6c70e65c77429482df5b64a4d0c943'
+const DAI_ADDRESS = '0x6B175474E89094C44Da98b954EedeAC495271d0F'
+
+async function main() {
+  const provider = new ethers.providers.JsonRpcProvider(RPC_HOST)
+  const formatEther = ethers.utils.formatEther
+
+  const dai = (new ethers.Contract(DAI_ADDRESS, abi, provider) as any) as Dai
+  const balance = await dai.functions.balanceOf('0x70b144972C5Ef6CB941A5379240B74239c418CD4')
+
+  console.log(`Our DAI balance is: ${formatEther(balance[0])}`)
+}
+
+main().catch(e => {
+  console.error(e)
+  process.exit(1)
+})
diff --git a/examples/ethers-v5/tsconfig.json b/examples/ethers-v5/tsconfig.json
new file mode 100644
index 000000000..9c3fe515c
--- /dev/null
+++ b/examples/ethers-v5/tsconfig.json
@@ -0,0 +1,11 @@
+{
+  "compilerOptions": {
+    "lib": ["ES2018", "DOM"],
+    "module": "CommonJS",
+    "moduleResolution": "node",
+    "strict": true,
+    "target": "ES2018",
+    "sourceMap": true,
+    "esModuleInterop": true
+  }
+}
diff --git a/examples/ethers-v5/yarn.lock b/examples/ethers-v5/yarn.lock
new file mode 100644
index 000000000..07fe65cef
--- /dev/null
+++ b/examples/ethers-v5/yarn.lock
@@ -0,0 +1,820 @@
+# THIS IS AN AUTOGENERATED FILE. DO NOT EDIT THIS FILE DIRECTLY.
+# yarn lockfile v1
+
+
+"@ethersproject/abi@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/abi/-/abi-5.0.1.tgz#b6ba2bfb4278fbd6328b608e09741c2475ddad9c"
+  integrity sha512-9fqSa3jEYV4nN8tijW+jz4UnT/Ma9/b8y4+nHlsvuWqr32E2kYsT9SCIVpk/51iM6NOud7xsA6UxCox9zBeHKg==
+  dependencies:
+    "@ethersproject/address" "^5.0.0"
+    "@ethersproject/bignumber" "^5.0.0"
+    "@ethersproject/bytes" "^5.0.0"
+    "@ethersproject/constants" "^5.0.0"
+    "@ethersproject/hash" "^5.0.0"
+    "@ethersproject/keccak256" "^5.0.0"
+    "@ethersproject/logger" "^5.0.0"
+    "@ethersproject/properties" "^5.0.0"
+    "@ethersproject/strings" "^5.0.0"
+
+"@ethersproject/abstract-provider@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/abstract-provider/-/abstract-provider-5.0.1.tgz#7d4828a3b4690f95f4462abedcba7aeb118dadd5"
+  integrity sha512-/KOw65ayviYPtKLqFE1qozeIJJlfI1wE/tNA+iKUPUai6bU6vg2tbfLFGarRTCQe3HoWV1t7xSsD/z9T9xg74g==
+  dependencies:
+    "@ethersproject/bignumber" "^5.0.0"
+    "@ethersproject/bytes" "^5.0.0"
+    "@ethersproject/logger" "^5.0.0"
+    "@ethersproject/networks" "^5.0.0"
+    "@ethersproject/properties" "^5.0.0"
+    "@ethersproject/transactions" "^5.0.0"
+    "@ethersproject/web" "^5.0.0"
+
+"@ethersproject/abstract-signer@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/abstract-signer/-/abstract-signer-5.0.1.tgz#92149e771366467e86cc44dd0c49d28f93eaa852"
+  integrity sha512-Rp8DP+cLcSNFkd1YhwPSBcgEWLRipNakitwIwHngAmhbo4zdiWgALD/OLqdQ7SKF75CufF1W4BCuXcQgiWaRow==
+  dependencies:
+    "@ethersproject/abstract-provider" "^5.0.0"
+    "@ethersproject/bignumber" "^5.0.0"
+    "@ethersproject/bytes" "^5.0.0"
+    "@ethersproject/logger" "^5.0.0"
+    "@ethersproject/properties" "^5.0.0"
+
+"@ethersproject/address@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/address/-/address-5.0.1.tgz#882424fbbec1111abc1aa3482e647a72683c5377"
+  integrity sha512-kfQtXpBP2pI2TfoRRAYv8grHGiYw8U0c1KbMsC58/W33TIBy7gFSf/oAzOd94lNzdIUenKU0OuSzrHQfVcDDDA==
+  dependencies:
+    "@ethersproject/bignumber" "^5.0.0"
+    "@ethersproject/bytes" "^5.0.0"
+    "@ethersproject/keccak256" "^5.0.0"
+    "@ethersproject/logger" "^5.0.0"
+    "@ethersproject/rlp" "^5.0.0"
+    bn.js "^4.4.0"
+
+"@ethersproject/base64@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/base64/-/base64-5.0.1.tgz#9f067855f59db94edebb6cd80fbe79033406b317"
+  integrity sha512-WZDa+TYl6BQfUm9EQIDDfJFL0GiuYXNZPIWoiZx3uds7P1XMsvcW3k71AyjYUxIkU5AKW7awwPbzCbBeP1uXsA==
+  dependencies:
+    "@ethersproject/bytes" "^5.0.0"
+
+"@ethersproject/basex@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/basex/-/basex-5.0.1.tgz#226ae11bb5c6453398cece08b9548a5f896e24e5"
+  integrity sha512-ssL2+p/A5bZgkZkiWy0iQDVz2mVJxZfzpf7dpw8t0sKF9VpoM3ZiMthRapH/QBhd4Rr6TNbr619pFLAGmMi9Ug==
+  dependencies:
+    "@ethersproject/bytes" "^5.0.0"
+    "@ethersproject/properties" "^5.0.0"
+
+"@ethersproject/bignumber@^5.0.0":
+  version "5.0.2"
+  resolved "https://registry.yarnpkg.com/@ethersproject/bignumber/-/bignumber-5.0.2.tgz#797e0b8955e49509d297a42e50db9159a902ed83"
+  integrity sha512-fy27wYrrgXCHSG1Y8WMrcZQC8L28X2+yRHvSMr/dXAS0BDqIjcT+QdiVAynbIzShALklZdMkKHBe0qA45nLNEQ==
+  dependencies:
+    "@ethersproject/bytes" "^5.0.0"
+    "@ethersproject/logger" "^5.0.0"
+    "@ethersproject/properties" "^5.0.0"
+    bn.js "^4.4.0"
+
+"@ethersproject/bytes@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/bytes/-/bytes-5.0.1.tgz#da8cd9b3e3b2800be9b46fda7036fc441b334680"
+  integrity sha512-Y198536UW9Jb9RBXuqmCsCa9mYJUsxJn+5aGr2XjNMpLBc6vEn/44GHnbQXYgRCzh4rnWtJ9bTgSwDjme9Hgnw==
+  dependencies:
+    "@ethersproject/logger" "^5.0.0"
+
+"@ethersproject/constants@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/constants/-/constants-5.0.1.tgz#51426b1d673661e905418ddeefca1f634866860d"
+  integrity sha512-Xec07hFCPN4wfC3WDiRay7KipkApl2msiKTrBHCuAwNMOM8M92+mlQp8tgfEL51DPwCZkmdk1f02kArc6caVSw==
+  dependencies:
+    "@ethersproject/bignumber" "^5.0.0"
+
+"@ethersproject/contracts@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/contracts/-/contracts-5.0.1.tgz#b11ad52f98f807e13a4bf0a89e45a2c56db19df3"
+  integrity sha512-1uPajmkvw3Oy/dxs5TKUsGaXzQ3s5qiXKSVpw9ZrhGG6fMRO3gNyUA+uSWk9IXK0ulj5P95F7vW8HmYOkzep/Q==
+  dependencies:
+    "@ethersproject/abi" "^5.0.0"
+    "@ethersproject/abstract-provider" "^5.0.0"
+    "@ethersproject/abstract-signer" "^5.0.0"
+    "@ethersproject/address" "^5.0.0"
+    "@ethersproject/bignumber" "^5.0.0"
+    "@ethersproject/bytes" "^5.0.0"
+    "@ethersproject/constants" "^5.0.0"
+    "@ethersproject/logger" "^5.0.0"
+    "@ethersproject/properties" "^5.0.0"
+
+"@ethersproject/hash@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/hash/-/hash-5.0.1.tgz#8190240d250b9442dd25f1e8ec2d66e7d0d38237"
+  integrity sha512-1ByUXYvkszrSSks07xctBtZfpFnIVmftxWlAAnguxh6Q65vKECd/EPi5uI5xVOvnrYMH9Vb8MK1SofPX/6fArQ==
+  dependencies:
+    "@ethersproject/bytes" "^5.0.0"
+    "@ethersproject/keccak256" "^5.0.0"
+    "@ethersproject/logger" "^5.0.0"
+    "@ethersproject/strings" "^5.0.0"
+
+"@ethersproject/hdnode@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/hdnode/-/hdnode-5.0.1.tgz#28c621c6fdb1a744c870212405e87c64e714e05f"
+  integrity sha512-L2OZP4SKKxNtHUdwfK8cND09kHRH62ncxXW33WAJU9shKo8Sbz31HVqSdov84bMAGm8QfEKZbfbAJV/7DM6DjQ==
+  dependencies:
+    "@ethersproject/abstract-signer" "^5.0.0"
+    "@ethersproject/basex" "^5.0.0"
+    "@ethersproject/bignumber" "^5.0.0"
+    "@ethersproject/bytes" "^5.0.0"
+    "@ethersproject/logger" "^5.0.0"
+    "@ethersproject/pbkdf2" "^5.0.0"
+    "@ethersproject/properties" "^5.0.0"
+    "@ethersproject/sha2" "^5.0.0"
+    "@ethersproject/signing-key" "^5.0.0"
+    "@ethersproject/strings" "^5.0.0"
+    "@ethersproject/transactions" "^5.0.0"
+    "@ethersproject/wordlists" "^5.0.0"
+
+"@ethersproject/json-wallets@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/json-wallets/-/json-wallets-5.0.1.tgz#a04a728cbf1974fc0a618794ef348335d4522848"
+  integrity sha512-QjqQCh1a0a6wRVHdnqVccCLWX0vAgxnvGZeGqpOk2NbyNE8HTzV7GpOE+4LU+iCc8oonfy1gYd4hpsf+iEUWGg==
+  dependencies:
+    "@ethersproject/abstract-signer" "^5.0.0"
+    "@ethersproject/address" "^5.0.0"
+    "@ethersproject/bytes" "^5.0.0"
+    "@ethersproject/hdnode" "^5.0.0"
+    "@ethersproject/keccak256" "^5.0.0"
+    "@ethersproject/logger" "^5.0.0"
+    "@ethersproject/pbkdf2" "^5.0.0"
+    "@ethersproject/properties" "^5.0.0"
+    "@ethersproject/random" "^5.0.0"
+    "@ethersproject/strings" "^5.0.0"
+    "@ethersproject/transactions" "^5.0.0"
+    aes-js "3.0.0"
+    scrypt-js "3.0.1"
+    uuid "2.0.1"
+
+"@ethersproject/keccak256@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/keccak256/-/keccak256-5.0.1.tgz#be91c11a8bdf4e94c8b900502d2a46b223fbdeb3"
+  integrity sha512-AtFm/4qHRQUvZcG3WYmaT7zV79dz72+N01w0XphcIBaD/7UZXyW85Uf08sirVlckHmh9fvc4UDWyHiroKsBT6Q==
+  dependencies:
+    "@ethersproject/bytes" "^5.0.0"
+    js-sha3 "0.5.7"
+
+"@ethersproject/logger@^5.0.0":
+  version "5.0.2"
+  resolved "https://registry.yarnpkg.com/@ethersproject/logger/-/logger-5.0.2.tgz#f24aa14a738a428d711c1828b44d50114a461b8b"
+  integrity sha512-NQe3O1/Nwkcp6bto6hsTvrcCeR/cOGK+RhOMn0Zi2FND6gdWsf1g+5ie8gQ1REqDX4MTGP/Y131dZas985ls/g==
+
+"@ethersproject/networks@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/networks/-/networks-5.0.1.tgz#c06ac151d0dfec421c1cb98a9153c109b3117111"
+  integrity sha512-Pe34JCTC6Apm/DkK3z97xotvEyu9YHKIFlDIu5hGV6yFDb4/sUfY2SHKYSGdUrV0418ZZVrwYDveJtBFMmYu2Q==
+  dependencies:
+    "@ethersproject/logger" "^5.0.0"
+
+"@ethersproject/pbkdf2@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/pbkdf2/-/pbkdf2-5.0.1.tgz#86d4340f88ebb97254c7e0d26830c24fb45b1642"
+  integrity sha512-4wc8Aov0iJmiomu6Dv1JNGOlhm3L7omITjLmChz/vgeDnW4Unv4J/nGybCeWKgY4hnjyQMVXkdkQ15BCRbkaYg==
+  dependencies:
+    "@ethersproject/bytes" "^5.0.0"
+    "@ethersproject/sha2" "^5.0.0"
+
+"@ethersproject/properties@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/properties/-/properties-5.0.1.tgz#e1fecbfcb24f23bf3b64a2ac74f2751113d116e0"
+  integrity sha512-b3VZ/NpYIf64/hFXeWNxVCbY1xoMPIYM3n6Qnu6Ayr3bLt1olFPQfAaaRB0aOsLz7tMtmkT3DrA1KG/IrOgBRw==
+  dependencies:
+    "@ethersproject/logger" "^5.0.0"
+
+"@ethersproject/providers@^5.0.0":
+  version "5.0.3"
+  resolved "https://registry.yarnpkg.com/@ethersproject/providers/-/providers-5.0.3.tgz#0181f3ef225365356064dc2015c3756842ca04bc"
+  integrity sha512-HuZf+QSq3R/TKEOQE2ZrEqXy8r6wtXwxOC3+ZayHAiVisy9hL/VRTljhVd2XwHwu/1GSn4FmXyCT3OzZxXpiQg==
+  dependencies:
+    "@ethersproject/abstract-provider" "^5.0.0"
+    "@ethersproject/abstract-signer" "^5.0.0"
+    "@ethersproject/address" "^5.0.0"
+    "@ethersproject/bignumber" "^5.0.0"
+    "@ethersproject/bytes" "^5.0.0"
+    "@ethersproject/constants" "^5.0.0"
+    "@ethersproject/hash" "^5.0.0"
+    "@ethersproject/logger" "^5.0.0"
+    "@ethersproject/networks" "^5.0.0"
+    "@ethersproject/properties" "^5.0.0"
+    "@ethersproject/random" "^5.0.0"
+    "@ethersproject/rlp" "^5.0.0"
+    "@ethersproject/strings" "^5.0.0"
+    "@ethersproject/transactions" "^5.0.0"
+    "@ethersproject/web" "^5.0.0"
+    ws "7.2.3"
+
+"@ethersproject/random@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/random/-/random-5.0.1.tgz#cc5433c54e26faddf7c036e07a4f125d64503edb"
+  integrity sha512-nYzNhcp5Th4dCocV3yceZmh80bRmSQxqNRgND7Y/YgEgYJSSnknScpfRHACG//kgbsY8zui8ajXJeEnzS7yFbQ==
+  dependencies:
+    "@ethersproject/bytes" "^5.0.0"
+    "@ethersproject/logger" "^5.0.0"
+
+"@ethersproject/rlp@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/rlp/-/rlp-5.0.1.tgz#3407b0cb78f82a1a219aecff57578c0558ae26c8"
+  integrity sha512-3F8XE1zS4w8w4xiK1hMtFuVs6UnhQlmrEHLT85GanqK8vG5wGi81IQmkukL9tQIu2a5jykoO46ibja+6N1fpFg==
+  dependencies:
+    "@ethersproject/bytes" "^5.0.0"
+    "@ethersproject/logger" "^5.0.0"
+
+"@ethersproject/sha2@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/sha2/-/sha2-5.0.1.tgz#46b1b06cfd7d557ae4deab4cc85773f7512c4022"
+  integrity sha512-5wNdULNDMJKwyzqrTH66e2TZPZTSqqluS7RNtuuuQSTP+yIALoID7ewLjDoj31g4kZyq/pqQbackKJLOXejTKw==
+  dependencies:
+    "@ethersproject/bytes" "^5.0.0"
+    "@ethersproject/logger" "^5.0.0"
+    hash.js "1.1.3"
+
+"@ethersproject/signing-key@^5.0.0":
+  version "5.0.2"
+  resolved "https://registry.yarnpkg.com/@ethersproject/signing-key/-/signing-key-5.0.2.tgz#ca3cff00d92220fcf7d124e03a139182d627cff3"
+  integrity sha512-kgpCdtgoLoKXJTwJPw3ggRW7EO93YCQ98zY8hBpIb4OK3FxFCR3UUjlrGEwjMnLHDjFrxpKCeJagGWf477RyMQ==
+  dependencies:
+    "@ethersproject/bytes" "^5.0.0"
+    "@ethersproject/logger" "^5.0.0"
+    "@ethersproject/properties" "^5.0.0"
+    elliptic "6.5.3"
+
+"@ethersproject/solidity@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/solidity/-/solidity-5.0.1.tgz#df561603ba1c420e2ea309fca746698c55710a6d"
+  integrity sha512-3L+xI1LaJmd2zBJxnK9Y4cd1vb2aJLFvL6fxvjWpzcMiFiZ4dbPwj3kharv5f5mAlbGwAs6NiPJaFWvbOpm96Q==
+  dependencies:
+    "@ethersproject/bignumber" "^5.0.0"
+    "@ethersproject/bytes" "^5.0.0"
+    "@ethersproject/keccak256" "^5.0.0"
+    "@ethersproject/sha2" "^5.0.0"
+    "@ethersproject/strings" "^5.0.0"
+
+"@ethersproject/strings@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/strings/-/strings-5.0.1.tgz#a93aafeede100c4aad7f48e25aad1ddc42eeccc7"
+  integrity sha512-N8LxdHGBT7GZdogkEOV5xKXYTz5PNHuNzcxLNPYfH3kpvWSyXshZBgAz8YE1a8sMZagGj+Ic6d3mHijdCTSkGA==
+  dependencies:
+    "@ethersproject/bytes" "^5.0.0"
+    "@ethersproject/constants" "^5.0.0"
+    "@ethersproject/logger" "^5.0.0"
+
+"@ethersproject/transactions@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/transactions/-/transactions-5.0.1.tgz#61480dc600f4a49eb99627778e3b46b381f8bdd9"
+  integrity sha512-IGc6/5hri3PrqR/ZCj89osDiq3Lt0CSrycn6vlRl8SjpBKYDdcT+Ru5xkeC7YcsnqcdBmTL+jyR3SLudU+x2Kw==
+  dependencies:
+    "@ethersproject/address" "^5.0.0"
+    "@ethersproject/bignumber" "^5.0.0"
+    "@ethersproject/bytes" "^5.0.0"
+    "@ethersproject/constants" "^5.0.0"
+    "@ethersproject/keccak256" "^5.0.0"
+    "@ethersproject/logger" "^5.0.0"
+    "@ethersproject/properties" "^5.0.0"
+    "@ethersproject/rlp" "^5.0.0"
+    "@ethersproject/signing-key" "^5.0.0"
+
+"@ethersproject/units@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/units/-/units-5.0.1.tgz#f9fd97d0bfa0c23d55084b428053a29b42082a1f"
+  integrity sha512-7J7Jmm4hMZ+yFiqEd7D5oeVK/V74GDwQlT0Om1yxXLYX6UPcV5ChHkUz/xpHPT9JXQlQ+2D69HBf1dzvdflrmQ==
+  dependencies:
+    "@ethersproject/bignumber" "^5.0.0"
+    "@ethersproject/constants" "^5.0.0"
+    "@ethersproject/logger" "^5.0.0"
+
+"@ethersproject/wallet@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/wallet/-/wallet-5.0.1.tgz#595077365c674654e90d3884594a86d70ba07e7e"
+  integrity sha512-1/QPpFngJtUGtdVOLSoIN3vf+zEWyEVxQ0lhRCwGkiBqL2SoVoDHB7/nCfcv7wwlZkdnegFfo/8DxeyYjTZN7w==
+  dependencies:
+    "@ethersproject/abstract-provider" "^5.0.0"
+    "@ethersproject/abstract-signer" "^5.0.0"
+    "@ethersproject/address" "^5.0.0"
+    "@ethersproject/bignumber" "^5.0.0"
+    "@ethersproject/bytes" "^5.0.0"
+    "@ethersproject/hash" "^5.0.0"
+    "@ethersproject/hdnode" "^5.0.0"
+    "@ethersproject/json-wallets" "^5.0.0"
+    "@ethersproject/keccak256" "^5.0.0"
+    "@ethersproject/logger" "^5.0.0"
+    "@ethersproject/properties" "^5.0.0"
+    "@ethersproject/random" "^5.0.0"
+    "@ethersproject/signing-key" "^5.0.0"
+    "@ethersproject/transactions" "^5.0.0"
+    "@ethersproject/wordlists" "^5.0.0"
+
+"@ethersproject/web@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/web/-/web-5.0.1.tgz#b741096b5ad9465a1148b7dba8988c1da16f592a"
+  integrity sha512-lWPg8BR6KoyiIKYRIM6j+XO9bT9vGM1JnxFj2HmhIvOrOjba7ZRd8ANBOsDVGfw5igLUdfqAUOf9WpSsH//TzA==
+  dependencies:
+    "@ethersproject/base64" "^5.0.0"
+    "@ethersproject/logger" "^5.0.0"
+    "@ethersproject/properties" "^5.0.0"
+    "@ethersproject/strings" "^5.0.0"
+
+"@ethersproject/wordlists@^5.0.0":
+  version "5.0.1"
+  resolved "https://registry.yarnpkg.com/@ethersproject/wordlists/-/wordlists-5.0.1.tgz#4b1ef0894665fc8e7898235d3aa155f1724efa75"
+  integrity sha512-R7boLmpewucz5v4jD7cWwI0BGHR/DstiZtjdhUOft6XdMqM1OGb1UTL0GBQeS4vDXzCLuJEHddjJ69beGVN/4Q==
+  dependencies:
+    "@ethersproject/bytes" "^5.0.0"
+    "@ethersproject/hash" "^5.0.0"
+    "@ethersproject/logger" "^5.0.0"
+    "@ethersproject/properties" "^5.0.0"
+    "@ethersproject/strings" "^5.0.0"
+
+"@typechain/ethers-v5@^0.0.1":
+  version "0.0.1"
+  resolved "https://registry.yarnpkg.com/@typechain/ethers-v5/-/ethers-v5-0.0.1.tgz#92c52cc55c1b8f2abb63b048c5d5490245051e7b"
+  integrity sha512-vENQPJfSwtWXctcE7ua73Xl6VHXRXMr7Na8/8pO++/I/UrxJe3Whyrj+3DIxdntHaG96iAYiv8/F89ehsoblQg==
+  dependencies:
+    ethers "^5.0.2"
+
+"@types/bn.js@^4.11.6":
+  version "4.11.6"
+  resolved "https://registry.yarnpkg.com/@types/bn.js/-/bn.js-4.11.6.tgz#c306c70d9358aaea33cd4eda092a742b9505967c"
+  integrity sha512-pqr857jrp2kPuO9uRjZ3PwnJTjoQy+fcdxvBTvHm6dkmEL9q+hDD/2j/0ELOBPtPnS8LjCX0gI9nbl8lVkadpg==
+  dependencies:
+    "@types/node" "*"
+
+"@types/mkdirp@^0.5.2":
+  version "0.5.2"
+  resolved "https://registry.yarnpkg.com/@types/mkdirp/-/mkdirp-0.5.2.tgz#503aacfe5cc2703d5484326b1b27efa67a339c1f"
+  integrity sha512-U5icWpv7YnZYGsN4/cmh3WD2onMY0aJIiTE6+51TwJCttdHvtCYmkBNOobHlXwrJRL0nkH9jH4kD+1FAdMN4Tg==
+  dependencies:
+    "@types/node" "*"
+
+"@types/node@*":
+  version "13.11.1"
+  resolved "https://registry.yarnpkg.com/@types/node/-/node-13.11.1.tgz#49a2a83df9d26daacead30d0ccc8762b128d53c7"
+  integrity sha512-eWQGP3qtxwL8FGneRrC5DwrJLGN4/dH1clNTuLfN81HCrxVtxRjygDTUoZJ5ASlDEeo0ppYFQjQIlXhtXpOn6g==
+
+"@types/prettier@^1.13.2":
+  version "1.19.1"
+  resolved "https://registry.yarnpkg.com/@types/prettier/-/prettier-1.19.1.tgz#33509849f8e679e4add158959fdb086440e9553f"
+  integrity sha512-5qOlnZscTn4xxM5MeGXAMOsIOIKIbh9e85zJWfBRVPlRMEVawzoPhINYbRGkBZCI8LxvBe7tJCdWiarA99OZfQ==
+
+"@types/resolve@^0.0.8":
+  version "0.0.8"
+  resolved "https://registry.yarnpkg.com/@types/resolve/-/resolve-0.0.8.tgz#f26074d238e02659e323ce1a13d041eee280e194"
+  integrity sha512-auApPaJf3NPfe18hSoJkp8EbZzer2ISk7o8mCC3M9he/a04+gbMF97NkpD2S8riMGvm4BMRI59/SZQSaLTKpsQ==
+  dependencies:
+    "@types/node" "*"
+
+aes-js@3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/aes-js/-/aes-js-3.0.0.tgz#e21df10ad6c2053295bcbb8dab40b09dbea87e4d"
+  integrity sha1-4h3xCtbCBTKVvLuNq0Cwnb6ofk0=
+
+ansi-styles@^3.2.1:
+  version "3.2.1"
+  resolved "https://registry.yarnpkg.com/ansi-styles/-/ansi-styles-3.2.1.tgz#41fbb20243e50b12be0f04b8dedbf07520ce841d"
+  integrity sha512-VT0ZI6kZRdTh8YyJw3SMbYm/u+NqfsAxEpWO0Pf9sq8/e94WxxOpPKx9FR1FlyCtOVDNOQ+8ntlqFxiRc+r5qA==
+  dependencies:
+    color-convert "^1.9.0"
+
+arg@^4.1.0:
+  version "4.1.3"
+  resolved "https://registry.yarnpkg.com/arg/-/arg-4.1.3.tgz#269fc7ad5b8e42cb63c896d5666017261c144089"
+  integrity sha512-58S9QDqG0Xx27YwPSt9fJxivjYl432YCwfDMfZ+71RAqUrZef7LrKQZ3LHLOwCS4FLNBplP533Zx895SeOCHvA==
+
+array-back@^1.0.3, array-back@^1.0.4:
+  version "1.0.4"
+  resolved "https://registry.yarnpkg.com/array-back/-/array-back-1.0.4.tgz#644ba7f095f7ffcf7c43b5f0dc39d3c1f03c063b"
+  integrity sha1-ZEun8JX3/898Q7Xw3DnTwfA8Bjs=
+  dependencies:
+    typical "^2.6.0"
+
+array-back@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/array-back/-/array-back-2.0.0.tgz#6877471d51ecc9c9bfa6136fb6c7d5fe69748022"
+  integrity sha512-eJv4pLLufP3g5kcZry0j6WXpIbzYw9GUB4mVJZno9wfwiBxbizTnHCw3VJb07cBihbFX48Y7oSrW9y+gt4glyw==
+  dependencies:
+    typical "^2.6.1"
+
+balanced-match@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/balanced-match/-/balanced-match-1.0.0.tgz#89b4d199ab2bee49de164ea02b89ce462d71b767"
+  integrity sha1-ibTRmasr7kneFk6gK4nORi1xt2c=
+
+bn.js@^4.4.0:
+  version "4.11.8"
+  resolved "https://registry.yarnpkg.com/bn.js/-/bn.js-4.11.8.tgz#2cde09eb5ee341f484746bb0309b3253b1b1442f"
+  integrity sha512-ItfYfPLkWHUjckQCk8xC+LwxgK8NYcXywGigJgSwOP8Y2iyWT4f2vsZnoOXTTbo+o5yXmIUJ4gn5538SO5S3gA==
+
+brace-expansion@^1.1.7:
+  version "1.1.11"
+  resolved "https://registry.yarnpkg.com/brace-expansion/-/brace-expansion-1.1.11.tgz#3c7fcbf529d87226f3d2f52b966ff5271eb441dd"
+  integrity sha512-iCuPHDFgrHX7H2vEI/5xpz07zSHB00TpugqhmYtVmMO6518mCuRMoOYFldEBl0g187ufozdaHgWKcYFb61qGiA==
+  dependencies:
+    balanced-match "^1.0.0"
+    concat-map "0.0.1"
+
+brorand@^1.0.1:
+  version "1.1.0"
+  resolved "https://registry.yarnpkg.com/brorand/-/brorand-1.1.0.tgz#12c25efe40a45e3c323eb8675a0a0ce57b22371f"
+  integrity sha1-EsJe/kCkXjwyPrhnWgoM5XsiNx8=
+
+buffer-from@^1.0.0:
+  version "1.1.1"
+  resolved "https://registry.yarnpkg.com/buffer-from/-/buffer-from-1.1.1.tgz#32713bc028f75c02fdb710d7c7bcec1f2c6070ef"
+  integrity sha512-MQcXEUbCKtEo7bhqEs6560Hyd4XaovZlO/k9V3hjVUF/zwW7KBVdSK4gIt/bzwS9MbR5qob+F5jusZsb0YQK2A==
+
+chalk@^2.4.1:
+  version "2.4.2"
+  resolved "https://registry.yarnpkg.com/chalk/-/chalk-2.4.2.tgz#cd42541677a54333cf541a49108c1432b44c9424"
+  integrity sha512-Mti+f9lpJNcwF4tWV8/OrTTtF1gZi+f8FqlyAdouralcFWFQWF2+NgCHShjkCb+IFBLq9buZwE1xckQU4peSuQ==
+  dependencies:
+    ansi-styles "^3.2.1"
+    escape-string-regexp "^1.0.5"
+    supports-color "^5.3.0"
+
+color-convert@^1.9.0:
+  version "1.9.3"
+  resolved "https://registry.yarnpkg.com/color-convert/-/color-convert-1.9.3.tgz#bb71850690e1f136567de629d2d5471deda4c1e8"
+  integrity sha512-QfAUtd+vFdAtFQcC8CCyYt1fYWxSqAiK2cSD6zDB8N3cpsEBAvRxp9zOGg6G/SHHJYAT88/az/IuDGALsNVbGg==
+  dependencies:
+    color-name "1.1.3"
+
+color-name@1.1.3:
+  version "1.1.3"
+  resolved "https://registry.yarnpkg.com/color-name/-/color-name-1.1.3.tgz#a7d0558bd89c42f795dd42328f740831ca53bc25"
+  integrity sha1-p9BVi9icQveV3UIyj3QIMcpTvCU=
+
+command-line-args@^4.0.7:
+  version "4.0.7"
+  resolved "https://registry.yarnpkg.com/command-line-args/-/command-line-args-4.0.7.tgz#f8d1916ecb90e9e121eda6428e41300bfb64cc46"
+  integrity sha512-aUdPvQRAyBvQd2n7jXcsMDz68ckBJELXNzBybCHOibUWEg0mWTnaYCSRU8h9R+aNRSvDihJtssSRCiDRpLaezA==
+  dependencies:
+    array-back "^2.0.0"
+    find-replace "^1.0.3"
+    typical "^2.6.1"
+
+concat-map@0.0.1:
+  version "0.0.1"
+  resolved "https://registry.yarnpkg.com/concat-map/-/concat-map-0.0.1.tgz#d8a96bd77fd68df7793a73036a3ba0d5405d477b"
+  integrity sha1-2Klr13/Wjfd5OnMDajug1UBdR3s=
+
+debug@^4.1.1:
+  version "4.1.1"
+  resolved "https://registry.yarnpkg.com/debug/-/debug-4.1.1.tgz#3b72260255109c6b589cee050f1d516139664791"
+  integrity sha512-pYAIzeRo8J6KPEaJ0VWOh5Pzkbw/RetuzehGM7QRRX5he4fPHx2rdKMB256ehJCkX+XRQm16eZLqLNS8RSZXZw==
+  dependencies:
+    ms "^2.1.1"
+
+diff@^4.0.1:
+  version "4.0.2"
+  resolved "https://registry.yarnpkg.com/diff/-/diff-4.0.2.tgz#60f3aecb89d5fae520c11aa19efc2bb982aade7d"
+  integrity sha512-58lmxKSA4BNyLz+HHMUzlOEpg09FV+ev6ZMe3vJihgdxzgcwZ8VoEEPmALCZG9LmqfVoNMMKpttIYTVG6uDY7A==
+
+elliptic@6.5.3:
+  version "6.5.3"
+  resolved "https://registry.yarnpkg.com/elliptic/-/elliptic-6.5.3.tgz#cb59eb2efdaf73a0bd78ccd7015a62ad6e0f93d6"
+  integrity sha512-IMqzv5wNQf+E6aHeIqATs0tOLeOTwj1QKbRcS3jBbYkl5oLAserA8yJTT7/VyHUYG91PRmPyeQDObKLPpeS4dw==
+  dependencies:
+    bn.js "^4.4.0"
+    brorand "^1.0.1"
+    hash.js "^1.0.0"
+    hmac-drbg "^1.0.0"
+    inherits "^2.0.1"
+    minimalistic-assert "^1.0.0"
+    minimalistic-crypto-utils "^1.0.0"
+
+escape-string-regexp@^1.0.5:
+  version "1.0.5"
+  resolved "https://registry.yarnpkg.com/escape-string-regexp/-/escape-string-regexp-1.0.5.tgz#1b61c0562190a8dff6ae3bb2cf0200ca130b86d4"
+  integrity sha1-G2HAViGQqN/2rjuyzwIAyhMLhtQ=
+
+ethers@^5.0.2, ethers@^5.0.3:
+  version "5.0.3"
+  resolved "https://registry.yarnpkg.com/ethers/-/ethers-5.0.3.tgz#41587a09934fb4dd5960cfe1fbc67560a53df7d5"
+  integrity sha512-Y9ud5W9Gtuzibyc8tEEkFRd/+uQciUoy0j7PTHF0i8H9521i67NQPXYOIA0NS0fRD2TolNTFeRLNNEY7EA98qg==
+  dependencies:
+    "@ethersproject/abi" "^5.0.0"
+    "@ethersproject/abstract-provider" "^5.0.0"
+    "@ethersproject/abstract-signer" "^5.0.0"
+    "@ethersproject/address" "^5.0.0"
+    "@ethersproject/base64" "^5.0.0"
+    "@ethersproject/bignumber" "^5.0.0"
+    "@ethersproject/bytes" "^5.0.0"
+    "@ethersproject/constants" "^5.0.0"
+    "@ethersproject/contracts" "^5.0.0"
+    "@ethersproject/hash" "^5.0.0"
+    "@ethersproject/hdnode" "^5.0.0"
+    "@ethersproject/json-wallets" "^5.0.0"
+    "@ethersproject/keccak256" "^5.0.0"
+    "@ethersproject/logger" "^5.0.0"
+    "@ethersproject/networks" "^5.0.0"
+    "@ethersproject/pbkdf2" "^5.0.0"
+    "@ethersproject/properties" "^5.0.0"
+    "@ethersproject/providers" "^5.0.0"
+    "@ethersproject/random" "^5.0.0"
+    "@ethersproject/rlp" "^5.0.0"
+    "@ethersproject/sha2" "^5.0.0"
+    "@ethersproject/signing-key" "^5.0.0"
+    "@ethersproject/solidity" "^5.0.0"
+    "@ethersproject/strings" "^5.0.0"
+    "@ethersproject/transactions" "^5.0.0"
+    "@ethersproject/units" "^5.0.0"
+    "@ethersproject/wallet" "^5.0.0"
+    "@ethersproject/web" "^5.0.0"
+    "@ethersproject/wordlists" "^5.0.0"
+
+find-replace@^1.0.3:
+  version "1.0.3"
+  resolved "https://registry.yarnpkg.com/find-replace/-/find-replace-1.0.3.tgz#b88e7364d2d9c959559f388c66670d6130441fa0"
+  integrity sha1-uI5zZNLZyVlVnziMZmcNYTBEH6A=
+  dependencies:
+    array-back "^1.0.4"
+    test-value "^2.1.0"
+
+fs-extra@^7.0.0:
+  version "7.0.1"
+  resolved "https://registry.yarnpkg.com/fs-extra/-/fs-extra-7.0.1.tgz#4f189c44aa123b895f722804f55ea23eadc348e9"
+  integrity sha512-YJDaCJZEnBmcbw13fvdAM9AwNOJwOzrE4pqMqBq5nFiEqXUqHwlK4B+3pUw6JNvfSPtX05xFHtYy/1ni01eGCw==
+  dependencies:
+    graceful-fs "^4.1.2"
+    jsonfile "^4.0.0"
+    universalify "^0.1.0"
+
+fs.realpath@^1.0.0:
+  version "1.0.0"
+  resolved "https://registry.yarnpkg.com/fs.realpath/-/fs.realpath-1.0.0.tgz#1504ad2523158caa40db4a2787cb01411994ea4f"
+  integrity sha1-FQStJSMVjKpA20onh8sBQRmU6k8=
+
+glob@^7.1.2:
+  version "7.1.6"
+  resolved "https://registry.yarnpkg.com/glob/-/glob-7.1.6.tgz#141f33b81a7c2492e125594307480c46679278a6"
+  integrity sha512-LwaxwyZ72Lk7vZINtNNrywX0ZuLyStrdDtabefZKAY5ZGJhVtgdznluResxNmPitE0SAO+O26sWTHeKSI2wMBA==
+  dependencies:
+    fs.realpath "^1.0.0"
+    inflight "^1.0.4"
+    inherits "2"
+    minimatch "^3.0.4"
+    once "^1.3.0"
+    path-is-absolute "^1.0.0"
+
+graceful-fs@^4.1.2, graceful-fs@^4.1.6:
+  version "4.2.3"
+  resolved "https://registry.yarnpkg.com/graceful-fs/-/graceful-fs-4.2.3.tgz#4a12ff1b60376ef09862c2093edd908328be8423"
+  integrity sha512-a30VEBm4PEdx1dRB7MFK7BejejvCvBronbLjht+sHuGYj8PHs7M/5Z+rt5lw551vZ7yfTCj4Vuyy3mSJytDWRQ==
+
+has-flag@^3.0.0:
+  version "3.0.0"
+  resolved "https://registry.yarnpkg.com/has-flag/-/has-flag-3.0.0.tgz#b5d454dc2199ae225699f3467e5a07f3b955bafd"
+  integrity sha1-tdRU3CGZriJWmfNGfloH87lVuv0=
+
+hash.js@1.1.3:
+  version "1.1.3"
+  resolved "https://registry.yarnpkg.com/hash.js/-/hash.js-1.1.3.tgz#340dedbe6290187151c1ea1d777a3448935df846"
+  integrity sha512-/UETyP0W22QILqS+6HowevwhEFJ3MBJnwTf75Qob9Wz9t0DPuisL8kW8YZMK62dHAKE1c1p+gY1TtOLY+USEHA==
+  dependencies:
+    inherits "^2.0.3"
+    minimalistic-assert "^1.0.0"
+
+hash.js@^1.0.0, hash.js@^1.0.3:
+  version "1.1.7"
+  resolved "https://registry.yarnpkg.com/hash.js/-/hash.js-1.1.7.tgz#0babca538e8d4ee4a0f8988d68866537a003cf42"
+  integrity sha512-taOaskGt4z4SOANNseOviYDvjEJinIkRgmp7LbKP2YTTmVxWBl87s/uzK9r+44BclBSp2X7K1hqeNfz9JbBeXA==
+  dependencies:
+    inherits "^2.0.3"
+    minimalistic-assert "^1.0.1"
+
+hmac-drbg@^1.0.0:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/hmac-drbg/-/hmac-drbg-1.0.1.tgz#d2745701025a6c775a6c545793ed502fc0c649a1"
+  integrity sha1-0nRXAQJabHdabFRXk+1QL8DGSaE=
+  dependencies:
+    hash.js "^1.0.3"
+    minimalistic-assert "^1.0.0"
+    minimalistic-crypto-utils "^1.0.1"
+
+inflight@^1.0.4:
+  version "1.0.6"
+  resolved "https://registry.yarnpkg.com/inflight/-/inflight-1.0.6.tgz#49bd6331d7d02d0c09bc910a1075ba8165b56df9"
+  integrity sha1-Sb1jMdfQLQwJvJEKEHW6gWW1bfk=
+  dependencies:
+    once "^1.3.0"
+    wrappy "1"
+
+inherits@2, inherits@^2.0.1, inherits@^2.0.3:
+  version "2.0.4"
+  resolved "https://registry.yarnpkg.com/inherits/-/inherits-2.0.4.tgz#0fa2c64f932917c3433a0ded55363aae37416b7c"
+  integrity sha512-k/vGaX4/Yla3WzyMCvTQOXYeIHvqOKtnqBduzTHpzpQZzAskKMhZ2K+EnBiSM9zGSoIFeMpXKxa4dYeZIQqewQ==
+
+js-sha3@0.5.7:
+  version "0.5.7"
+  resolved "https://registry.yarnpkg.com/js-sha3/-/js-sha3-0.5.7.tgz#0d4ffd8002d5333aabaf4a23eed2f6374c9f28e7"
+  integrity sha1-DU/9gALVMzqrr0oj7tL2N0yfKOc=
+
+js-sha3@^0.8.0:
+  version "0.8.0"
+  resolved "https://registry.yarnpkg.com/js-sha3/-/js-sha3-0.8.0.tgz#b9b7a5da73afad7dedd0f8c463954cbde6818840"
+  integrity sha512-gF1cRrHhIzNfToc802P800N8PpXS+evLLXfsVpowqmAFR9uwbi89WvXg2QspOmXL8QL86J4T1EpFu+yUkwJY3Q==
+
+jsonfile@^4.0.0:
+  version "4.0.0"
+  resolved "https://registry.yarnpkg.com/jsonfile/-/jsonfile-4.0.0.tgz#8771aae0799b64076b76640fca058f9c10e33ecb"
+  integrity sha1-h3Gq4HmbZAdrdmQPygWPnBDjPss=
+  optionalDependencies:
+    graceful-fs "^4.1.6"
+
+lodash@^4.17.15:
+  version "4.17.15"
+  resolved "https://registry.yarnpkg.com/lodash/-/lodash-4.17.15.tgz#b447f6670a0455bbfeedd11392eff330ea097548"
+  integrity sha512-8xOcRHvCjnocdS5cpwXQXVzmmh5e5+saE2QGoeQmbKmRS6J3VQppPOIt0MnmE+4xlZoumy0GPG0D0MVIQbNA1A==
+
+make-error@^1.1.1:
+  version "1.3.6"
+  resolved "https://registry.yarnpkg.com/make-error/-/make-error-1.3.6.tgz#2eb2e37ea9b67c4891f684a1394799af484cf7a2"
+  integrity sha512-s8UhlNe7vPKomQhC1qFelMokr/Sc3AgNbso3n74mVPA5LTZwkB9NlXf4XPamLxJE8h0gh73rM94xvwRT2CVInw==
+
+minimalistic-assert@^1.0.0, minimalistic-assert@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/minimalistic-assert/-/minimalistic-assert-1.0.1.tgz#2e194de044626d4a10e7f7fbc00ce73e83e4d5c7"
+  integrity sha512-UtJcAD4yEaGtjPezWuO9wC4nwUnVH/8/Im3yEHQP4b67cXlD/Qr9hdITCU1xDbSEXg2XKNaP8jsReV7vQd00/A==
+
+minimalistic-crypto-utils@^1.0.0, minimalistic-crypto-utils@^1.0.1:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/minimalistic-crypto-utils/-/minimalistic-crypto-utils-1.0.1.tgz#f6c00c1c0b082246e5c4d99dfb8c7c083b2b582a"
+  integrity sha1-9sAMHAsIIkblxNmd+4x8CDsrWCo=
+
+minimatch@^3.0.4:
+  version "3.0.4"
+  resolved "https://registry.yarnpkg.com/minimatch/-/minimatch-3.0.4.tgz#5166e286457f03306064be5497e8dbb0c3d32083"
+  integrity sha512-yJHVQEhyqPLUTgt9B83PXu6W3rx4MvvHvSUvToogpwoGDOUQ+yDrR0HRot+yOCdCO7u4hX3pWft6kWBBcqh0UA==
+  dependencies:
+    brace-expansion "^1.1.7"
+
+minimist@^1.2.5:
+  version "1.2.5"
+  resolved "https://registry.yarnpkg.com/minimist/-/minimist-1.2.5.tgz#67d66014b66a6a8aaa0c083c5fd58df4e4e97602"
+  integrity sha512-FM9nNUYrRBAELZQT3xeZQ7fmMOBg6nWNmJKTcgsJeaLstP/UODVpGsr5OhXhhXg6f+qtJ8uiZ+PUxkDWcgIXLw==
+
+mkdirp@^0.5.1:
+  version "0.5.5"
+  resolved "https://registry.yarnpkg.com/mkdirp/-/mkdirp-0.5.5.tgz#d91cefd62d1436ca0f41620e251288d420099def"
+  integrity sha512-NKmAlESf6jMGym1++R0Ra7wvhV+wFW63FaSOFPwRahvea0gMUcGUhVeAg/0BC0wiv9ih5NYPB1Wn1UEI1/L+xQ==
+  dependencies:
+    minimist "^1.2.5"
+
+ms@^2.1.1:
+  version "2.1.2"
+  resolved "https://registry.yarnpkg.com/ms/-/ms-2.1.2.tgz#d09d1f357b443f493382a8eb3ccd183872ae6009"
+  integrity sha512-sGkPx+VjMtmA6MX27oA4FBFELFCZZ4S4XqeGOXCv68tT+jb3vk/RyaKWP0PTKyWtmLSM0b+adUTEvbs1PEaH2w==
+
+once@^1.3.0:
+  version "1.4.0"
+  resolved "https://registry.yarnpkg.com/once/-/once-1.4.0.tgz#583b1aa775961d4b113ac17d9c50baef9dd76bd1"
+  integrity sha1-WDsap3WWHUsROsF9nFC6753Xa9E=
+  dependencies:
+    wrappy "1"
+
+path-is-absolute@^1.0.0:
+  version "1.0.1"
+  resolved "https://registry.yarnpkg.com/path-is-absolute/-/path-is-absolute-1.0.1.tgz#174b9268735534ffbc7ace6bf53a5a9e1b5c5f5f"
+  integrity sha1-F0uSaHNVNP+8es5r9TpanhtcX18=
+
+path-parse@^1.0.6:
+  version "1.0.6"
+  resolved "https://registry.yarnpkg.com/path-parse/-/path-parse-1.0.6.tgz#d62dbb5679405d72c4737ec58600e9ddcf06d24c"
+  integrity sha512-GSmOT2EbHrINBf9SR7CDELwlJ8AENk3Qn7OikK4nFYAu3Ote2+JYNVvkpAEQm3/TLNEJFD/xZJjzyxg3KBWOzw==
+
+prettier@^1.14.2:
+  version "1.19.1"
+  resolved "https://registry.yarnpkg.com/prettier/-/prettier-1.19.1.tgz#f7d7f5ff8a9cd872a7be4ca142095956a60797cb"
+  integrity sha512-s7PoyDv/II1ObgQunCbB9PdLmUcBZcnWOcxDh7O0N/UwDEsHyqkW+Qh28jW+mVuCdx7gLB0BotYI1Y6uI9iyew==
+
+resolve@^1.8.1:
+  version "1.15.1"
+  resolved "https://registry.yarnpkg.com/resolve/-/resolve-1.15.1.tgz#27bdcdeffeaf2d6244b95bb0f9f4b4653451f3e8"
+  integrity sha512-84oo6ZTtoTUpjgNEr5SJyzQhzL72gaRodsSfyxC/AXRvwu0Yse9H8eF9IpGo7b8YetZhlI6v7ZQ6bKBFV/6S7w==
+  dependencies:
+    path-parse "^1.0.6"
+
+scrypt-js@3.0.1:
+  version "3.0.1"
+  resolved "https://registry.yarnpkg.com/scrypt-js/-/scrypt-js-3.0.1.tgz#d314a57c2aef69d1ad98a138a21fe9eafa9ee312"
+  integrity sha512-cdwTTnqPu0Hyvf5in5asVdZocVDTNRmR7XEcJuIzMjJeSHybHl7vpB66AzwTaIg6CLSbtjcxc8fqcySfnTkccA==
+
+source-map-support@^0.5.6:
+  version "0.5.16"
+  resolved "https://registry.yarnpkg.com/source-map-support/-/source-map-support-0.5.16.tgz#0ae069e7fe3ba7538c64c98515e35339eac5a042"
+  integrity sha512-efyLRJDr68D9hBBNIPWFjhpFzURh+KJykQwvMyW5UiZzYwoF6l4YMMDIJJEyFWxWCqfyxLzz6tSfUFR+kXXsVQ==
+  dependencies:
+    buffer-from "^1.0.0"
+    source-map "^0.6.0"
+
+source-map@^0.6.0:
+  version "0.6.1"
+  resolved "https://registry.yarnpkg.com/source-map/-/source-map-0.6.1.tgz#74722af32e9614e9c287a8d0bbde48b5e2f1a263"
+  integrity sha512-UjgapumWlbMhkBgzT7Ykc5YXUT46F0iKu8SGXq0bcwP5dz/h0Plj6enJqjz1Zbq2l5WaqYnrVbwWOWMyF3F47g==
+
+supports-color@^5.3.0:
+  version "5.5.0"
+  resolved "https://registry.yarnpkg.com/supports-color/-/supports-color-5.5.0.tgz#e2e69a44ac8772f78a1ec0b35b689df6530efc8f"
+  integrity sha512-QjVjwdXIt408MIiAqCX4oUKsgU2EqAGzs2Ppkm4aQYbjm+ZEWEcW4SfFNTr4uMNZma0ey4f5lgLrkB0aX0QMow==
+  dependencies:
+    has-flag "^3.0.0"
+
+test-value@^2.1.0:
+  version "2.1.0"
+  resolved "https://registry.yarnpkg.com/test-value/-/test-value-2.1.0.tgz#11da6ff670f3471a73b625ca4f3fdcf7bb748291"
+  integrity sha1-Edpv9nDzRxpztiXKTz/c97t0gpE=
+  dependencies:
+    array-back "^1.0.3"
+    typical "^2.6.0"
+
+ts-essentials@^1.0.0:
+  version "1.0.4"
+  resolved "https://registry.yarnpkg.com/ts-essentials/-/ts-essentials-1.0.4.tgz#ce3b5dade5f5d97cf69889c11bf7d2da8555b15a"
+  integrity sha512-q3N1xS4vZpRouhYHDPwO0bDW3EZ6SK9CrrDHxi/D6BPReSjpVgWIOpLS2o0gSBZm+7q/wyKp6RVM1AeeW7uyfQ==
+
+ts-essentials@^6.0.3:
+  version "6.0.4"
+  resolved "https://registry.yarnpkg.com/ts-essentials/-/ts-essentials-6.0.4.tgz#d36055bf0a7620b1338da6aafd2268787e208aab"
+  integrity sha512-ZtU9zgSnn8DcAxDZY1DJF8rnxsen8M0IVkO7dVB5fTEOVs7o/0RA4V6i99PIg99bpX81Sgb0FCLjQqD5Ufz3rQ==
+
+ts-generator@^0.0.8:
+  version "0.0.8"
+  resolved "https://registry.yarnpkg.com/ts-generator/-/ts-generator-0.0.8.tgz#7bd48ca064db026d9520bcb682b69efc20971d6a"
+  integrity sha512-Gi+aZCELpVL7Mqb+GuMgM+n8JZ/arZZib1iD/R9Ok8JDjOCOCrqS9b1lr72ku7J45WeDCFZxyJoRsiQvhokCnw==
+  dependencies:
+    "@types/mkdirp" "^0.5.2"
+    "@types/prettier" "^1.13.2"
+    "@types/resolve" "^0.0.8"
+    chalk "^2.4.1"
+    glob "^7.1.2"
+    mkdirp "^0.5.1"
+    prettier "^1.14.2"
+    resolve "^1.8.1"
+    ts-essentials "^1.0.0"
+
+ts-node@^8.8.2:
+  version "8.8.2"
+  resolved "https://registry.yarnpkg.com/ts-node/-/ts-node-8.8.2.tgz#0b39e690bee39ea5111513a9d2bcdc0bc121755f"
+  integrity sha512-duVj6BpSpUpD/oM4MfhO98ozgkp3Gt9qIp3jGxwU2DFvl/3IRaEAvbLa8G60uS7C77457e/m5TMowjedeRxI1Q==
+  dependencies:
+    arg "^4.1.0"
+    diff "^4.0.1"
+    make-error "^1.1.1"
+    source-map-support "^0.5.6"
+    yn "3.1.1"
+
+typechain@^2.0.0:
+  version "2.0.0"
+  resolved "https://registry.yarnpkg.com/typechain/-/typechain-2.0.0.tgz#62143b48cdf8f95a777f1b76617af077b2d44eee"
+  integrity sha512-O+hsAUwtBpqCfoq46Grm52OEdm0GBEu78LxrEzkkGdwUdCoCZpNb2HPzPoNB1MXiRnNhEOGMFyf05UbT2/bUEw==
+  dependencies:
+    command-line-args "^4.0.7"
+    debug "^4.1.1"
+    fs-extra "^7.0.0"
+    js-sha3 "^0.8.0"
+    lodash "^4.17.15"
+    ts-essentials "^6.0.3"
+    ts-generator "^0.0.8"
+
+typescript@^3.8.3:
+  version "3.8.3"
+  resolved "https://registry.yarnpkg.com/typescript/-/typescript-3.8.3.tgz#409eb8544ea0335711205869ec458ab109ee1061"
+  integrity sha512-MYlEfn5VrLNsgudQTVJeNaQFUAI7DkhnOjdpAp4T+ku1TfQClewlbSuTVHiA+8skNBgaf02TL/kLOvig4y3G8w==
+
+typical@^2.6.0, typical@^2.6.1:
+  version "2.6.1"
+  resolved "https://registry.yarnpkg.com/typical/-/typical-2.6.1.tgz#5c080e5d661cbbe38259d2e70a3c7253e873881d"
+  integrity sha1-XAgOXWYcu+OCWdLnCjxyU+hziB0=
+
+universalify@^0.1.0:
+  version "0.1.2"
+  resolved "https://registry.yarnpkg.com/universalify/-/universalify-0.1.2.tgz#b646f69be3942dabcecc9d6639c80dc105efaa66"
+  integrity sha512-rBJeI5CXAlmy1pV+617WB9J63U6XcazHHF2f2dbJix4XzpUF0RS3Zbj0FGIOCAva5P/d/GBOYaACQ1w+0azUkg==
+
+uuid@2.0.1:
+  version "2.0.1"
+  resolved "https://registry.yarnpkg.com/uuid/-/uuid-2.0.1.tgz#c2a30dedb3e535d72ccf82e343941a50ba8533ac"
+  integrity sha1-wqMN7bPlNdcsz4LjQ5QaULqFM6w=
+
+wrappy@1:
+  version "1.0.2"
+  resolved "https://registry.yarnpkg.com/wrappy/-/wrappy-1.0.2.tgz#b5243d8f3ec1aa35f1364605bc0d1036e30ab69f"
+  integrity sha1-tSQ9jz7BqjXxNkYFvA0QNuMKtp8=
+
+ws@7.2.3:
+  version "7.2.3"
+  resolved "https://registry.yarnpkg.com/ws/-/ws-7.2.3.tgz#a5411e1fb04d5ed0efee76d26d5c46d830c39b46"
+  integrity sha512-HTDl9G9hbkNDk98naoR/cHDws7+EyYMOdL1BmjsZXRUjf7d+MficC4B7HLUPlSiho0vg+CWKrGIt/VJBd1xunQ==
+
+yn@3.1.1:
+  version "3.1.1"
+  resolved "https://registry.yarnpkg.com/yn/-/yn-3.1.1.tgz#1e87401a09d767c1d5eab26a6e4c185182d2eb50"
+  integrity sha512-Ux4ygGWsu2c7isFWe8Yu1YluJmqVhxqK2cLXNQA5AcC3QfbGNpM7fu0Y8b/z16pXLnFxZYvWhd3fhBY9DLmC6Q==
diff --git a/packages/target-ethers-v5/package.json b/packages/target-ethers-v5/package.json
index 4da32b070..98b820765 100644
--- a/packages/target-ethers-v5/package.json
+++ b/packages/target-ethers-v5/package.json
@@ -8,7 +8,7 @@
     "TypeChain",
     "TypeScript"
   ],
-  "version": "1.0.0",
+  "version": "0.0.1",
   "license": "MIT",
   "repository": "https://github.com/ethereum-ts/Typechain",
   "main": "./dist/index.js",

From fe72e82b8aa386ed079849c77b6ea1e3d7480259 Mon Sep 17 00:00:00 2001
From: Krzysztof Kaczor <krzkaczor@gmail.com>
Date: Tue, 30 Jun 2020 22:09:30 +0200
Subject: [PATCH 41/64] git ignore fix

---
 .gitignore | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/.gitignore b/.gitignore
index a95a3f90c..ed2b40d66 100644
--- a/.gitignore
+++ b/.gitignore
@@ -14,5 +14,5 @@ examples/truffle-v4/types
 examples/truffle-v4/migrations
 examples/truffle-v5/types
 examples/truffle-v5/migrations
-# examples/ethers-v4/types
+examples/ethers-v4/types
 examples/ethers-v5/types

From 68a3750048216cb494fdad22bdd5e8399c50f4c2 Mon Sep 17 00:00:00 2001
From: zemse <sohamzemse143@gmail.com>
Date: Fri, 3 Jul 2020 14:02:53 +0530
Subject: [PATCH 42/64] Update staticCall to callStatic
 (ethers-io/ethers.js#924)

---
 packages/target-ethers-v5-test/types/DataTypesInput.d.ts | 2 +-
 packages/target-ethers-v5-test/types/DataTypesPure.d.ts  | 2 +-
 packages/target-ethers-v5-test/types/DataTypesView.d.ts  | 2 +-
 packages/target-ethers-v5-test/types/Events.d.ts         | 2 +-
 packages/target-ethers-v5-test/types/NameMangling.d.ts   | 2 +-
 packages/target-ethers-v5-test/types/Overloads.d.ts      | 2 +-
 packages/target-ethers-v5-test/types/Payable.d.ts        | 2 +-
 packages/target-ethers-v5/src/codegen/index.ts           | 2 +-
 8 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/packages/target-ethers-v5-test/types/DataTypesInput.d.ts b/packages/target-ethers-v5-test/types/DataTypesInput.d.ts
index e95cd8ccb..e634d07c8 100644
--- a/packages/target-ethers-v5-test/types/DataTypesInput.d.ts
+++ b/packages/target-ethers-v5-test/types/DataTypesInput.d.ts
@@ -295,7 +295,7 @@ export class DataTypesInput extends Contract {
 
   input_uint8(input1: BigNumberish, overrides?: CallOverrides): Promise<number>;
 
-  staticCall: {
+  callStatic: {
     input_address(input1: string, overrides?: CallOverrides): Promise<string>;
 
     input_bool(input1: boolean, overrides?: CallOverrides): Promise<boolean>;
diff --git a/packages/target-ethers-v5-test/types/DataTypesPure.d.ts b/packages/target-ethers-v5-test/types/DataTypesPure.d.ts
index 2a8b0524a..75fa19bfc 100644
--- a/packages/target-ethers-v5-test/types/DataTypesPure.d.ts
+++ b/packages/target-ethers-v5-test/types/DataTypesPure.d.ts
@@ -278,7 +278,7 @@ export class DataTypesPure extends Contract {
 
   pure_uint8(overrides?: CallOverrides): Promise<number>;
 
-  staticCall: {
+  callStatic: {
     pure_address(overrides?: CallOverrides): Promise<string>;
 
     pure_bool(overrides?: CallOverrides): Promise<boolean>;
diff --git a/packages/target-ethers-v5-test/types/DataTypesView.d.ts b/packages/target-ethers-v5-test/types/DataTypesView.d.ts
index 5a3b7b9f0..f1fbf2cdd 100644
--- a/packages/target-ethers-v5-test/types/DataTypesView.d.ts
+++ b/packages/target-ethers-v5-test/types/DataTypesView.d.ts
@@ -278,7 +278,7 @@ export class DataTypesView extends Contract {
 
   view_uint8(overrides?: CallOverrides): Promise<number>;
 
-  staticCall: {
+  callStatic: {
     view_address(overrides?: CallOverrides): Promise<string>;
 
     view_bool(overrides?: CallOverrides): Promise<boolean>;
diff --git a/packages/target-ethers-v5-test/types/Events.d.ts b/packages/target-ethers-v5-test/types/Events.d.ts
index 480aaceea..9f1f160c0 100644
--- a/packages/target-ethers-v5-test/types/Events.d.ts
+++ b/packages/target-ethers-v5-test/types/Events.d.ts
@@ -114,7 +114,7 @@ export class Events extends Contract {
 
   emit_event3_overloaded(overrides?: Overrides): Promise<ContractTransaction>;
 
-  staticCall: {
+  callStatic: {
     emit_anon1(overrides?: Overrides): Promise<void>;
 
     emit_event1(overrides?: Overrides): Promise<void>;
diff --git a/packages/target-ethers-v5-test/types/NameMangling.d.ts b/packages/target-ethers-v5-test/types/NameMangling.d.ts
index 479775c58..b14c53184 100644
--- a/packages/target-ethers-v5-test/types/NameMangling.d.ts
+++ b/packages/target-ethers-v5-test/types/NameMangling.d.ts
@@ -53,7 +53,7 @@ export class NameMangling extends Contract {
 
   works(overrides?: CallOverrides): Promise<boolean>;
 
-  staticCall: {
+  callStatic: {
     works(overrides?: CallOverrides): Promise<boolean>;
   };
 
diff --git a/packages/target-ethers-v5-test/types/Overloads.d.ts b/packages/target-ethers-v5-test/types/Overloads.d.ts
index 1d4b534ad..011146244 100644
--- a/packages/target-ethers-v5-test/types/Overloads.d.ts
+++ b/packages/target-ethers-v5-test/types/Overloads.d.ts
@@ -74,7 +74,7 @@ export class Overloads extends Contract {
     overrides?: CallOverrides
   ): Promise<BigNumber>;
 
-  staticCall: {
+  callStatic: {
     "overload1(int256)"(
       input1: BigNumberish,
       overrides?: CallOverrides
diff --git a/packages/target-ethers-v5-test/types/Payable.d.ts b/packages/target-ethers-v5-test/types/Payable.d.ts
index e13a0a229..99b9fc370 100644
--- a/packages/target-ethers-v5-test/types/Payable.d.ts
+++ b/packages/target-ethers-v5-test/types/Payable.d.ts
@@ -69,7 +69,7 @@ export class Payable extends Contract {
 
   payable_func(overrides?: PayableOverrides): Promise<ContractTransaction>;
 
-  staticCall: {
+  callStatic: {
     non_payable_func(overrides?: Overrides): Promise<void>;
 
     payable_func(overrides?: PayableOverrides): Promise<void>;
diff --git a/packages/target-ethers-v5/src/codegen/index.ts b/packages/target-ethers-v5/src/codegen/index.ts
index e6bd416bb..d338405eb 100644
--- a/packages/target-ethers-v5/src/codegen/index.ts
+++ b/packages/target-ethers-v5/src/codegen/index.ts
@@ -78,7 +78,7 @@ export function codegenContractTypings(contract: Contract) {
 
     ${values(contract.functions).map(codegenFunctions.bind(null, {})).join('\n')}
 
-    staticCall: {
+    callStatic: {
       ${values(contract.functions)
         .map(codegenFunctions.bind(null, { isStaticCall: true }))
         .join('\n')}

From 8bb29fb72a79b4ec2c6a4c8f9385185658869f22 Mon Sep 17 00:00:00 2001
From: Krzysztof Kaczor <krzkaczor@gmail.com>
Date: Sat, 4 Jul 2020 11:26:38 +0200
Subject: [PATCH 43/64] bump version

---
 packages/target-ethers-v5/package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/target-ethers-v5/package.json b/packages/target-ethers-v5/package.json
index 98b820765..863bfe4e5 100644
--- a/packages/target-ethers-v5/package.json
+++ b/packages/target-ethers-v5/package.json
@@ -8,7 +8,7 @@
     "TypeChain",
     "TypeScript"
   ],
-  "version": "0.0.1",
+  "version": "0.0.2",
   "license": "MIT",
   "repository": "https://github.com/ethereum-ts/Typechain",
   "main": "./dist/index.js",

From a1b93f05d95230d121f37b4310d3a12946eee8cc Mon Sep 17 00:00:00 2001
From: Braden Napier <brady.napier@dashos.net>
Date: Thu, 9 Jul 2020 00:40:56 -0400
Subject: [PATCH 44/64] fix: fn types to match ethers api

---
 .../types/DataTypesInput.d.ts                 | 153 ++++++++++++++----
 .../types/DataTypesPure.d.ts                  |  82 ++++++----
 .../types/DataTypesView.d.ts                  |  82 ++++++----
 .../target-ethers-v5-test/types/Events.d.ts   |  30 ++--
 .../types/NameMangling.d.ts                   |   4 +-
 .../types/Overloads.d.ts                      |  22 ++-
 .../target-ethers-v5-test/types/Payable.d.ts  |  10 +-
 .../target-ethers-v5/src/codegen/functions.ts |  15 +-
 .../target-ethers-v5/src/codegen/index.ts     |  16 +-
 9 files changed, 290 insertions(+), 124 deletions(-)

diff --git a/packages/target-ethers-v5-test/types/DataTypesInput.d.ts b/packages/target-ethers-v5-test/types/DataTypesInput.d.ts
index e634d07c8..7c06ff7c9 100644
--- a/packages/target-ethers-v5-test/types/DataTypesInput.d.ts
+++ b/packages/target-ethers-v5-test/types/DataTypesInput.d.ts
@@ -359,43 +359,132 @@ export class DataTypesInput extends Contract {
   filters: {};
 
   estimateGas: {
-    input_address(input1: string): Promise<BigNumber>;
-    input_bool(input1: boolean): Promise<BigNumber>;
-    input_bytes(input1: BytesLike): Promise<BigNumber>;
-    input_bytes1(input1: BytesLike): Promise<BigNumber>;
-    input_enum(input1: BigNumberish): Promise<BigNumber>;
-    input_int256(input1: BigNumberish): Promise<BigNumber>;
-    input_int8(input1: BigNumberish): Promise<BigNumber>;
-    input_stat_array(input1: BigNumberish[]): Promise<BigNumber>;
-    input_string(input1: string): Promise<BigNumber>;
-    input_struct(input1: {
-      uint256_0: BigNumberish;
-      uint256_1: BigNumberish;
-    }): Promise<BigNumber>;
-    input_tuple(input1: BigNumberish, input2: BigNumberish): Promise<BigNumber>;
-    input_uint256(input1: BigNumberish): Promise<BigNumber>;
-    input_uint8(input1: BigNumberish): Promise<BigNumber>;
+    input_address(
+      input1: string,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    input_bool(input1: boolean, overrides?: CallOverrides): Promise<BigNumber>;
+
+    input_bytes(
+      input1: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    input_bytes1(
+      input1: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    input_enum(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    input_int256(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    input_int8(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    input_stat_array(
+      input1: BigNumberish[],
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    input_string(input1: string, overrides?: CallOverrides): Promise<BigNumber>;
+
+    input_struct(
+      input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    input_tuple(
+      input1: BigNumberish,
+      input2: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    input_uint256(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    input_uint8(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
   };
 
   populateTransaction: {
-    input_address(input1: string): Promise<PopulatedTransaction>;
-    input_bool(input1: boolean): Promise<PopulatedTransaction>;
-    input_bytes(input1: BytesLike): Promise<PopulatedTransaction>;
-    input_bytes1(input1: BytesLike): Promise<PopulatedTransaction>;
-    input_enum(input1: BigNumberish): Promise<PopulatedTransaction>;
-    input_int256(input1: BigNumberish): Promise<PopulatedTransaction>;
-    input_int8(input1: BigNumberish): Promise<PopulatedTransaction>;
-    input_stat_array(input1: BigNumberish[]): Promise<PopulatedTransaction>;
-    input_string(input1: string): Promise<PopulatedTransaction>;
-    input_struct(input1: {
-      uint256_0: BigNumberish;
-      uint256_1: BigNumberish;
-    }): Promise<PopulatedTransaction>;
+    input_address(
+      input1: string,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    input_bool(
+      input1: boolean,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    input_bytes(
+      input1: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    input_bytes1(
+      input1: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    input_enum(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    input_int256(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    input_int8(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    input_stat_array(
+      input1: BigNumberish[],
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    input_string(
+      input1: string,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    input_struct(
+      input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
     input_tuple(
       input1: BigNumberish,
-      input2: BigNumberish
+      input2: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    input_uint256(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    input_uint8(
+      input1: BigNumberish,
+      overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
-    input_uint256(input1: BigNumberish): Promise<PopulatedTransaction>;
-    input_uint8(input1: BigNumberish): Promise<PopulatedTransaction>;
   };
 }
diff --git a/packages/target-ethers-v5-test/types/DataTypesPure.d.ts b/packages/target-ethers-v5-test/types/DataTypesPure.d.ts
index 75fa19bfc..c40b9d313 100644
--- a/packages/target-ethers-v5-test/types/DataTypesPure.d.ts
+++ b/packages/target-ethers-v5-test/types/DataTypesPure.d.ts
@@ -330,36 +330,62 @@ export class DataTypesPure extends Contract {
   filters: {};
 
   estimateGas: {
-    pure_address(): Promise<BigNumber>;
-    pure_bool(): Promise<BigNumber>;
-    pure_bytes(): Promise<BigNumber>;
-    pure_bytes1(): Promise<BigNumber>;
-    pure_enum(): Promise<BigNumber>;
-    pure_int256(): Promise<BigNumber>;
-    pure_int8(): Promise<BigNumber>;
-    pure_named(): Promise<BigNumber>;
-    pure_stat_array(): Promise<BigNumber>;
-    pure_string(): Promise<BigNumber>;
-    pure_struct(): Promise<BigNumber>;
-    pure_tuple(): Promise<BigNumber>;
-    pure_uint256(): Promise<BigNumber>;
-    pure_uint8(): Promise<BigNumber>;
+    pure_address(overrides?: CallOverrides): Promise<BigNumber>;
+
+    pure_bool(overrides?: CallOverrides): Promise<BigNumber>;
+
+    pure_bytes(overrides?: CallOverrides): Promise<BigNumber>;
+
+    pure_bytes1(overrides?: CallOverrides): Promise<BigNumber>;
+
+    pure_enum(overrides?: CallOverrides): Promise<BigNumber>;
+
+    pure_int256(overrides?: CallOverrides): Promise<BigNumber>;
+
+    pure_int8(overrides?: CallOverrides): Promise<BigNumber>;
+
+    pure_named(overrides?: CallOverrides): Promise<BigNumber>;
+
+    pure_stat_array(overrides?: CallOverrides): Promise<BigNumber>;
+
+    pure_string(overrides?: CallOverrides): Promise<BigNumber>;
+
+    pure_struct(overrides?: CallOverrides): Promise<BigNumber>;
+
+    pure_tuple(overrides?: CallOverrides): Promise<BigNumber>;
+
+    pure_uint256(overrides?: CallOverrides): Promise<BigNumber>;
+
+    pure_uint8(overrides?: CallOverrides): Promise<BigNumber>;
   };
 
   populateTransaction: {
-    pure_address(): Promise<PopulatedTransaction>;
-    pure_bool(): Promise<PopulatedTransaction>;
-    pure_bytes(): Promise<PopulatedTransaction>;
-    pure_bytes1(): Promise<PopulatedTransaction>;
-    pure_enum(): Promise<PopulatedTransaction>;
-    pure_int256(): Promise<PopulatedTransaction>;
-    pure_int8(): Promise<PopulatedTransaction>;
-    pure_named(): Promise<PopulatedTransaction>;
-    pure_stat_array(): Promise<PopulatedTransaction>;
-    pure_string(): Promise<PopulatedTransaction>;
-    pure_struct(): Promise<PopulatedTransaction>;
-    pure_tuple(): Promise<PopulatedTransaction>;
-    pure_uint256(): Promise<PopulatedTransaction>;
-    pure_uint8(): Promise<PopulatedTransaction>;
+    pure_address(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    pure_bool(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    pure_bytes(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    pure_bytes1(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    pure_enum(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    pure_int256(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    pure_int8(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    pure_named(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    pure_stat_array(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    pure_string(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    pure_struct(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    pure_tuple(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    pure_uint256(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    pure_uint8(overrides?: CallOverrides): Promise<PopulatedTransaction>;
   };
 }
diff --git a/packages/target-ethers-v5-test/types/DataTypesView.d.ts b/packages/target-ethers-v5-test/types/DataTypesView.d.ts
index f1fbf2cdd..3c72c12eb 100644
--- a/packages/target-ethers-v5-test/types/DataTypesView.d.ts
+++ b/packages/target-ethers-v5-test/types/DataTypesView.d.ts
@@ -330,36 +330,62 @@ export class DataTypesView extends Contract {
   filters: {};
 
   estimateGas: {
-    view_address(): Promise<BigNumber>;
-    view_bool(): Promise<BigNumber>;
-    view_bytes(): Promise<BigNumber>;
-    view_bytes1(): Promise<BigNumber>;
-    view_enum(): Promise<BigNumber>;
-    view_int256(): Promise<BigNumber>;
-    view_int8(): Promise<BigNumber>;
-    view_named(): Promise<BigNumber>;
-    view_stat_array(): Promise<BigNumber>;
-    view_string(): Promise<BigNumber>;
-    view_struct(): Promise<BigNumber>;
-    view_tuple(): Promise<BigNumber>;
-    view_uint256(): Promise<BigNumber>;
-    view_uint8(): Promise<BigNumber>;
+    view_address(overrides?: CallOverrides): Promise<BigNumber>;
+
+    view_bool(overrides?: CallOverrides): Promise<BigNumber>;
+
+    view_bytes(overrides?: CallOverrides): Promise<BigNumber>;
+
+    view_bytes1(overrides?: CallOverrides): Promise<BigNumber>;
+
+    view_enum(overrides?: CallOverrides): Promise<BigNumber>;
+
+    view_int256(overrides?: CallOverrides): Promise<BigNumber>;
+
+    view_int8(overrides?: CallOverrides): Promise<BigNumber>;
+
+    view_named(overrides?: CallOverrides): Promise<BigNumber>;
+
+    view_stat_array(overrides?: CallOverrides): Promise<BigNumber>;
+
+    view_string(overrides?: CallOverrides): Promise<BigNumber>;
+
+    view_struct(overrides?: CallOverrides): Promise<BigNumber>;
+
+    view_tuple(overrides?: CallOverrides): Promise<BigNumber>;
+
+    view_uint256(overrides?: CallOverrides): Promise<BigNumber>;
+
+    view_uint8(overrides?: CallOverrides): Promise<BigNumber>;
   };
 
   populateTransaction: {
-    view_address(): Promise<PopulatedTransaction>;
-    view_bool(): Promise<PopulatedTransaction>;
-    view_bytes(): Promise<PopulatedTransaction>;
-    view_bytes1(): Promise<PopulatedTransaction>;
-    view_enum(): Promise<PopulatedTransaction>;
-    view_int256(): Promise<PopulatedTransaction>;
-    view_int8(): Promise<PopulatedTransaction>;
-    view_named(): Promise<PopulatedTransaction>;
-    view_stat_array(): Promise<PopulatedTransaction>;
-    view_string(): Promise<PopulatedTransaction>;
-    view_struct(): Promise<PopulatedTransaction>;
-    view_tuple(): Promise<PopulatedTransaction>;
-    view_uint256(): Promise<PopulatedTransaction>;
-    view_uint8(): Promise<PopulatedTransaction>;
+    view_address(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    view_bool(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    view_bytes(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    view_bytes1(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    view_enum(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    view_int256(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    view_int8(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    view_named(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    view_stat_array(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    view_string(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    view_struct(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    view_tuple(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    view_uint256(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    view_uint8(overrides?: CallOverrides): Promise<PopulatedTransaction>;
   };
 }
diff --git a/packages/target-ethers-v5-test/types/Events.d.ts b/packages/target-ethers-v5-test/types/Events.d.ts
index 9f1f160c0..a959a2301 100644
--- a/packages/target-ethers-v5-test/types/Events.d.ts
+++ b/packages/target-ethers-v5-test/types/Events.d.ts
@@ -137,18 +137,28 @@ export class Events extends Contract {
   };
 
   estimateGas: {
-    emit_anon1(): Promise<BigNumber>;
-    emit_event1(): Promise<BigNumber>;
-    emit_event2(): Promise<BigNumber>;
-    emit_event3(): Promise<BigNumber>;
-    emit_event3_overloaded(): Promise<BigNumber>;
+    emit_anon1(overrides?: Overrides): Promise<BigNumber>;
+
+    emit_event1(overrides?: Overrides): Promise<BigNumber>;
+
+    emit_event2(overrides?: Overrides): Promise<BigNumber>;
+
+    emit_event3(overrides?: Overrides): Promise<BigNumber>;
+
+    emit_event3_overloaded(overrides?: Overrides): Promise<BigNumber>;
   };
 
   populateTransaction: {
-    emit_anon1(): Promise<PopulatedTransaction>;
-    emit_event1(): Promise<PopulatedTransaction>;
-    emit_event2(): Promise<PopulatedTransaction>;
-    emit_event3(): Promise<PopulatedTransaction>;
-    emit_event3_overloaded(): Promise<PopulatedTransaction>;
+    emit_anon1(overrides?: Overrides): Promise<PopulatedTransaction>;
+
+    emit_event1(overrides?: Overrides): Promise<PopulatedTransaction>;
+
+    emit_event2(overrides?: Overrides): Promise<PopulatedTransaction>;
+
+    emit_event3(overrides?: Overrides): Promise<PopulatedTransaction>;
+
+    emit_event3_overloaded(
+      overrides?: Overrides
+    ): Promise<PopulatedTransaction>;
   };
 }
diff --git a/packages/target-ethers-v5-test/types/NameMangling.d.ts b/packages/target-ethers-v5-test/types/NameMangling.d.ts
index b14c53184..003f60f06 100644
--- a/packages/target-ethers-v5-test/types/NameMangling.d.ts
+++ b/packages/target-ethers-v5-test/types/NameMangling.d.ts
@@ -60,10 +60,10 @@ export class NameMangling extends Contract {
   filters: {};
 
   estimateGas: {
-    works(): Promise<BigNumber>;
+    works(overrides?: CallOverrides): Promise<BigNumber>;
   };
 
   populateTransaction: {
-    works(): Promise<PopulatedTransaction>;
+    works(overrides?: CallOverrides): Promise<PopulatedTransaction>;
   };
 }
diff --git a/packages/target-ethers-v5-test/types/Overloads.d.ts b/packages/target-ethers-v5-test/types/Overloads.d.ts
index 011146244..ad3e8a940 100644
--- a/packages/target-ethers-v5-test/types/Overloads.d.ts
+++ b/packages/target-ethers-v5-test/types/Overloads.d.ts
@@ -90,10 +90,28 @@ export class Overloads extends Contract {
   filters: {};
 
   estimateGas: {
-    overload1(input1: BigNumberish): Promise<BigNumber>;
+    "overload1(int256)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    "overload1(uint256,uint256)"(
+      input1: BigNumberish,
+      input2: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
   };
 
   populateTransaction: {
-    overload1(input1: BigNumberish): Promise<PopulatedTransaction>;
+    "overload1(int256)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    "overload1(uint256,uint256)"(
+      input1: BigNumberish,
+      input2: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
   };
 }
diff --git a/packages/target-ethers-v5-test/types/Payable.d.ts b/packages/target-ethers-v5-test/types/Payable.d.ts
index 99b9fc370..8a36dc317 100644
--- a/packages/target-ethers-v5-test/types/Payable.d.ts
+++ b/packages/target-ethers-v5-test/types/Payable.d.ts
@@ -78,12 +78,14 @@ export class Payable extends Contract {
   filters: {};
 
   estimateGas: {
-    non_payable_func(): Promise<BigNumber>;
-    payable_func(): Promise<BigNumber>;
+    non_payable_func(overrides?: Overrides): Promise<BigNumber>;
+
+    payable_func(overrides?: PayableOverrides): Promise<BigNumber>;
   };
 
   populateTransaction: {
-    non_payable_func(): Promise<PopulatedTransaction>;
-    payable_func(): Promise<PopulatedTransaction>;
+    non_payable_func(overrides?: Overrides): Promise<PopulatedTransaction>;
+
+    payable_func(overrides?: PayableOverrides): Promise<PopulatedTransaction>;
   };
 }
diff --git a/packages/target-ethers-v5/src/codegen/functions.ts b/packages/target-ethers-v5/src/codegen/functions.ts
index 8fb00d51b..8ea677260 100644
--- a/packages/target-ethers-v5/src/codegen/functions.ts
+++ b/packages/target-ethers-v5/src/codegen/functions.ts
@@ -4,6 +4,7 @@ import { generateInputTypes, generateOutputTypes } from './types'
 interface GenerateFunctionOptions {
   returnResultObject?: boolean
   isStaticCall?: boolean
+  overrideOutput?: string
 }
 
 export function codegenFunctions(options: GenerateFunctionOptions, fns: FunctionDeclaration[]): string {
@@ -29,11 +30,15 @@ function generateFunction(options: GenerateFunctionOptions, fn: FunctionDeclarat
     !isConstant(fn) && !isConstantFn(fn)
       ? `overrides?: ${isPayable(fn) ? 'PayableOverrides' : 'Overrides'}`
       : 'overrides?: CallOverrides'
-  }): Promise<${
-    options.isStaticCall || fn.stateMutability === 'pure' || fn.stateMutability === 'view'
-      ? generateOutputTypes(!!options.returnResultObject, fn.outputs)
-      : 'ContractTransaction'
-  }>;
+  }): ${
+    options.overrideOutput
+      ? options.overrideOutput
+      : `Promise<${
+          options.isStaticCall || fn.stateMutability === 'pure' || fn.stateMutability === 'view'
+            ? generateOutputTypes(!!options.returnResultObject, fn.outputs)
+            : 'ContractTransaction'
+        }>`
+  };
 `
 }
 
diff --git a/packages/target-ethers-v5/src/codegen/index.ts b/packages/target-ethers-v5/src/codegen/index.ts
index d338405eb..06c84fbde 100644
--- a/packages/target-ethers-v5/src/codegen/index.ts
+++ b/packages/target-ethers-v5/src/codegen/index.ts
@@ -38,7 +38,7 @@ export function codegenContractTypings(contract: Contract) {
       .map((v) => v[0])
       .map(generateEncodeFunctionDataOverload)
       .join('\n')}
-    
+
     ${values(contract.functions)
       .map((v) => v[0])
       .map(generateDecodeFunctionResultOverload)
@@ -93,15 +93,13 @@ export function codegenContractTypings(contract: Contract) {
 
     estimateGas: {
       ${values(contract.functions)
-        .map((v) => v[0])
-        .map(generateEstimateFunction)
+        .map(codegenFunctions.bind(null, { overrideOutput: 'Promise<BigNumber>' }))
         .join('\n')}
     };
 
     populateTransaction: {
       ${values(contract.functions)
-        .map((v) => v[0])
-        .map(generatePopulateTransactionFunction)
+        .map(codegenFunctions.bind(null, { overrideOutput: 'Promise<PopulatedTransaction>' }))
         .join('\n')}
     };
   }`
@@ -227,14 +225,6 @@ function generateLibraryAddressesInterface(contract: Contract, bytecode: Bytecod
   };`
 }
 
-function generateEstimateFunction(fn: FunctionDeclaration): string {
-  return `${fn.name}(${generateInputTypes(fn.inputs)}): Promise<BigNumber>;`
-}
-
-function generatePopulateTransactionFunction(fn: FunctionDeclaration): string {
-  return `${fn.name}(${generateInputTypes(fn.inputs)}): Promise<PopulatedTransaction>;`
-}
-
 function generateInterfaceFunctionDescription(fn: FunctionDeclaration): string {
   return `'${generateFunctionSignature(fn)}': FunctionFragment;`
 }

From 5111fd34f442a34203c1c73312824c430e200377 Mon Sep 17 00:00:00 2001
From: Braden Napier <brady.napier@dashos.net>
Date: Thu, 9 Jul 2020 03:31:07 -0400
Subject: [PATCH 45/64] fix: overloads to work according to spec

---
 .../test/DataTypesInput.test.ts               |   5 +
 .../test/Overload.test.ts                     |  16 +-
 .../types/DataTypesInput.d.ts                 |  80 ++++++
 .../types/DataTypesPure.d.ts                  |  82 ++++++
 .../types/DataTypesView.d.ts                  |  82 ++++++
 .../target-ethers-v4-test/types/Events.d.ts   |  40 +++
 .../types/NameMangling.d.ts                   |   4 +
 .../types/Overloads.d.ts                      |   4 +
 .../target-ethers-v4-test/types/Payable.d.ts  |  16 ++
 .../target-ethers-v4/src/codegen/functions.ts |   4 +-
 .../test/DataTypesInput.test.ts               |   5 +
 .../test/Overload.test.ts                     |   8 +-
 .../types/DataTypesInput.d.ts                 | 246 ++++++++++++++++++
 .../types/DataTypesPure.d.ts                  | 187 +++++++++++++
 .../types/DataTypesView.d.ts                  | 187 +++++++++++++
 .../target-ethers-v5-test/types/Events.d.ts   |  34 +++
 .../types/NameMangling.d.ts                   |  10 +
 .../target-ethers-v5-test/types/Payable.d.ts  |  14 +
 .../target-ethers-v5/src/codegen/functions.ts |   2 +-
 19 files changed, 1015 insertions(+), 11 deletions(-)

diff --git a/packages/target-ethers-v4-test/test/DataTypesInput.test.ts b/packages/target-ethers-v4-test/test/DataTypesInput.test.ts
index e090cb78f..ce9572c55 100644
--- a/packages/target-ethers-v4-test/test/DataTypesInput.test.ts
+++ b/packages/target-ethers-v4-test/test/DataTypesInput.test.ts
@@ -35,6 +35,11 @@ describe('DataTypesInput', () => {
       '0x70b144972C5Ef6CB941A5379240B74239c418CD4',
     )
 
+    typedAssert(
+      await contract['input_address(address)']('0x70b144972C5Ef6CB941A5379240B74239c418CD4'),
+      '0x70b144972C5Ef6CB941A5379240B74239c418CD4',
+    )
+
     typedAssert(await contract.input_bytes1('0xaa'), '0xaa')
     typedAssert(await contract.input_bytes1([0]), '0x00')
 
diff --git a/packages/target-ethers-v4-test/test/Overload.test.ts b/packages/target-ethers-v4-test/test/Overload.test.ts
index 505138867..490f9fdfb 100644
--- a/packages/target-ethers-v4-test/test/Overload.test.ts
+++ b/packages/target-ethers-v4-test/test/Overload.test.ts
@@ -16,12 +16,20 @@ describe('Overloads', () => {
   afterEach(() => ganache.close())
 
   it('works with 1st overload', async () => {
-    const result = await contract.functions['overload1(int256)'](1)
-    typedAssert(result, new BigNumber(1))
+    const results = await Promise.all([
+      contract['overload1(int256)'](1),
+      contract.functions['overload1(int256)'](1),
+      contract.functions.overload1(1),
+      contract.overload1(1),
+    ])
+    results.forEach((result) => typedAssert(result, new BigNumber(1)))
   })
 
   it('works with 2n overload', async () => {
-    const result = await contract.functions['overload1(uint256,uint256)'](1, 2)
-    typedAssert(result, new BigNumber(3))
+    const results = await Promise.all([
+      contract.functions['overload1(uint256,uint256)'](1, 2),
+      contract['overload1(uint256,uint256)'](1, 2),
+    ])
+    results.forEach((result) => typedAssert(result, new BigNumber(3)))
   })
 })
diff --git a/packages/target-ethers-v4-test/types/DataTypesInput.d.ts b/packages/target-ethers-v4-test/types/DataTypesInput.d.ts
index 6ab731907..3727ced6c 100644
--- a/packages/target-ethers-v4-test/types/DataTypesInput.d.ts
+++ b/packages/target-ethers-v4-test/types/DataTypesInput.d.ts
@@ -89,22 +89,40 @@ export class DataTypesInput extends Contract {
   functions: {
     input_address(input1: string): Promise<string>;
 
+    "input_address(address)"(input1: string): Promise<string>;
+
     input_bool(input1: boolean): Promise<boolean>;
 
+    "input_bool(bool)"(input1: boolean): Promise<boolean>;
+
     input_bytes(input1: Arrayish): Promise<string>;
 
+    "input_bytes(bytes)"(input1: Arrayish): Promise<string>;
+
     input_bytes1(input1: Arrayish): Promise<string>;
 
+    "input_bytes1(bytes1)"(input1: Arrayish): Promise<string>;
+
     input_enum(input1: BigNumberish): Promise<number>;
 
+    "input_enum(uint8)"(input1: BigNumberish): Promise<number>;
+
     input_int256(input1: BigNumberish): Promise<BigNumber>;
 
+    "input_int256(int256)"(input1: BigNumberish): Promise<BigNumber>;
+
     input_int8(input1: BigNumberish): Promise<number>;
 
+    "input_int8(int8)"(input1: BigNumberish): Promise<number>;
+
     input_stat_array(input1: BigNumberish[]): Promise<number[]>;
 
+    "input_stat_array(uint8[3])"(input1: BigNumberish[]): Promise<number[]>;
+
     input_string(input1: string): Promise<string>;
 
+    "input_string(string)"(input1: string): Promise<string>;
+
     input_struct(input1: {
       uint256_0: BigNumberish;
       uint256_1: BigNumberish;
@@ -115,6 +133,16 @@ export class DataTypesInput extends Contract {
       1: BigNumber;
     }>;
 
+    "input_struct(tuple)"(input1: {
+      uint256_0: BigNumberish;
+      uint256_1: BigNumberish;
+    }): Promise<{
+      uint256_0: BigNumber;
+      uint256_1: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
     input_tuple(
       input1: BigNumberish,
       input2: BigNumberish
@@ -123,29 +151,59 @@ export class DataTypesInput extends Contract {
       1: BigNumber;
     }>;
 
+    "input_tuple(uint256,uint256)"(
+      input1: BigNumberish,
+      input2: BigNumberish
+    ): Promise<{
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
     input_uint256(input1: BigNumberish): Promise<BigNumber>;
 
+    "input_uint256(uint256)"(input1: BigNumberish): Promise<BigNumber>;
+
     input_uint8(input1: BigNumberish): Promise<number>;
+
+    "input_uint8(uint8)"(input1: BigNumberish): Promise<number>;
   };
 
   input_address(input1: string): Promise<string>;
 
+  "input_address(address)"(input1: string): Promise<string>;
+
   input_bool(input1: boolean): Promise<boolean>;
 
+  "input_bool(bool)"(input1: boolean): Promise<boolean>;
+
   input_bytes(input1: Arrayish): Promise<string>;
 
+  "input_bytes(bytes)"(input1: Arrayish): Promise<string>;
+
   input_bytes1(input1: Arrayish): Promise<string>;
 
+  "input_bytes1(bytes1)"(input1: Arrayish): Promise<string>;
+
   input_enum(input1: BigNumberish): Promise<number>;
 
+  "input_enum(uint8)"(input1: BigNumberish): Promise<number>;
+
   input_int256(input1: BigNumberish): Promise<BigNumber>;
 
+  "input_int256(int256)"(input1: BigNumberish): Promise<BigNumber>;
+
   input_int8(input1: BigNumberish): Promise<number>;
 
+  "input_int8(int8)"(input1: BigNumberish): Promise<number>;
+
   input_stat_array(input1: BigNumberish[]): Promise<number[]>;
 
+  "input_stat_array(uint8[3])"(input1: BigNumberish[]): Promise<number[]>;
+
   input_string(input1: string): Promise<string>;
 
+  "input_string(string)"(input1: string): Promise<string>;
+
   input_struct(input1: {
     uint256_0: BigNumberish;
     uint256_1: BigNumberish;
@@ -156,6 +214,16 @@ export class DataTypesInput extends Contract {
     1: BigNumber;
   }>;
 
+  "input_struct(tuple)"(input1: {
+    uint256_0: BigNumberish;
+    uint256_1: BigNumberish;
+  }): Promise<{
+    uint256_0: BigNumber;
+    uint256_1: BigNumber;
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
   input_tuple(
     input1: BigNumberish,
     input2: BigNumberish
@@ -164,10 +232,22 @@ export class DataTypesInput extends Contract {
     1: BigNumber;
   }>;
 
+  "input_tuple(uint256,uint256)"(
+    input1: BigNumberish,
+    input2: BigNumberish
+  ): Promise<{
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
   input_uint256(input1: BigNumberish): Promise<BigNumber>;
 
+  "input_uint256(uint256)"(input1: BigNumberish): Promise<BigNumber>;
+
   input_uint8(input1: BigNumberish): Promise<number>;
 
+  "input_uint8(uint8)"(input1: BigNumberish): Promise<number>;
+
   filters: {};
 
   estimate: {
diff --git a/packages/target-ethers-v4-test/types/DataTypesPure.d.ts b/packages/target-ethers-v4-test/types/DataTypesPure.d.ts
index 6e81fa219..ee7811fe9 100644
--- a/packages/target-ethers-v4-test/types/DataTypesPure.d.ts
+++ b/packages/target-ethers-v4-test/types/DataTypesPure.d.ts
@@ -63,18 +63,32 @@ export class DataTypesPure extends Contract {
   functions: {
     pure_address(): Promise<string>;
 
+    "pure_address()"(): Promise<string>;
+
     pure_bool(): Promise<boolean>;
 
+    "pure_bool()"(): Promise<boolean>;
+
     pure_bytes(): Promise<string>;
 
+    "pure_bytes()"(): Promise<string>;
+
     pure_bytes1(): Promise<string>;
 
+    "pure_bytes1()"(): Promise<string>;
+
     pure_enum(): Promise<number>;
 
+    "pure_enum()"(): Promise<number>;
+
     pure_int256(): Promise<BigNumber>;
 
+    "pure_int256()"(): Promise<BigNumber>;
+
     pure_int8(): Promise<number>;
 
+    "pure_int8()"(): Promise<number>;
+
     pure_named(): Promise<{
       uint256_1: BigNumber;
       uint256_2: BigNumber;
@@ -82,10 +96,21 @@ export class DataTypesPure extends Contract {
       1: BigNumber;
     }>;
 
+    "pure_named()"(): Promise<{
+      uint256_1: BigNumber;
+      uint256_2: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
     pure_stat_array(): Promise<number[]>;
 
+    "pure_stat_array()"(): Promise<number[]>;
+
     pure_string(): Promise<string>;
 
+    "pure_string()"(): Promise<string>;
+
     pure_struct(): Promise<{
       uint256_0: BigNumber;
       uint256_1: BigNumber;
@@ -93,30 +118,60 @@ export class DataTypesPure extends Contract {
       1: BigNumber;
     }>;
 
+    "pure_struct()"(): Promise<{
+      uint256_0: BigNumber;
+      uint256_1: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
     pure_tuple(): Promise<{
       0: BigNumber;
       1: BigNumber;
     }>;
 
+    "pure_tuple()"(): Promise<{
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
     pure_uint256(): Promise<BigNumber>;
 
+    "pure_uint256()"(): Promise<BigNumber>;
+
     pure_uint8(): Promise<number>;
+
+    "pure_uint8()"(): Promise<number>;
   };
 
   pure_address(): Promise<string>;
 
+  "pure_address()"(): Promise<string>;
+
   pure_bool(): Promise<boolean>;
 
+  "pure_bool()"(): Promise<boolean>;
+
   pure_bytes(): Promise<string>;
 
+  "pure_bytes()"(): Promise<string>;
+
   pure_bytes1(): Promise<string>;
 
+  "pure_bytes1()"(): Promise<string>;
+
   pure_enum(): Promise<number>;
 
+  "pure_enum()"(): Promise<number>;
+
   pure_int256(): Promise<BigNumber>;
 
+  "pure_int256()"(): Promise<BigNumber>;
+
   pure_int8(): Promise<number>;
 
+  "pure_int8()"(): Promise<number>;
+
   pure_named(): Promise<{
     uint256_1: BigNumber;
     uint256_2: BigNumber;
@@ -124,10 +179,21 @@ export class DataTypesPure extends Contract {
     1: BigNumber;
   }>;
 
+  "pure_named()"(): Promise<{
+    uint256_1: BigNumber;
+    uint256_2: BigNumber;
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
   pure_stat_array(): Promise<number[]>;
 
+  "pure_stat_array()"(): Promise<number[]>;
+
   pure_string(): Promise<string>;
 
+  "pure_string()"(): Promise<string>;
+
   pure_struct(): Promise<{
     uint256_0: BigNumber;
     uint256_1: BigNumber;
@@ -135,15 +201,31 @@ export class DataTypesPure extends Contract {
     1: BigNumber;
   }>;
 
+  "pure_struct()"(): Promise<{
+    uint256_0: BigNumber;
+    uint256_1: BigNumber;
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
   pure_tuple(): Promise<{
     0: BigNumber;
     1: BigNumber;
   }>;
 
+  "pure_tuple()"(): Promise<{
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
   pure_uint256(): Promise<BigNumber>;
 
+  "pure_uint256()"(): Promise<BigNumber>;
+
   pure_uint8(): Promise<number>;
 
+  "pure_uint8()"(): Promise<number>;
+
   filters: {};
 
   estimate: {
diff --git a/packages/target-ethers-v4-test/types/DataTypesView.d.ts b/packages/target-ethers-v4-test/types/DataTypesView.d.ts
index d489c6ba3..ab6d6a715 100644
--- a/packages/target-ethers-v4-test/types/DataTypesView.d.ts
+++ b/packages/target-ethers-v4-test/types/DataTypesView.d.ts
@@ -63,18 +63,32 @@ export class DataTypesView extends Contract {
   functions: {
     view_address(): Promise<string>;
 
+    "view_address()"(): Promise<string>;
+
     view_bool(): Promise<boolean>;
 
+    "view_bool()"(): Promise<boolean>;
+
     view_bytes(): Promise<string>;
 
+    "view_bytes()"(): Promise<string>;
+
     view_bytes1(): Promise<string>;
 
+    "view_bytes1()"(): Promise<string>;
+
     view_enum(): Promise<number>;
 
+    "view_enum()"(): Promise<number>;
+
     view_int256(): Promise<BigNumber>;
 
+    "view_int256()"(): Promise<BigNumber>;
+
     view_int8(): Promise<number>;
 
+    "view_int8()"(): Promise<number>;
+
     view_named(): Promise<{
       uint256_1: BigNumber;
       uint256_2: BigNumber;
@@ -82,10 +96,21 @@ export class DataTypesView extends Contract {
       1: BigNumber;
     }>;
 
+    "view_named()"(): Promise<{
+      uint256_1: BigNumber;
+      uint256_2: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
     view_stat_array(): Promise<number[]>;
 
+    "view_stat_array()"(): Promise<number[]>;
+
     view_string(): Promise<string>;
 
+    "view_string()"(): Promise<string>;
+
     view_struct(): Promise<{
       uint256_0: BigNumber;
       uint256_1: BigNumber;
@@ -93,30 +118,60 @@ export class DataTypesView extends Contract {
       1: BigNumber;
     }>;
 
+    "view_struct()"(): Promise<{
+      uint256_0: BigNumber;
+      uint256_1: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
     view_tuple(): Promise<{
       0: BigNumber;
       1: BigNumber;
     }>;
 
+    "view_tuple()"(): Promise<{
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
     view_uint256(): Promise<BigNumber>;
 
+    "view_uint256()"(): Promise<BigNumber>;
+
     view_uint8(): Promise<number>;
+
+    "view_uint8()"(): Promise<number>;
   };
 
   view_address(): Promise<string>;
 
+  "view_address()"(): Promise<string>;
+
   view_bool(): Promise<boolean>;
 
+  "view_bool()"(): Promise<boolean>;
+
   view_bytes(): Promise<string>;
 
+  "view_bytes()"(): Promise<string>;
+
   view_bytes1(): Promise<string>;
 
+  "view_bytes1()"(): Promise<string>;
+
   view_enum(): Promise<number>;
 
+  "view_enum()"(): Promise<number>;
+
   view_int256(): Promise<BigNumber>;
 
+  "view_int256()"(): Promise<BigNumber>;
+
   view_int8(): Promise<number>;
 
+  "view_int8()"(): Promise<number>;
+
   view_named(): Promise<{
     uint256_1: BigNumber;
     uint256_2: BigNumber;
@@ -124,10 +179,21 @@ export class DataTypesView extends Contract {
     1: BigNumber;
   }>;
 
+  "view_named()"(): Promise<{
+    uint256_1: BigNumber;
+    uint256_2: BigNumber;
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
   view_stat_array(): Promise<number[]>;
 
+  "view_stat_array()"(): Promise<number[]>;
+
   view_string(): Promise<string>;
 
+  "view_string()"(): Promise<string>;
+
   view_struct(): Promise<{
     uint256_0: BigNumber;
     uint256_1: BigNumber;
@@ -135,15 +201,31 @@ export class DataTypesView extends Contract {
     1: BigNumber;
   }>;
 
+  "view_struct()"(): Promise<{
+    uint256_0: BigNumber;
+    uint256_1: BigNumber;
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
   view_tuple(): Promise<{
     0: BigNumber;
     1: BigNumber;
   }>;
 
+  "view_tuple()"(): Promise<{
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
   view_uint256(): Promise<BigNumber>;
 
+  "view_uint256()"(): Promise<BigNumber>;
+
   view_uint8(): Promise<number>;
 
+  "view_uint8()"(): Promise<number>;
+
   filters: {};
 
   estimate: {
diff --git a/packages/target-ethers-v4-test/types/Events.d.ts b/packages/target-ethers-v4-test/types/Events.d.ts
index 21dd4fd1c..a77a235e3 100644
--- a/packages/target-ethers-v4-test/types/Events.d.ts
+++ b/packages/target-ethers-v4-test/types/Events.d.ts
@@ -58,29 +58,69 @@ export class Events extends Contract {
   functions: {
     emit_anon1(overrides?: TransactionOverrides): Promise<ContractTransaction>;
 
+    "emit_anon1()"(
+      overrides?: TransactionOverrides
+    ): Promise<ContractTransaction>;
+
     emit_event1(overrides?: TransactionOverrides): Promise<ContractTransaction>;
 
+    "emit_event1()"(
+      overrides?: TransactionOverrides
+    ): Promise<ContractTransaction>;
+
     emit_event2(overrides?: TransactionOverrides): Promise<ContractTransaction>;
 
+    "emit_event2()"(
+      overrides?: TransactionOverrides
+    ): Promise<ContractTransaction>;
+
     emit_event3(overrides?: TransactionOverrides): Promise<ContractTransaction>;
 
+    "emit_event3()"(
+      overrides?: TransactionOverrides
+    ): Promise<ContractTransaction>;
+
     emit_event3_overloaded(
       overrides?: TransactionOverrides
     ): Promise<ContractTransaction>;
+
+    "emit_event3_overloaded()"(
+      overrides?: TransactionOverrides
+    ): Promise<ContractTransaction>;
   };
 
   emit_anon1(overrides?: TransactionOverrides): Promise<ContractTransaction>;
 
+  "emit_anon1()"(
+    overrides?: TransactionOverrides
+  ): Promise<ContractTransaction>;
+
   emit_event1(overrides?: TransactionOverrides): Promise<ContractTransaction>;
 
+  "emit_event1()"(
+    overrides?: TransactionOverrides
+  ): Promise<ContractTransaction>;
+
   emit_event2(overrides?: TransactionOverrides): Promise<ContractTransaction>;
 
+  "emit_event2()"(
+    overrides?: TransactionOverrides
+  ): Promise<ContractTransaction>;
+
   emit_event3(overrides?: TransactionOverrides): Promise<ContractTransaction>;
 
+  "emit_event3()"(
+    overrides?: TransactionOverrides
+  ): Promise<ContractTransaction>;
+
   emit_event3_overloaded(
     overrides?: TransactionOverrides
   ): Promise<ContractTransaction>;
 
+  "emit_event3_overloaded()"(
+    overrides?: TransactionOverrides
+  ): Promise<ContractTransaction>;
+
   filters: {
     AnonEvent1(value1: BigNumberish | null): EventFilter;
 
diff --git a/packages/target-ethers-v4-test/types/NameMangling.d.ts b/packages/target-ethers-v4-test/types/NameMangling.d.ts
index 5edbd9e8e..93f01fced 100644
--- a/packages/target-ethers-v4-test/types/NameMangling.d.ts
+++ b/packages/target-ethers-v4-test/types/NameMangling.d.ts
@@ -36,10 +36,14 @@ export class NameMangling extends Contract {
 
   functions: {
     works(): Promise<boolean>;
+
+    "works()"(): Promise<boolean>;
   };
 
   works(): Promise<boolean>;
 
+  "works()"(): Promise<boolean>;
+
   filters: {};
 
   estimate: {
diff --git a/packages/target-ethers-v4-test/types/Overloads.d.ts b/packages/target-ethers-v4-test/types/Overloads.d.ts
index 73ed4f205..b0aed4f4f 100644
--- a/packages/target-ethers-v4-test/types/Overloads.d.ts
+++ b/packages/target-ethers-v4-test/types/Overloads.d.ts
@@ -34,6 +34,8 @@ export class Overloads extends Contract {
   interface: OverloadsInterface;
 
   functions: {
+    overload1(input1: BigNumberish): Promise<BigNumber>;
+
     "overload1(int256)"(input1: BigNumberish): Promise<BigNumber>;
 
     "overload1(uint256,uint256)"(
@@ -42,6 +44,8 @@ export class Overloads extends Contract {
     ): Promise<BigNumber>;
   };
 
+  overload1(input1: BigNumberish): Promise<BigNumber>;
+
   "overload1(int256)"(input1: BigNumberish): Promise<BigNumber>;
 
   "overload1(uint256,uint256)"(
diff --git a/packages/target-ethers-v4-test/types/Payable.d.ts b/packages/target-ethers-v4-test/types/Payable.d.ts
index c36e141ef..edaddc918 100644
--- a/packages/target-ethers-v4-test/types/Payable.d.ts
+++ b/packages/target-ethers-v4-test/types/Payable.d.ts
@@ -38,17 +38,33 @@ export class Payable extends Contract {
       overrides?: TransactionOverrides
     ): Promise<ContractTransaction>;
 
+    "non_payable_func()"(
+      overrides?: TransactionOverrides
+    ): Promise<ContractTransaction>;
+
     payable_func(
       overrides?: TransactionOverrides
     ): Promise<ContractTransaction>;
+
+    "payable_func()"(
+      overrides?: TransactionOverrides
+    ): Promise<ContractTransaction>;
   };
 
   non_payable_func(
     overrides?: TransactionOverrides
   ): Promise<ContractTransaction>;
 
+  "non_payable_func()"(
+    overrides?: TransactionOverrides
+  ): Promise<ContractTransaction>;
+
   payable_func(overrides?: TransactionOverrides): Promise<ContractTransaction>;
 
+  "payable_func()"(
+    overrides?: TransactionOverrides
+  ): Promise<ContractTransaction>;
+
   filters: {};
 
   estimate: {
diff --git a/packages/target-ethers-v4/src/codegen/functions.ts b/packages/target-ethers-v4/src/codegen/functions.ts
index 83ca54360..1cc47a662 100644
--- a/packages/target-ethers-v4/src/codegen/functions.ts
+++ b/packages/target-ethers-v4/src/codegen/functions.ts
@@ -3,10 +3,10 @@ import { generateInputTypes, generateOutputTypes } from './types'
 
 export function codegenFunctions(fns: FunctionDeclaration[]): string {
   if (fns.length === 1) {
-    return generateFunction(fns[0])
+    return `${generateFunction(fns[0])}${codegenForOverloadedFunctions(fns)}`
   }
 
-  return codegenForOverloadedFunctions(fns)
+  return `${generateFunction(fns[0])}${codegenForOverloadedFunctions(fns)}`
 }
 
 export function codegenForOverloadedFunctions(fns: FunctionDeclaration[]): string {
diff --git a/packages/target-ethers-v5-test/test/DataTypesInput.test.ts b/packages/target-ethers-v5-test/test/DataTypesInput.test.ts
index 3be442d0b..c1fac58f3 100644
--- a/packages/target-ethers-v5-test/test/DataTypesInput.test.ts
+++ b/packages/target-ethers-v5-test/test/DataTypesInput.test.ts
@@ -35,6 +35,11 @@ describe('DataTypesInput', () => {
       '0x70b144972C5Ef6CB941A5379240B74239c418CD4',
     )
 
+    typedAssert(
+      await contract['input_address(address)']('0x70b144972C5Ef6CB941A5379240B74239c418CD4'),
+      '0x70b144972C5Ef6CB941A5379240B74239c418CD4',
+    )
+
     typedAssert(await contract.input_bytes1('0xaa'), '0xaa')
     typedAssert(await contract.input_bytes1([0]), '0x00')
 
diff --git a/packages/target-ethers-v5-test/test/Overload.test.ts b/packages/target-ethers-v5-test/test/Overload.test.ts
index 940aea13b..c98919108 100644
--- a/packages/target-ethers-v5-test/test/Overload.test.ts
+++ b/packages/target-ethers-v5-test/test/Overload.test.ts
@@ -16,12 +16,12 @@ describe('Overloads', () => {
   afterEach(() => ganache.close())
 
   it('works with 1st overload', async () => {
-    const result = await contract['overload1(int256)'](1)
-    typedAssert(result, BigNumber.from(1))
+    typedAssert(await contract['overload1(int256)'](1), BigNumber.from(1))
+    typedAssert(await contract.functions['overload1(int256)'](1), { 0: BigNumber.from(1) })
   })
 
   it('works with 2n overload', async () => {
-    const result = await contract['overload1(uint256,uint256)'](1, 2)
-    typedAssert(result, BigNumber.from(3))
+    typedAssert(await contract['overload1(uint256,uint256)'](1, 2), BigNumber.from(3))
+    typedAssert(await contract.functions['overload1(uint256,uint256)'](1, 2), { 0: BigNumber.from(3) })
   })
 })
diff --git a/packages/target-ethers-v5-test/types/DataTypesInput.d.ts b/packages/target-ethers-v5-test/types/DataTypesInput.d.ts
index e634d07c8..c6d3016f7 100644
--- a/packages/target-ethers-v5-test/types/DataTypesInput.d.ts
+++ b/packages/target-ethers-v5-test/types/DataTypesInput.d.ts
@@ -153,6 +153,13 @@ export class DataTypesInput extends Contract {
       0: string;
     }>;
 
+    "input_address(address)"(
+      input1: string,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
+
     input_bool(
       input1: boolean,
       overrides?: CallOverrides
@@ -160,6 +167,13 @@ export class DataTypesInput extends Contract {
       0: boolean;
     }>;
 
+    "input_bool(bool)"(
+      input1: boolean,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: boolean;
+    }>;
+
     input_bytes(
       input1: BytesLike,
       overrides?: CallOverrides
@@ -167,6 +181,13 @@ export class DataTypesInput extends Contract {
       0: string;
     }>;
 
+    "input_bytes(bytes)"(
+      input1: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
+
     input_bytes1(
       input1: BytesLike,
       overrides?: CallOverrides
@@ -174,6 +195,13 @@ export class DataTypesInput extends Contract {
       0: string;
     }>;
 
+    "input_bytes1(bytes1)"(
+      input1: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
+
     input_enum(
       input1: BigNumberish,
       overrides?: CallOverrides
@@ -181,6 +209,13 @@ export class DataTypesInput extends Contract {
       0: number;
     }>;
 
+    "input_enum(uint8)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number;
+    }>;
+
     input_int256(
       input1: BigNumberish,
       overrides?: CallOverrides
@@ -188,6 +223,13 @@ export class DataTypesInput extends Contract {
       0: BigNumber;
     }>;
 
+    "input_int256(int256)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+    }>;
+
     input_int8(
       input1: BigNumberish,
       overrides?: CallOverrides
@@ -195,6 +237,13 @@ export class DataTypesInput extends Contract {
       0: number;
     }>;
 
+    "input_int8(int8)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number;
+    }>;
+
     input_stat_array(
       input1: BigNumberish[],
       overrides?: CallOverrides
@@ -202,6 +251,13 @@ export class DataTypesInput extends Contract {
       0: number[];
     }>;
 
+    "input_stat_array(uint8[3])"(
+      input1: BigNumberish[],
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number[];
+    }>;
+
     input_string(
       input1: string,
       overrides?: CallOverrides
@@ -209,6 +265,13 @@ export class DataTypesInput extends Contract {
       0: string;
     }>;
 
+    "input_string(string)"(
+      input1: string,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
+
     input_struct(
       input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
       overrides?: CallOverrides
@@ -221,6 +284,18 @@ export class DataTypesInput extends Contract {
       };
     }>;
 
+    "input_struct(tuple)"(
+      input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
+      overrides?: CallOverrides
+    ): Promise<{
+      0: {
+        uint256_0: BigNumber;
+        uint256_1: BigNumber;
+        0: BigNumber;
+        1: BigNumber;
+      };
+    }>;
+
     input_tuple(
       input1: BigNumberish,
       input2: BigNumberish,
@@ -230,6 +305,15 @@ export class DataTypesInput extends Contract {
       1: BigNumber;
     }>;
 
+    "input_tuple(uint256,uint256)"(
+      input1: BigNumberish,
+      input2: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
     input_uint256(
       input1: BigNumberish,
       overrides?: CallOverrides
@@ -237,38 +321,97 @@ export class DataTypesInput extends Contract {
       0: BigNumber;
     }>;
 
+    "input_uint256(uint256)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+    }>;
+
     input_uint8(
       input1: BigNumberish,
       overrides?: CallOverrides
     ): Promise<{
       0: number;
     }>;
+
+    "input_uint8(uint8)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number;
+    }>;
   };
 
   input_address(input1: string, overrides?: CallOverrides): Promise<string>;
 
+  "input_address(address)"(
+    input1: string,
+    overrides?: CallOverrides
+  ): Promise<string>;
+
   input_bool(input1: boolean, overrides?: CallOverrides): Promise<boolean>;
 
+  "input_bool(bool)"(
+    input1: boolean,
+    overrides?: CallOverrides
+  ): Promise<boolean>;
+
   input_bytes(input1: BytesLike, overrides?: CallOverrides): Promise<string>;
 
+  "input_bytes(bytes)"(
+    input1: BytesLike,
+    overrides?: CallOverrides
+  ): Promise<string>;
+
   input_bytes1(input1: BytesLike, overrides?: CallOverrides): Promise<string>;
 
+  "input_bytes1(bytes1)"(
+    input1: BytesLike,
+    overrides?: CallOverrides
+  ): Promise<string>;
+
   input_enum(input1: BigNumberish, overrides?: CallOverrides): Promise<number>;
 
+  "input_enum(uint8)"(
+    input1: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<number>;
+
   input_int256(
     input1: BigNumberish,
     overrides?: CallOverrides
   ): Promise<BigNumber>;
 
+  "input_int256(int256)"(
+    input1: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
   input_int8(input1: BigNumberish, overrides?: CallOverrides): Promise<number>;
 
+  "input_int8(int8)"(
+    input1: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<number>;
+
   input_stat_array(
     input1: BigNumberish[],
     overrides?: CallOverrides
   ): Promise<number[]>;
 
+  "input_stat_array(uint8[3])"(
+    input1: BigNumberish[],
+    overrides?: CallOverrides
+  ): Promise<number[]>;
+
   input_string(input1: string, overrides?: CallOverrides): Promise<string>;
 
+  "input_string(string)"(
+    input1: string,
+    overrides?: CallOverrides
+  ): Promise<string>;
+
   input_struct(
     input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
     overrides?: CallOverrides
@@ -279,6 +422,16 @@ export class DataTypesInput extends Contract {
     1: BigNumber;
   }>;
 
+  "input_struct(tuple)"(
+    input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
+    overrides?: CallOverrides
+  ): Promise<{
+    uint256_0: BigNumber;
+    uint256_1: BigNumber;
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
   input_tuple(
     input1: BigNumberish,
     input2: BigNumberish,
@@ -288,44 +441,108 @@ export class DataTypesInput extends Contract {
     1: BigNumber;
   }>;
 
+  "input_tuple(uint256,uint256)"(
+    input1: BigNumberish,
+    input2: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<{
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
   input_uint256(
     input1: BigNumberish,
     overrides?: CallOverrides
   ): Promise<BigNumber>;
 
+  "input_uint256(uint256)"(
+    input1: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
   input_uint8(input1: BigNumberish, overrides?: CallOverrides): Promise<number>;
 
+  "input_uint8(uint8)"(
+    input1: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<number>;
+
   callStatic: {
     input_address(input1: string, overrides?: CallOverrides): Promise<string>;
 
+    "input_address(address)"(
+      input1: string,
+      overrides?: CallOverrides
+    ): Promise<string>;
+
     input_bool(input1: boolean, overrides?: CallOverrides): Promise<boolean>;
 
+    "input_bool(bool)"(
+      input1: boolean,
+      overrides?: CallOverrides
+    ): Promise<boolean>;
+
     input_bytes(input1: BytesLike, overrides?: CallOverrides): Promise<string>;
 
+    "input_bytes(bytes)"(
+      input1: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<string>;
+
     input_bytes1(input1: BytesLike, overrides?: CallOverrides): Promise<string>;
 
+    "input_bytes1(bytes1)"(
+      input1: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<string>;
+
     input_enum(
       input1: BigNumberish,
       overrides?: CallOverrides
     ): Promise<number>;
 
+    "input_enum(uint8)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<number>;
+
     input_int256(
       input1: BigNumberish,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
+    "input_int256(int256)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
     input_int8(
       input1: BigNumberish,
       overrides?: CallOverrides
     ): Promise<number>;
 
+    "input_int8(int8)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<number>;
+
     input_stat_array(
       input1: BigNumberish[],
       overrides?: CallOverrides
     ): Promise<number[]>;
 
+    "input_stat_array(uint8[3])"(
+      input1: BigNumberish[],
+      overrides?: CallOverrides
+    ): Promise<number[]>;
+
     input_string(input1: string, overrides?: CallOverrides): Promise<string>;
 
+    "input_string(string)"(
+      input1: string,
+      overrides?: CallOverrides
+    ): Promise<string>;
+
     input_struct(
       input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
       overrides?: CallOverrides
@@ -336,6 +553,16 @@ export class DataTypesInput extends Contract {
       1: BigNumber;
     }>;
 
+    "input_struct(tuple)"(
+      input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
+      overrides?: CallOverrides
+    ): Promise<{
+      uint256_0: BigNumber;
+      uint256_1: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
     input_tuple(
       input1: BigNumberish,
       input2: BigNumberish,
@@ -345,15 +572,34 @@ export class DataTypesInput extends Contract {
       1: BigNumber;
     }>;
 
+    "input_tuple(uint256,uint256)"(
+      input1: BigNumberish,
+      input2: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
     input_uint256(
       input1: BigNumberish,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
+    "input_uint256(uint256)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
     input_uint8(
       input1: BigNumberish,
       overrides?: CallOverrides
     ): Promise<number>;
+
+    "input_uint8(uint8)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<number>;
   };
 
   filters: {};
diff --git a/packages/target-ethers-v5-test/types/DataTypesPure.d.ts b/packages/target-ethers-v5-test/types/DataTypesPure.d.ts
index 75fa19bfc..ec634a7db 100644
--- a/packages/target-ethers-v5-test/types/DataTypesPure.d.ts
+++ b/packages/target-ethers-v5-test/types/DataTypesPure.d.ts
@@ -143,42 +143,84 @@ export class DataTypesPure extends Contract {
       0: string;
     }>;
 
+    "pure_address()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
+
     pure_bool(
       overrides?: CallOverrides
     ): Promise<{
       0: boolean;
     }>;
 
+    "pure_bool()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: boolean;
+    }>;
+
     pure_bytes(
       overrides?: CallOverrides
     ): Promise<{
       0: string;
     }>;
 
+    "pure_bytes()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
+
     pure_bytes1(
       overrides?: CallOverrides
     ): Promise<{
       0: string;
     }>;
 
+    "pure_bytes1()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
+
     pure_enum(
       overrides?: CallOverrides
     ): Promise<{
       0: number;
     }>;
 
+    "pure_enum()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number;
+    }>;
+
     pure_int256(
       overrides?: CallOverrides
     ): Promise<{
       0: BigNumber;
     }>;
 
+    "pure_int256()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+    }>;
+
     pure_int8(
       overrides?: CallOverrides
     ): Promise<{
       0: number;
     }>;
 
+    "pure_int8()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number;
+    }>;
+
     pure_named(
       overrides?: CallOverrides
     ): Promise<{
@@ -188,18 +230,39 @@ export class DataTypesPure extends Contract {
       1: BigNumber;
     }>;
 
+    "pure_named()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      uint256_1: BigNumber;
+      uint256_2: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
     pure_stat_array(
       overrides?: CallOverrides
     ): Promise<{
       0: number[];
     }>;
 
+    "pure_stat_array()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number[];
+    }>;
+
     pure_string(
       overrides?: CallOverrides
     ): Promise<{
       0: string;
     }>;
 
+    "pure_string()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
+
     pure_struct(
       overrides?: CallOverrides
     ): Promise<{
@@ -211,6 +274,17 @@ export class DataTypesPure extends Contract {
       };
     }>;
 
+    "pure_struct()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: {
+        uint256_0: BigNumber;
+        uint256_1: BigNumber;
+        0: BigNumber;
+        1: BigNumber;
+      };
+    }>;
+
     pure_tuple(
       overrides?: CallOverrides
     ): Promise<{
@@ -218,33 +292,66 @@ export class DataTypesPure extends Contract {
       1: BigNumber;
     }>;
 
+    "pure_tuple()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
     pure_uint256(
       overrides?: CallOverrides
     ): Promise<{
       0: BigNumber;
     }>;
 
+    "pure_uint256()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+    }>;
+
     pure_uint8(
       overrides?: CallOverrides
     ): Promise<{
       0: number;
     }>;
+
+    "pure_uint8()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number;
+    }>;
   };
 
   pure_address(overrides?: CallOverrides): Promise<string>;
 
+  "pure_address()"(overrides?: CallOverrides): Promise<string>;
+
   pure_bool(overrides?: CallOverrides): Promise<boolean>;
 
+  "pure_bool()"(overrides?: CallOverrides): Promise<boolean>;
+
   pure_bytes(overrides?: CallOverrides): Promise<string>;
 
+  "pure_bytes()"(overrides?: CallOverrides): Promise<string>;
+
   pure_bytes1(overrides?: CallOverrides): Promise<string>;
 
+  "pure_bytes1()"(overrides?: CallOverrides): Promise<string>;
+
   pure_enum(overrides?: CallOverrides): Promise<number>;
 
+  "pure_enum()"(overrides?: CallOverrides): Promise<number>;
+
   pure_int256(overrides?: CallOverrides): Promise<BigNumber>;
 
+  "pure_int256()"(overrides?: CallOverrides): Promise<BigNumber>;
+
   pure_int8(overrides?: CallOverrides): Promise<number>;
 
+  "pure_int8()"(overrides?: CallOverrides): Promise<number>;
+
   pure_named(
     overrides?: CallOverrides
   ): Promise<{
@@ -254,10 +361,23 @@ export class DataTypesPure extends Contract {
     1: BigNumber;
   }>;
 
+  "pure_named()"(
+    overrides?: CallOverrides
+  ): Promise<{
+    uint256_1: BigNumber;
+    uint256_2: BigNumber;
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
   pure_stat_array(overrides?: CallOverrides): Promise<number[]>;
 
+  "pure_stat_array()"(overrides?: CallOverrides): Promise<number[]>;
+
   pure_string(overrides?: CallOverrides): Promise<string>;
 
+  "pure_string()"(overrides?: CallOverrides): Promise<string>;
+
   pure_struct(
     overrides?: CallOverrides
   ): Promise<{
@@ -267,6 +387,15 @@ export class DataTypesPure extends Contract {
     1: BigNumber;
   }>;
 
+  "pure_struct()"(
+    overrides?: CallOverrides
+  ): Promise<{
+    uint256_0: BigNumber;
+    uint256_1: BigNumber;
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
   pure_tuple(
     overrides?: CallOverrides
   ): Promise<{
@@ -274,25 +403,50 @@ export class DataTypesPure extends Contract {
     1: BigNumber;
   }>;
 
+  "pure_tuple()"(
+    overrides?: CallOverrides
+  ): Promise<{
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
   pure_uint256(overrides?: CallOverrides): Promise<BigNumber>;
 
+  "pure_uint256()"(overrides?: CallOverrides): Promise<BigNumber>;
+
   pure_uint8(overrides?: CallOverrides): Promise<number>;
 
+  "pure_uint8()"(overrides?: CallOverrides): Promise<number>;
+
   callStatic: {
     pure_address(overrides?: CallOverrides): Promise<string>;
 
+    "pure_address()"(overrides?: CallOverrides): Promise<string>;
+
     pure_bool(overrides?: CallOverrides): Promise<boolean>;
 
+    "pure_bool()"(overrides?: CallOverrides): Promise<boolean>;
+
     pure_bytes(overrides?: CallOverrides): Promise<string>;
 
+    "pure_bytes()"(overrides?: CallOverrides): Promise<string>;
+
     pure_bytes1(overrides?: CallOverrides): Promise<string>;
 
+    "pure_bytes1()"(overrides?: CallOverrides): Promise<string>;
+
     pure_enum(overrides?: CallOverrides): Promise<number>;
 
+    "pure_enum()"(overrides?: CallOverrides): Promise<number>;
+
     pure_int256(overrides?: CallOverrides): Promise<BigNumber>;
 
+    "pure_int256()"(overrides?: CallOverrides): Promise<BigNumber>;
+
     pure_int8(overrides?: CallOverrides): Promise<number>;
 
+    "pure_int8()"(overrides?: CallOverrides): Promise<number>;
+
     pure_named(
       overrides?: CallOverrides
     ): Promise<{
@@ -302,10 +456,23 @@ export class DataTypesPure extends Contract {
       1: BigNumber;
     }>;
 
+    "pure_named()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      uint256_1: BigNumber;
+      uint256_2: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
     pure_stat_array(overrides?: CallOverrides): Promise<number[]>;
 
+    "pure_stat_array()"(overrides?: CallOverrides): Promise<number[]>;
+
     pure_string(overrides?: CallOverrides): Promise<string>;
 
+    "pure_string()"(overrides?: CallOverrides): Promise<string>;
+
     pure_struct(
       overrides?: CallOverrides
     ): Promise<{
@@ -315,6 +482,15 @@ export class DataTypesPure extends Contract {
       1: BigNumber;
     }>;
 
+    "pure_struct()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      uint256_0: BigNumber;
+      uint256_1: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
     pure_tuple(
       overrides?: CallOverrides
     ): Promise<{
@@ -322,9 +498,20 @@ export class DataTypesPure extends Contract {
       1: BigNumber;
     }>;
 
+    "pure_tuple()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
     pure_uint256(overrides?: CallOverrides): Promise<BigNumber>;
 
+    "pure_uint256()"(overrides?: CallOverrides): Promise<BigNumber>;
+
     pure_uint8(overrides?: CallOverrides): Promise<number>;
+
+    "pure_uint8()"(overrides?: CallOverrides): Promise<number>;
   };
 
   filters: {};
diff --git a/packages/target-ethers-v5-test/types/DataTypesView.d.ts b/packages/target-ethers-v5-test/types/DataTypesView.d.ts
index f1fbf2cdd..db9dd0082 100644
--- a/packages/target-ethers-v5-test/types/DataTypesView.d.ts
+++ b/packages/target-ethers-v5-test/types/DataTypesView.d.ts
@@ -143,42 +143,84 @@ export class DataTypesView extends Contract {
       0: string;
     }>;
 
+    "view_address()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
+
     view_bool(
       overrides?: CallOverrides
     ): Promise<{
       0: boolean;
     }>;
 
+    "view_bool()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: boolean;
+    }>;
+
     view_bytes(
       overrides?: CallOverrides
     ): Promise<{
       0: string;
     }>;
 
+    "view_bytes()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
+
     view_bytes1(
       overrides?: CallOverrides
     ): Promise<{
       0: string;
     }>;
 
+    "view_bytes1()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
+
     view_enum(
       overrides?: CallOverrides
     ): Promise<{
       0: number;
     }>;
 
+    "view_enum()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number;
+    }>;
+
     view_int256(
       overrides?: CallOverrides
     ): Promise<{
       0: BigNumber;
     }>;
 
+    "view_int256()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+    }>;
+
     view_int8(
       overrides?: CallOverrides
     ): Promise<{
       0: number;
     }>;
 
+    "view_int8()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number;
+    }>;
+
     view_named(
       overrides?: CallOverrides
     ): Promise<{
@@ -188,18 +230,39 @@ export class DataTypesView extends Contract {
       1: BigNumber;
     }>;
 
+    "view_named()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      uint256_1: BigNumber;
+      uint256_2: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
     view_stat_array(
       overrides?: CallOverrides
     ): Promise<{
       0: number[];
     }>;
 
+    "view_stat_array()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number[];
+    }>;
+
     view_string(
       overrides?: CallOverrides
     ): Promise<{
       0: string;
     }>;
 
+    "view_string()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
+
     view_struct(
       overrides?: CallOverrides
     ): Promise<{
@@ -211,6 +274,17 @@ export class DataTypesView extends Contract {
       };
     }>;
 
+    "view_struct()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: {
+        uint256_0: BigNumber;
+        uint256_1: BigNumber;
+        0: BigNumber;
+        1: BigNumber;
+      };
+    }>;
+
     view_tuple(
       overrides?: CallOverrides
     ): Promise<{
@@ -218,33 +292,66 @@ export class DataTypesView extends Contract {
       1: BigNumber;
     }>;
 
+    "view_tuple()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
     view_uint256(
       overrides?: CallOverrides
     ): Promise<{
       0: BigNumber;
     }>;
 
+    "view_uint256()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+    }>;
+
     view_uint8(
       overrides?: CallOverrides
     ): Promise<{
       0: number;
     }>;
+
+    "view_uint8()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number;
+    }>;
   };
 
   view_address(overrides?: CallOverrides): Promise<string>;
 
+  "view_address()"(overrides?: CallOverrides): Promise<string>;
+
   view_bool(overrides?: CallOverrides): Promise<boolean>;
 
+  "view_bool()"(overrides?: CallOverrides): Promise<boolean>;
+
   view_bytes(overrides?: CallOverrides): Promise<string>;
 
+  "view_bytes()"(overrides?: CallOverrides): Promise<string>;
+
   view_bytes1(overrides?: CallOverrides): Promise<string>;
 
+  "view_bytes1()"(overrides?: CallOverrides): Promise<string>;
+
   view_enum(overrides?: CallOverrides): Promise<number>;
 
+  "view_enum()"(overrides?: CallOverrides): Promise<number>;
+
   view_int256(overrides?: CallOverrides): Promise<BigNumber>;
 
+  "view_int256()"(overrides?: CallOverrides): Promise<BigNumber>;
+
   view_int8(overrides?: CallOverrides): Promise<number>;
 
+  "view_int8()"(overrides?: CallOverrides): Promise<number>;
+
   view_named(
     overrides?: CallOverrides
   ): Promise<{
@@ -254,10 +361,23 @@ export class DataTypesView extends Contract {
     1: BigNumber;
   }>;
 
+  "view_named()"(
+    overrides?: CallOverrides
+  ): Promise<{
+    uint256_1: BigNumber;
+    uint256_2: BigNumber;
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
   view_stat_array(overrides?: CallOverrides): Promise<number[]>;
 
+  "view_stat_array()"(overrides?: CallOverrides): Promise<number[]>;
+
   view_string(overrides?: CallOverrides): Promise<string>;
 
+  "view_string()"(overrides?: CallOverrides): Promise<string>;
+
   view_struct(
     overrides?: CallOverrides
   ): Promise<{
@@ -267,6 +387,15 @@ export class DataTypesView extends Contract {
     1: BigNumber;
   }>;
 
+  "view_struct()"(
+    overrides?: CallOverrides
+  ): Promise<{
+    uint256_0: BigNumber;
+    uint256_1: BigNumber;
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
   view_tuple(
     overrides?: CallOverrides
   ): Promise<{
@@ -274,25 +403,50 @@ export class DataTypesView extends Contract {
     1: BigNumber;
   }>;
 
+  "view_tuple()"(
+    overrides?: CallOverrides
+  ): Promise<{
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
   view_uint256(overrides?: CallOverrides): Promise<BigNumber>;
 
+  "view_uint256()"(overrides?: CallOverrides): Promise<BigNumber>;
+
   view_uint8(overrides?: CallOverrides): Promise<number>;
 
+  "view_uint8()"(overrides?: CallOverrides): Promise<number>;
+
   callStatic: {
     view_address(overrides?: CallOverrides): Promise<string>;
 
+    "view_address()"(overrides?: CallOverrides): Promise<string>;
+
     view_bool(overrides?: CallOverrides): Promise<boolean>;
 
+    "view_bool()"(overrides?: CallOverrides): Promise<boolean>;
+
     view_bytes(overrides?: CallOverrides): Promise<string>;
 
+    "view_bytes()"(overrides?: CallOverrides): Promise<string>;
+
     view_bytes1(overrides?: CallOverrides): Promise<string>;
 
+    "view_bytes1()"(overrides?: CallOverrides): Promise<string>;
+
     view_enum(overrides?: CallOverrides): Promise<number>;
 
+    "view_enum()"(overrides?: CallOverrides): Promise<number>;
+
     view_int256(overrides?: CallOverrides): Promise<BigNumber>;
 
+    "view_int256()"(overrides?: CallOverrides): Promise<BigNumber>;
+
     view_int8(overrides?: CallOverrides): Promise<number>;
 
+    "view_int8()"(overrides?: CallOverrides): Promise<number>;
+
     view_named(
       overrides?: CallOverrides
     ): Promise<{
@@ -302,10 +456,23 @@ export class DataTypesView extends Contract {
       1: BigNumber;
     }>;
 
+    "view_named()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      uint256_1: BigNumber;
+      uint256_2: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
     view_stat_array(overrides?: CallOverrides): Promise<number[]>;
 
+    "view_stat_array()"(overrides?: CallOverrides): Promise<number[]>;
+
     view_string(overrides?: CallOverrides): Promise<string>;
 
+    "view_string()"(overrides?: CallOverrides): Promise<string>;
+
     view_struct(
       overrides?: CallOverrides
     ): Promise<{
@@ -315,6 +482,15 @@ export class DataTypesView extends Contract {
       1: BigNumber;
     }>;
 
+    "view_struct()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      uint256_0: BigNumber;
+      uint256_1: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
     view_tuple(
       overrides?: CallOverrides
     ): Promise<{
@@ -322,9 +498,20 @@ export class DataTypesView extends Contract {
       1: BigNumber;
     }>;
 
+    "view_tuple()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
     view_uint256(overrides?: CallOverrides): Promise<BigNumber>;
 
+    "view_uint256()"(overrides?: CallOverrides): Promise<BigNumber>;
+
     view_uint8(overrides?: CallOverrides): Promise<number>;
+
+    "view_uint8()"(overrides?: CallOverrides): Promise<number>;
   };
 
   filters: {};
diff --git a/packages/target-ethers-v5-test/types/Events.d.ts b/packages/target-ethers-v5-test/types/Events.d.ts
index 9f1f160c0..6f8a768b7 100644
--- a/packages/target-ethers-v5-test/types/Events.d.ts
+++ b/packages/target-ethers-v5-test/types/Events.d.ts
@@ -95,35 +95,69 @@ export class Events extends Contract {
   functions: {
     emit_anon1(overrides?: Overrides): Promise<ContractTransaction>;
 
+    "emit_anon1()"(overrides?: Overrides): Promise<ContractTransaction>;
+
     emit_event1(overrides?: Overrides): Promise<ContractTransaction>;
 
+    "emit_event1()"(overrides?: Overrides): Promise<ContractTransaction>;
+
     emit_event2(overrides?: Overrides): Promise<ContractTransaction>;
 
+    "emit_event2()"(overrides?: Overrides): Promise<ContractTransaction>;
+
     emit_event3(overrides?: Overrides): Promise<ContractTransaction>;
 
+    "emit_event3()"(overrides?: Overrides): Promise<ContractTransaction>;
+
     emit_event3_overloaded(overrides?: Overrides): Promise<ContractTransaction>;
+
+    "emit_event3_overloaded()"(
+      overrides?: Overrides
+    ): Promise<ContractTransaction>;
   };
 
   emit_anon1(overrides?: Overrides): Promise<ContractTransaction>;
 
+  "emit_anon1()"(overrides?: Overrides): Promise<ContractTransaction>;
+
   emit_event1(overrides?: Overrides): Promise<ContractTransaction>;
 
+  "emit_event1()"(overrides?: Overrides): Promise<ContractTransaction>;
+
   emit_event2(overrides?: Overrides): Promise<ContractTransaction>;
 
+  "emit_event2()"(overrides?: Overrides): Promise<ContractTransaction>;
+
   emit_event3(overrides?: Overrides): Promise<ContractTransaction>;
 
+  "emit_event3()"(overrides?: Overrides): Promise<ContractTransaction>;
+
   emit_event3_overloaded(overrides?: Overrides): Promise<ContractTransaction>;
 
+  "emit_event3_overloaded()"(
+    overrides?: Overrides
+  ): Promise<ContractTransaction>;
+
   callStatic: {
     emit_anon1(overrides?: Overrides): Promise<void>;
 
+    "emit_anon1()"(overrides?: Overrides): Promise<void>;
+
     emit_event1(overrides?: Overrides): Promise<void>;
 
+    "emit_event1()"(overrides?: Overrides): Promise<void>;
+
     emit_event2(overrides?: Overrides): Promise<void>;
 
+    "emit_event2()"(overrides?: Overrides): Promise<void>;
+
     emit_event3(overrides?: Overrides): Promise<void>;
 
+    "emit_event3()"(overrides?: Overrides): Promise<void>;
+
     emit_event3_overloaded(overrides?: Overrides): Promise<void>;
+
+    "emit_event3_overloaded()"(overrides?: Overrides): Promise<void>;
   };
 
   filters: {
diff --git a/packages/target-ethers-v5-test/types/NameMangling.d.ts b/packages/target-ethers-v5-test/types/NameMangling.d.ts
index b14c53184..2f9294172 100644
--- a/packages/target-ethers-v5-test/types/NameMangling.d.ts
+++ b/packages/target-ethers-v5-test/types/NameMangling.d.ts
@@ -49,12 +49,22 @@ export class NameMangling extends Contract {
     ): Promise<{
       0: boolean;
     }>;
+
+    "works()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: boolean;
+    }>;
   };
 
   works(overrides?: CallOverrides): Promise<boolean>;
 
+  "works()"(overrides?: CallOverrides): Promise<boolean>;
+
   callStatic: {
     works(overrides?: CallOverrides): Promise<boolean>;
+
+    "works()"(overrides?: CallOverrides): Promise<boolean>;
   };
 
   filters: {};
diff --git a/packages/target-ethers-v5-test/types/Payable.d.ts b/packages/target-ethers-v5-test/types/Payable.d.ts
index 99b9fc370..274f7e82a 100644
--- a/packages/target-ethers-v5-test/types/Payable.d.ts
+++ b/packages/target-ethers-v5-test/types/Payable.d.ts
@@ -62,17 +62,31 @@ export class Payable extends Contract {
   functions: {
     non_payable_func(overrides?: Overrides): Promise<ContractTransaction>;
 
+    "non_payable_func()"(overrides?: Overrides): Promise<ContractTransaction>;
+
     payable_func(overrides?: PayableOverrides): Promise<ContractTransaction>;
+
+    "payable_func()"(
+      overrides?: PayableOverrides
+    ): Promise<ContractTransaction>;
   };
 
   non_payable_func(overrides?: Overrides): Promise<ContractTransaction>;
 
+  "non_payable_func()"(overrides?: Overrides): Promise<ContractTransaction>;
+
   payable_func(overrides?: PayableOverrides): Promise<ContractTransaction>;
 
+  "payable_func()"(overrides?: PayableOverrides): Promise<ContractTransaction>;
+
   callStatic: {
     non_payable_func(overrides?: Overrides): Promise<void>;
 
+    "non_payable_func()"(overrides?: Overrides): Promise<void>;
+
     payable_func(overrides?: PayableOverrides): Promise<void>;
+
+    "payable_func()"(overrides?: PayableOverrides): Promise<void>;
   };
 
   filters: {};
diff --git a/packages/target-ethers-v5/src/codegen/functions.ts b/packages/target-ethers-v5/src/codegen/functions.ts
index 8fb00d51b..cb0fdd345 100644
--- a/packages/target-ethers-v5/src/codegen/functions.ts
+++ b/packages/target-ethers-v5/src/codegen/functions.ts
@@ -8,7 +8,7 @@ interface GenerateFunctionOptions {
 
 export function codegenFunctions(options: GenerateFunctionOptions, fns: FunctionDeclaration[]): string {
   if (fns.length === 1) {
-    return generateFunction(options, fns[0])
+    return `${generateFunction(options, fns[0])}${codegenForOverloadedFunctions(options, fns)}`
   }
 
   return codegenForOverloadedFunctions(options, fns)

From c94e4e6115fff3d2267742133630f41fa990b4f5 Mon Sep 17 00:00:00 2001
From: Braden Napier <brady.napier@dashos.net>
Date: Thu, 9 Jul 2020 03:43:44 -0400
Subject: [PATCH 46/64] fix: add check to confirm v5 overload not changed

---
 packages/target-ethers-v5-test/test/Overload.test.ts | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/packages/target-ethers-v5-test/test/Overload.test.ts b/packages/target-ethers-v5-test/test/Overload.test.ts
index c98919108..90f24bcb0 100644
--- a/packages/target-ethers-v5-test/test/Overload.test.ts
+++ b/packages/target-ethers-v5-test/test/Overload.test.ts
@@ -1,3 +1,4 @@
+import { expect } from 'chai'
 import { typedAssert } from 'test-utils'
 
 import { createNewBlockchain, deployContract } from './common'
@@ -18,6 +19,11 @@ describe('Overloads', () => {
   it('works with 1st overload', async () => {
     typedAssert(await contract['overload1(int256)'](1), BigNumber.from(1))
     typedAssert(await contract.functions['overload1(int256)'](1), { 0: BigNumber.from(1) })
+    expect(contract.overload1).to.be.undefined
+  })
+
+  it('still doesnt create overload1 fn anymore', () => {
+    expect(contract.overload1).to.be.undefined
   })
 
   it('works with 2n overload', async () => {

From 96a56eee165fc359e46dd96223239200f0b98e79 Mon Sep 17 00:00:00 2001
From: Braden Napier <brady.napier@dashos.net>
Date: Thu, 9 Jul 2020 03:44:36 -0400
Subject: [PATCH 47/64] fix: remove undefined expect from the first test

---
 packages/target-ethers-v5-test/test/Overload.test.ts | 1 -
 1 file changed, 1 deletion(-)

diff --git a/packages/target-ethers-v5-test/test/Overload.test.ts b/packages/target-ethers-v5-test/test/Overload.test.ts
index 90f24bcb0..1dcb871ff 100644
--- a/packages/target-ethers-v5-test/test/Overload.test.ts
+++ b/packages/target-ethers-v5-test/test/Overload.test.ts
@@ -19,7 +19,6 @@ describe('Overloads', () => {
   it('works with 1st overload', async () => {
     typedAssert(await contract['overload1(int256)'](1), BigNumber.from(1))
     typedAssert(await contract.functions['overload1(int256)'](1), { 0: BigNumber.from(1) })
-    expect(contract.overload1).to.be.undefined
   })
 
   it('still doesnt create overload1 fn anymore', () => {

From a94719d914f74840518e5263db5db7c70af263c7 Mon Sep 17 00:00:00 2001
From: Braden Napier <brady.napier@dashos.net>
Date: Thu, 9 Jul 2020 04:05:34 -0400
Subject: [PATCH 48/64] feat: combined fixes and features

---
 .../types/DataTypesInput.d.ts                 | 522 +++++++++++
 .../types/DataTypesInputFactory.ts            | 300 ++++++
 .../types/DataTypesPure.d.ts                  | 312 +++++++
 .../types/DataTypesPureFactory.ts             | 223 +++++
 .../types/DataTypesView.d.ts                  | 312 +++++++
 .../types/DataTypesViewFactory.ts             | 223 +++++
 .../target-ethers-v4-test/types/Events.d.ts   | 159 ++++
 .../types/EventsFactory.ts                    | 128 +++
 .../types/NameMangling.d.ts                   |  54 ++
 .../types/NameManglingFactory.ts              |  32 +
 .../types/Overloads.d.ts                      |  89 ++
 .../types/OverloadsFactory.ts                 |  62 ++
 .../target-ethers-v4-test/types/Payable.d.ts  |  79 ++
 .../types/PayableFactory.ts                   |  33 +
 .../target-ethers-v4-test/types/index.d.ts    |  28 +
 .../types/DataTypesInput.d.ts                 | 868 ++++++++++++++++++
 .../types/DataTypesInputContract.ts           | 300 ++++++
 .../types/DataTypesPure.d.ts                  | 636 +++++++++++++
 .../types/DataTypesPureContract.ts            | 223 +++++
 .../types/DataTypesView.d.ts                  | 636 +++++++++++++
 .../types/DataTypesViewContract.ts            | 223 +++++
 .../target-ethers-v5-test/types/Events.d.ts   | 220 +++++
 .../types/EventsContract.ts                   | 128 +++
 .../types/NameMangling.d.ts                   |  83 ++
 .../types/NameManglingContract.ts             |  32 +
 .../types/Overloads.d.ts                      | 117 +++
 .../types/OverloadsContract.ts                |  62 ++
 .../target-ethers-v5-test/types/Payable.d.ts  | 115 +++
 .../types/PayableContract.ts                  |  33 +
 packages/target-ethers-v5-test/types/index.ts |   2 +
 30 files changed, 6234 insertions(+)
 create mode 100644 packages/target-ethers-v4-test/types/DataTypesInput.d.ts
 create mode 100644 packages/target-ethers-v4-test/types/DataTypesInputFactory.ts
 create mode 100644 packages/target-ethers-v4-test/types/DataTypesPure.d.ts
 create mode 100644 packages/target-ethers-v4-test/types/DataTypesPureFactory.ts
 create mode 100644 packages/target-ethers-v4-test/types/DataTypesView.d.ts
 create mode 100644 packages/target-ethers-v4-test/types/DataTypesViewFactory.ts
 create mode 100644 packages/target-ethers-v4-test/types/Events.d.ts
 create mode 100644 packages/target-ethers-v4-test/types/EventsFactory.ts
 create mode 100644 packages/target-ethers-v4-test/types/NameMangling.d.ts
 create mode 100644 packages/target-ethers-v4-test/types/NameManglingFactory.ts
 create mode 100644 packages/target-ethers-v4-test/types/Overloads.d.ts
 create mode 100644 packages/target-ethers-v4-test/types/OverloadsFactory.ts
 create mode 100644 packages/target-ethers-v4-test/types/Payable.d.ts
 create mode 100644 packages/target-ethers-v4-test/types/PayableFactory.ts
 create mode 100644 packages/target-ethers-v4-test/types/index.d.ts
 create mode 100644 packages/target-ethers-v5-test/types/DataTypesInput.d.ts
 create mode 100644 packages/target-ethers-v5-test/types/DataTypesInputContract.ts
 create mode 100644 packages/target-ethers-v5-test/types/DataTypesPure.d.ts
 create mode 100644 packages/target-ethers-v5-test/types/DataTypesPureContract.ts
 create mode 100644 packages/target-ethers-v5-test/types/DataTypesView.d.ts
 create mode 100644 packages/target-ethers-v5-test/types/DataTypesViewContract.ts
 create mode 100644 packages/target-ethers-v5-test/types/Events.d.ts
 create mode 100644 packages/target-ethers-v5-test/types/EventsContract.ts
 create mode 100644 packages/target-ethers-v5-test/types/NameMangling.d.ts
 create mode 100644 packages/target-ethers-v5-test/types/NameManglingContract.ts
 create mode 100644 packages/target-ethers-v5-test/types/Overloads.d.ts
 create mode 100644 packages/target-ethers-v5-test/types/OverloadsContract.ts
 create mode 100644 packages/target-ethers-v5-test/types/Payable.d.ts
 create mode 100644 packages/target-ethers-v5-test/types/PayableContract.ts
 create mode 100644 packages/target-ethers-v5-test/types/index.ts

diff --git a/packages/target-ethers-v4-test/types/DataTypesInput.d.ts b/packages/target-ethers-v4-test/types/DataTypesInput.d.ts
new file mode 100644
index 000000000..572887d63
--- /dev/null
+++ b/packages/target-ethers-v4-test/types/DataTypesInput.d.ts
@@ -0,0 +1,522 @@
+/* Generated by ts-generator ver. 0.0.8 */
+/* tslint:disable */
+
+import { Contract, ContractTransaction, EventFilter, Signer } from "ethers";
+import { Listener, Provider } from "ethers/providers";
+import { Arrayish, BigNumber, BigNumberish, Interface } from "ethers/utils";
+import {
+  TransactionOverrides,
+  TypedEventDescription,
+  TypedFunctionDescription
+} from ".";
+
+interface DataTypesInputInterface extends Interface {
+  functions: {
+    input_address: TypedFunctionDescription<{
+      encode([input1]: [string]): string;
+    }>;
+
+    input_bool: TypedFunctionDescription<{
+      encode([input1]: [boolean]): string;
+    }>;
+
+    input_bytes: TypedFunctionDescription<{
+      encode([input1]: [Arrayish]): string;
+    }>;
+
+    input_bytes1: TypedFunctionDescription<{
+      encode([input1]: [Arrayish]): string;
+    }>;
+
+    input_enum: TypedFunctionDescription<{
+      encode([input1]: [BigNumberish]): string;
+    }>;
+
+    input_int256: TypedFunctionDescription<{
+      encode([input1]: [BigNumberish]): string;
+    }>;
+
+    input_int8: TypedFunctionDescription<{
+      encode([input1]: [BigNumberish]): string;
+    }>;
+
+    input_stat_array: TypedFunctionDescription<{
+      encode([input1]: [BigNumberish[]]): string;
+    }>;
+
+    input_string: TypedFunctionDescription<{
+      encode([input1]: [string]): string;
+    }>;
+
+    input_struct: TypedFunctionDescription<{
+      encode([input1]: [
+        { uint256_0: BigNumberish; uint256_1: BigNumberish }
+      ]): string;
+    }>;
+
+    input_tuple: TypedFunctionDescription<{
+      encode([input1, input2]: [BigNumberish, BigNumberish]): string;
+    }>;
+
+    input_uint256: TypedFunctionDescription<{
+      encode([input1]: [BigNumberish]): string;
+    }>;
+
+    input_uint8: TypedFunctionDescription<{
+      encode([input1]: [BigNumberish]): string;
+    }>;
+  };
+
+  events: {};
+}
+
+export class DataTypesInput extends Contract {
+  connect(signerOrProvider: Signer | Provider | string): DataTypesInput;
+  attach(addressOrName: string): DataTypesInput;
+  deployed(): Promise<DataTypesInput>;
+
+  on(event: EventFilter | string, listener: Listener): DataTypesInput;
+  once(event: EventFilter | string, listener: Listener): DataTypesInput;
+  addListener(
+    eventName: EventFilter | string,
+    listener: Listener
+  ): DataTypesInput;
+  removeAllListeners(eventName: EventFilter | string): DataTypesInput;
+  removeListener(eventName: any, listener: Listener): DataTypesInput;
+
+  interface: DataTypesInputInterface;
+
+  functions: {
+    input_address(
+      input1: string,
+      overrides?: TransactionOverrides
+    ): Promise<string>;
+
+    "input_address(address)"(
+      input1: string,
+      overrides?: TransactionOverrides
+    ): Promise<string>;
+
+    input_bool(
+      input1: boolean,
+      overrides?: TransactionOverrides
+    ): Promise<boolean>;
+
+    "input_bool(bool)"(
+      input1: boolean,
+      overrides?: TransactionOverrides
+    ): Promise<boolean>;
+
+    input_bytes(
+      input1: Arrayish,
+      overrides?: TransactionOverrides
+    ): Promise<string>;
+
+    "input_bytes(bytes)"(
+      input1: Arrayish,
+      overrides?: TransactionOverrides
+    ): Promise<string>;
+
+    input_bytes1(
+      input1: Arrayish,
+      overrides?: TransactionOverrides
+    ): Promise<string>;
+
+    "input_bytes1(bytes1)"(
+      input1: Arrayish,
+      overrides?: TransactionOverrides
+    ): Promise<string>;
+
+    input_enum(
+      input1: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<number>;
+
+    "input_enum(uint8)"(
+      input1: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<number>;
+
+    input_int256(
+      input1: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+
+    "input_int256(int256)"(
+      input1: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+
+    input_int8(
+      input1: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<number>;
+
+    "input_int8(int8)"(
+      input1: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<number>;
+
+    input_stat_array(
+      input1: BigNumberish[],
+      overrides?: TransactionOverrides
+    ): Promise<number[]>;
+
+    "input_stat_array(uint8[3])"(
+      input1: BigNumberish[],
+      overrides?: TransactionOverrides
+    ): Promise<number[]>;
+
+    input_string(
+      input1: string,
+      overrides?: TransactionOverrides
+    ): Promise<string>;
+
+    "input_string(string)"(
+      input1: string,
+      overrides?: TransactionOverrides
+    ): Promise<string>;
+
+    input_struct(
+      input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
+      overrides?: TransactionOverrides
+    ): Promise<{
+      uint256_0: BigNumber;
+      uint256_1: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    "input_struct(tuple)"(
+      input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
+      overrides?: TransactionOverrides
+    ): Promise<{
+      uint256_0: BigNumber;
+      uint256_1: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    input_tuple(
+      input1: BigNumberish,
+      input2: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<{
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    "input_tuple(uint256,uint256)"(
+      input1: BigNumberish,
+      input2: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<{
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    input_uint256(
+      input1: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+
+    "input_uint256(uint256)"(
+      input1: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+
+    input_uint8(
+      input1: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<number>;
+
+    "input_uint8(uint8)"(
+      input1: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<number>;
+  };
+
+  input_address(
+    input1: string,
+    overrides?: TransactionOverrides
+  ): Promise<string>;
+
+  "input_address(address)"(
+    input1: string,
+    overrides?: TransactionOverrides
+  ): Promise<string>;
+
+  input_bool(
+    input1: boolean,
+    overrides?: TransactionOverrides
+  ): Promise<boolean>;
+
+  "input_bool(bool)"(
+    input1: boolean,
+    overrides?: TransactionOverrides
+  ): Promise<boolean>;
+
+  input_bytes(
+    input1: Arrayish,
+    overrides?: TransactionOverrides
+  ): Promise<string>;
+
+  "input_bytes(bytes)"(
+    input1: Arrayish,
+    overrides?: TransactionOverrides
+  ): Promise<string>;
+
+  input_bytes1(
+    input1: Arrayish,
+    overrides?: TransactionOverrides
+  ): Promise<string>;
+
+  "input_bytes1(bytes1)"(
+    input1: Arrayish,
+    overrides?: TransactionOverrides
+  ): Promise<string>;
+
+  input_enum(
+    input1: BigNumberish,
+    overrides?: TransactionOverrides
+  ): Promise<number>;
+
+  "input_enum(uint8)"(
+    input1: BigNumberish,
+    overrides?: TransactionOverrides
+  ): Promise<number>;
+
+  input_int256(
+    input1: BigNumberish,
+    overrides?: TransactionOverrides
+  ): Promise<BigNumber>;
+
+  "input_int256(int256)"(
+    input1: BigNumberish,
+    overrides?: TransactionOverrides
+  ): Promise<BigNumber>;
+
+  input_int8(
+    input1: BigNumberish,
+    overrides?: TransactionOverrides
+  ): Promise<number>;
+
+  "input_int8(int8)"(
+    input1: BigNumberish,
+    overrides?: TransactionOverrides
+  ): Promise<number>;
+
+  input_stat_array(
+    input1: BigNumberish[],
+    overrides?: TransactionOverrides
+  ): Promise<number[]>;
+
+  "input_stat_array(uint8[3])"(
+    input1: BigNumberish[],
+    overrides?: TransactionOverrides
+  ): Promise<number[]>;
+
+  input_string(
+    input1: string,
+    overrides?: TransactionOverrides
+  ): Promise<string>;
+
+  "input_string(string)"(
+    input1: string,
+    overrides?: TransactionOverrides
+  ): Promise<string>;
+
+  input_struct(
+    input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
+    overrides?: TransactionOverrides
+  ): Promise<{
+    uint256_0: BigNumber;
+    uint256_1: BigNumber;
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
+  "input_struct(tuple)"(
+    input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
+    overrides?: TransactionOverrides
+  ): Promise<{
+    uint256_0: BigNumber;
+    uint256_1: BigNumber;
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
+  input_tuple(
+    input1: BigNumberish,
+    input2: BigNumberish,
+    overrides?: TransactionOverrides
+  ): Promise<{
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
+  "input_tuple(uint256,uint256)"(
+    input1: BigNumberish,
+    input2: BigNumberish,
+    overrides?: TransactionOverrides
+  ): Promise<{
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
+  input_uint256(
+    input1: BigNumberish,
+    overrides?: TransactionOverrides
+  ): Promise<BigNumber>;
+
+  "input_uint256(uint256)"(
+    input1: BigNumberish,
+    overrides?: TransactionOverrides
+  ): Promise<BigNumber>;
+
+  input_uint8(
+    input1: BigNumberish,
+    overrides?: TransactionOverrides
+  ): Promise<number>;
+
+  "input_uint8(uint8)"(
+    input1: BigNumberish,
+    overrides?: TransactionOverrides
+  ): Promise<number>;
+
+  filters: {};
+
+  estimate: {
+    input_address(
+      input1: string,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+
+    "input_address(address)"(
+      input1: string,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+
+    input_bool(
+      input1: boolean,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+
+    "input_bool(bool)"(
+      input1: boolean,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+
+    input_bytes(
+      input1: Arrayish,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+
+    "input_bytes(bytes)"(
+      input1: Arrayish,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+
+    input_bytes1(
+      input1: Arrayish,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+
+    "input_bytes1(bytes1)"(
+      input1: Arrayish,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+
+    input_enum(
+      input1: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+
+    "input_enum(uint8)"(
+      input1: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+
+    input_int256(
+      input1: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+
+    "input_int256(int256)"(
+      input1: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+
+    input_int8(
+      input1: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+
+    "input_int8(int8)"(
+      input1: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+
+    input_stat_array(
+      input1: BigNumberish[],
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+
+    "input_stat_array(uint8[3])"(
+      input1: BigNumberish[],
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+
+    input_string(
+      input1: string,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+
+    "input_string(string)"(
+      input1: string,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+
+    input_struct(
+      input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+
+    "input_struct(tuple)"(
+      input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+
+    input_tuple(
+      input1: BigNumberish,
+      input2: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+
+    "input_tuple(uint256,uint256)"(
+      input1: BigNumberish,
+      input2: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+
+    input_uint256(
+      input1: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+
+    "input_uint256(uint256)"(
+      input1: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+
+    input_uint8(
+      input1: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+
+    "input_uint8(uint8)"(
+      input1: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+  };
+}
diff --git a/packages/target-ethers-v4-test/types/DataTypesInputFactory.ts b/packages/target-ethers-v4-test/types/DataTypesInputFactory.ts
new file mode 100644
index 000000000..34f3fcc78
--- /dev/null
+++ b/packages/target-ethers-v4-test/types/DataTypesInputFactory.ts
@@ -0,0 +1,300 @@
+/* Generated by ts-generator ver. 0.0.8 */
+/* tslint:disable */
+
+import { Contract, Signer } from "ethers";
+import { Provider } from "ethers/providers";
+
+import { DataTypesInput } from "./DataTypesInput";
+
+export class DataTypesInputFactory {
+  static connect(
+    address: string,
+    signerOrProvider: Signer | Provider
+  ): DataTypesInput {
+    return new Contract(address, _abi, signerOrProvider) as DataTypesInput;
+  }
+}
+
+const _abi = [
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "input1",
+        type: "address"
+      }
+    ],
+    name: "input_address",
+    outputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bool",
+        name: "input1",
+        type: "bool"
+      }
+    ],
+    name: "input_bool",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "input1",
+        type: "bytes"
+      }
+    ],
+    name: "input_bytes",
+    outputs: [
+      {
+        internalType: "bytes",
+        name: "",
+        type: "bytes"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes1",
+        name: "input1",
+        type: "bytes1"
+      }
+    ],
+    name: "input_bytes1",
+    outputs: [
+      {
+        internalType: "bytes1",
+        name: "",
+        type: "bytes1"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "enum DataTypesInput.Enum1",
+        name: "input1",
+        type: "uint8"
+      }
+    ],
+    name: "input_enum",
+    outputs: [
+      {
+        internalType: "enum DataTypesInput.Enum1",
+        name: "",
+        type: "uint8"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "int256",
+        name: "input1",
+        type: "int256"
+      }
+    ],
+    name: "input_int256",
+    outputs: [
+      {
+        internalType: "int256",
+        name: "",
+        type: "int256"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "int8",
+        name: "input1",
+        type: "int8"
+      }
+    ],
+    name: "input_int8",
+    outputs: [
+      {
+        internalType: "int8",
+        name: "",
+        type: "int8"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint8[3]",
+        name: "input1",
+        type: "uint8[3]"
+      }
+    ],
+    name: "input_stat_array",
+    outputs: [
+      {
+        internalType: "uint8[3]",
+        name: "",
+        type: "uint8[3]"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "string",
+        name: "input1",
+        type: "string"
+      }
+    ],
+    name: "input_string",
+    outputs: [
+      {
+        internalType: "string",
+        name: "",
+        type: "string"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        components: [
+          {
+            internalType: "uint256",
+            name: "uint256_0",
+            type: "uint256"
+          },
+          {
+            internalType: "uint256",
+            name: "uint256_1",
+            type: "uint256"
+          }
+        ],
+        internalType: "struct DataTypesInput.Struct1",
+        name: "input1",
+        type: "tuple"
+      }
+    ],
+    name: "input_struct",
+    outputs: [
+      {
+        components: [
+          {
+            internalType: "uint256",
+            name: "uint256_0",
+            type: "uint256"
+          },
+          {
+            internalType: "uint256",
+            name: "uint256_1",
+            type: "uint256"
+          }
+        ],
+        internalType: "struct DataTypesInput.Struct1",
+        name: "",
+        type: "tuple"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "input1",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "input2",
+        type: "uint256"
+      }
+    ],
+    name: "input_tuple",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "input1",
+        type: "uint256"
+      }
+    ],
+    name: "input_uint256",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint8",
+        name: "input1",
+        type: "uint8"
+      }
+    ],
+    name: "input_uint8",
+    outputs: [
+      {
+        internalType: "uint8",
+        name: "",
+        type: "uint8"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  }
+];
diff --git a/packages/target-ethers-v4-test/types/DataTypesPure.d.ts b/packages/target-ethers-v4-test/types/DataTypesPure.d.ts
new file mode 100644
index 000000000..80b7d9ad2
--- /dev/null
+++ b/packages/target-ethers-v4-test/types/DataTypesPure.d.ts
@@ -0,0 +1,312 @@
+/* Generated by ts-generator ver. 0.0.8 */
+/* tslint:disable */
+
+import { Contract, ContractTransaction, EventFilter, Signer } from "ethers";
+import { Listener, Provider } from "ethers/providers";
+import { Arrayish, BigNumber, BigNumberish, Interface } from "ethers/utils";
+import {
+  TransactionOverrides,
+  TypedEventDescription,
+  TypedFunctionDescription
+} from ".";
+
+interface DataTypesPureInterface extends Interface {
+  functions: {
+    pure_address: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    pure_bool: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    pure_bytes: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    pure_bytes1: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    pure_enum: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    pure_int256: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    pure_int8: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    pure_named: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    pure_stat_array: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    pure_string: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    pure_struct: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    pure_tuple: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    pure_uint256: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    pure_uint8: TypedFunctionDescription<{ encode([]: []): string }>;
+  };
+
+  events: {};
+}
+
+export class DataTypesPure extends Contract {
+  connect(signerOrProvider: Signer | Provider | string): DataTypesPure;
+  attach(addressOrName: string): DataTypesPure;
+  deployed(): Promise<DataTypesPure>;
+
+  on(event: EventFilter | string, listener: Listener): DataTypesPure;
+  once(event: EventFilter | string, listener: Listener): DataTypesPure;
+  addListener(
+    eventName: EventFilter | string,
+    listener: Listener
+  ): DataTypesPure;
+  removeAllListeners(eventName: EventFilter | string): DataTypesPure;
+  removeListener(eventName: any, listener: Listener): DataTypesPure;
+
+  interface: DataTypesPureInterface;
+
+  functions: {
+    pure_address(overrides?: TransactionOverrides): Promise<string>;
+
+    "pure_address()"(overrides?: TransactionOverrides): Promise<string>;
+
+    pure_bool(overrides?: TransactionOverrides): Promise<boolean>;
+
+    "pure_bool()"(overrides?: TransactionOverrides): Promise<boolean>;
+
+    pure_bytes(overrides?: TransactionOverrides): Promise<string>;
+
+    "pure_bytes()"(overrides?: TransactionOverrides): Promise<string>;
+
+    pure_bytes1(overrides?: TransactionOverrides): Promise<string>;
+
+    "pure_bytes1()"(overrides?: TransactionOverrides): Promise<string>;
+
+    pure_enum(overrides?: TransactionOverrides): Promise<number>;
+
+    "pure_enum()"(overrides?: TransactionOverrides): Promise<number>;
+
+    pure_int256(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "pure_int256()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    pure_int8(overrides?: TransactionOverrides): Promise<number>;
+
+    "pure_int8()"(overrides?: TransactionOverrides): Promise<number>;
+
+    pure_named(
+      overrides?: TransactionOverrides
+    ): Promise<{
+      uint256_1: BigNumber;
+      uint256_2: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    "pure_named()"(
+      overrides?: TransactionOverrides
+    ): Promise<{
+      uint256_1: BigNumber;
+      uint256_2: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    pure_stat_array(overrides?: TransactionOverrides): Promise<number[]>;
+
+    "pure_stat_array()"(overrides?: TransactionOverrides): Promise<number[]>;
+
+    pure_string(overrides?: TransactionOverrides): Promise<string>;
+
+    "pure_string()"(overrides?: TransactionOverrides): Promise<string>;
+
+    pure_struct(
+      overrides?: TransactionOverrides
+    ): Promise<{
+      uint256_0: BigNumber;
+      uint256_1: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    "pure_struct()"(
+      overrides?: TransactionOverrides
+    ): Promise<{
+      uint256_0: BigNumber;
+      uint256_1: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    pure_tuple(
+      overrides?: TransactionOverrides
+    ): Promise<{
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    "pure_tuple()"(
+      overrides?: TransactionOverrides
+    ): Promise<{
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    pure_uint256(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "pure_uint256()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    pure_uint8(overrides?: TransactionOverrides): Promise<number>;
+
+    "pure_uint8()"(overrides?: TransactionOverrides): Promise<number>;
+  };
+
+  pure_address(overrides?: TransactionOverrides): Promise<string>;
+
+  "pure_address()"(overrides?: TransactionOverrides): Promise<string>;
+
+  pure_bool(overrides?: TransactionOverrides): Promise<boolean>;
+
+  "pure_bool()"(overrides?: TransactionOverrides): Promise<boolean>;
+
+  pure_bytes(overrides?: TransactionOverrides): Promise<string>;
+
+  "pure_bytes()"(overrides?: TransactionOverrides): Promise<string>;
+
+  pure_bytes1(overrides?: TransactionOverrides): Promise<string>;
+
+  "pure_bytes1()"(overrides?: TransactionOverrides): Promise<string>;
+
+  pure_enum(overrides?: TransactionOverrides): Promise<number>;
+
+  "pure_enum()"(overrides?: TransactionOverrides): Promise<number>;
+
+  pure_int256(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+  "pure_int256()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+  pure_int8(overrides?: TransactionOverrides): Promise<number>;
+
+  "pure_int8()"(overrides?: TransactionOverrides): Promise<number>;
+
+  pure_named(
+    overrides?: TransactionOverrides
+  ): Promise<{
+    uint256_1: BigNumber;
+    uint256_2: BigNumber;
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
+  "pure_named()"(
+    overrides?: TransactionOverrides
+  ): Promise<{
+    uint256_1: BigNumber;
+    uint256_2: BigNumber;
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
+  pure_stat_array(overrides?: TransactionOverrides): Promise<number[]>;
+
+  "pure_stat_array()"(overrides?: TransactionOverrides): Promise<number[]>;
+
+  pure_string(overrides?: TransactionOverrides): Promise<string>;
+
+  "pure_string()"(overrides?: TransactionOverrides): Promise<string>;
+
+  pure_struct(
+    overrides?: TransactionOverrides
+  ): Promise<{
+    uint256_0: BigNumber;
+    uint256_1: BigNumber;
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
+  "pure_struct()"(
+    overrides?: TransactionOverrides
+  ): Promise<{
+    uint256_0: BigNumber;
+    uint256_1: BigNumber;
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
+  pure_tuple(
+    overrides?: TransactionOverrides
+  ): Promise<{
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
+  "pure_tuple()"(
+    overrides?: TransactionOverrides
+  ): Promise<{
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
+  pure_uint256(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+  "pure_uint256()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+  pure_uint8(overrides?: TransactionOverrides): Promise<number>;
+
+  "pure_uint8()"(overrides?: TransactionOverrides): Promise<number>;
+
+  filters: {};
+
+  estimate: {
+    pure_address(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "pure_address()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    pure_bool(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "pure_bool()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    pure_bytes(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "pure_bytes()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    pure_bytes1(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "pure_bytes1()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    pure_enum(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "pure_enum()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    pure_int256(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "pure_int256()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    pure_int8(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "pure_int8()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    pure_named(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "pure_named()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    pure_stat_array(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "pure_stat_array()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    pure_string(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "pure_string()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    pure_struct(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "pure_struct()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    pure_tuple(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "pure_tuple()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    pure_uint256(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "pure_uint256()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    pure_uint8(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "pure_uint8()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+  };
+}
diff --git a/packages/target-ethers-v4-test/types/DataTypesPureFactory.ts b/packages/target-ethers-v4-test/types/DataTypesPureFactory.ts
new file mode 100644
index 000000000..c0ab0e7af
--- /dev/null
+++ b/packages/target-ethers-v4-test/types/DataTypesPureFactory.ts
@@ -0,0 +1,223 @@
+/* Generated by ts-generator ver. 0.0.8 */
+/* tslint:disable */
+
+import { Contract, Signer } from "ethers";
+import { Provider } from "ethers/providers";
+
+import { DataTypesPure } from "./DataTypesPure";
+
+export class DataTypesPureFactory {
+  static connect(
+    address: string,
+    signerOrProvider: Signer | Provider
+  ): DataTypesPure {
+    return new Contract(address, _abi, signerOrProvider) as DataTypesPure;
+  }
+}
+
+const _abi = [
+  {
+    inputs: [],
+    name: "pure_address",
+    outputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "pure_bool",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "pure_bytes",
+    outputs: [
+      {
+        internalType: "bytes",
+        name: "",
+        type: "bytes"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "pure_bytes1",
+    outputs: [
+      {
+        internalType: "bytes1",
+        name: "",
+        type: "bytes1"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "pure_enum",
+    outputs: [
+      {
+        internalType: "enum DataTypesPure.Enum1",
+        name: "",
+        type: "uint8"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "pure_int256",
+    outputs: [
+      {
+        internalType: "int256",
+        name: "",
+        type: "int256"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "pure_int8",
+    outputs: [
+      {
+        internalType: "int8",
+        name: "",
+        type: "int8"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "pure_named",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "uint256_1",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "uint256_2",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "pure_stat_array",
+    outputs: [
+      {
+        internalType: "uint8[3]",
+        name: "",
+        type: "uint8[3]"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "pure_string",
+    outputs: [
+      {
+        internalType: "string",
+        name: "",
+        type: "string"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "pure_struct",
+    outputs: [
+      {
+        components: [
+          {
+            internalType: "uint256",
+            name: "uint256_0",
+            type: "uint256"
+          },
+          {
+            internalType: "uint256",
+            name: "uint256_1",
+            type: "uint256"
+          }
+        ],
+        internalType: "struct DataTypesPure.Struct1",
+        name: "",
+        type: "tuple"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "pure_tuple",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "pure_uint256",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "pure_uint8",
+    outputs: [
+      {
+        internalType: "uint8",
+        name: "",
+        type: "uint8"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  }
+];
diff --git a/packages/target-ethers-v4-test/types/DataTypesView.d.ts b/packages/target-ethers-v4-test/types/DataTypesView.d.ts
new file mode 100644
index 000000000..9ec7bf803
--- /dev/null
+++ b/packages/target-ethers-v4-test/types/DataTypesView.d.ts
@@ -0,0 +1,312 @@
+/* Generated by ts-generator ver. 0.0.8 */
+/* tslint:disable */
+
+import { Contract, ContractTransaction, EventFilter, Signer } from "ethers";
+import { Listener, Provider } from "ethers/providers";
+import { Arrayish, BigNumber, BigNumberish, Interface } from "ethers/utils";
+import {
+  TransactionOverrides,
+  TypedEventDescription,
+  TypedFunctionDescription
+} from ".";
+
+interface DataTypesViewInterface extends Interface {
+  functions: {
+    view_address: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    view_bool: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    view_bytes: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    view_bytes1: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    view_enum: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    view_int256: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    view_int8: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    view_named: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    view_stat_array: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    view_string: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    view_struct: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    view_tuple: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    view_uint256: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    view_uint8: TypedFunctionDescription<{ encode([]: []): string }>;
+  };
+
+  events: {};
+}
+
+export class DataTypesView extends Contract {
+  connect(signerOrProvider: Signer | Provider | string): DataTypesView;
+  attach(addressOrName: string): DataTypesView;
+  deployed(): Promise<DataTypesView>;
+
+  on(event: EventFilter | string, listener: Listener): DataTypesView;
+  once(event: EventFilter | string, listener: Listener): DataTypesView;
+  addListener(
+    eventName: EventFilter | string,
+    listener: Listener
+  ): DataTypesView;
+  removeAllListeners(eventName: EventFilter | string): DataTypesView;
+  removeListener(eventName: any, listener: Listener): DataTypesView;
+
+  interface: DataTypesViewInterface;
+
+  functions: {
+    view_address(overrides?: TransactionOverrides): Promise<string>;
+
+    "view_address()"(overrides?: TransactionOverrides): Promise<string>;
+
+    view_bool(overrides?: TransactionOverrides): Promise<boolean>;
+
+    "view_bool()"(overrides?: TransactionOverrides): Promise<boolean>;
+
+    view_bytes(overrides?: TransactionOverrides): Promise<string>;
+
+    "view_bytes()"(overrides?: TransactionOverrides): Promise<string>;
+
+    view_bytes1(overrides?: TransactionOverrides): Promise<string>;
+
+    "view_bytes1()"(overrides?: TransactionOverrides): Promise<string>;
+
+    view_enum(overrides?: TransactionOverrides): Promise<number>;
+
+    "view_enum()"(overrides?: TransactionOverrides): Promise<number>;
+
+    view_int256(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "view_int256()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    view_int8(overrides?: TransactionOverrides): Promise<number>;
+
+    "view_int8()"(overrides?: TransactionOverrides): Promise<number>;
+
+    view_named(
+      overrides?: TransactionOverrides
+    ): Promise<{
+      uint256_1: BigNumber;
+      uint256_2: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    "view_named()"(
+      overrides?: TransactionOverrides
+    ): Promise<{
+      uint256_1: BigNumber;
+      uint256_2: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    view_stat_array(overrides?: TransactionOverrides): Promise<number[]>;
+
+    "view_stat_array()"(overrides?: TransactionOverrides): Promise<number[]>;
+
+    view_string(overrides?: TransactionOverrides): Promise<string>;
+
+    "view_string()"(overrides?: TransactionOverrides): Promise<string>;
+
+    view_struct(
+      overrides?: TransactionOverrides
+    ): Promise<{
+      uint256_0: BigNumber;
+      uint256_1: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    "view_struct()"(
+      overrides?: TransactionOverrides
+    ): Promise<{
+      uint256_0: BigNumber;
+      uint256_1: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    view_tuple(
+      overrides?: TransactionOverrides
+    ): Promise<{
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    "view_tuple()"(
+      overrides?: TransactionOverrides
+    ): Promise<{
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    view_uint256(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "view_uint256()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    view_uint8(overrides?: TransactionOverrides): Promise<number>;
+
+    "view_uint8()"(overrides?: TransactionOverrides): Promise<number>;
+  };
+
+  view_address(overrides?: TransactionOverrides): Promise<string>;
+
+  "view_address()"(overrides?: TransactionOverrides): Promise<string>;
+
+  view_bool(overrides?: TransactionOverrides): Promise<boolean>;
+
+  "view_bool()"(overrides?: TransactionOverrides): Promise<boolean>;
+
+  view_bytes(overrides?: TransactionOverrides): Promise<string>;
+
+  "view_bytes()"(overrides?: TransactionOverrides): Promise<string>;
+
+  view_bytes1(overrides?: TransactionOverrides): Promise<string>;
+
+  "view_bytes1()"(overrides?: TransactionOverrides): Promise<string>;
+
+  view_enum(overrides?: TransactionOverrides): Promise<number>;
+
+  "view_enum()"(overrides?: TransactionOverrides): Promise<number>;
+
+  view_int256(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+  "view_int256()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+  view_int8(overrides?: TransactionOverrides): Promise<number>;
+
+  "view_int8()"(overrides?: TransactionOverrides): Promise<number>;
+
+  view_named(
+    overrides?: TransactionOverrides
+  ): Promise<{
+    uint256_1: BigNumber;
+    uint256_2: BigNumber;
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
+  "view_named()"(
+    overrides?: TransactionOverrides
+  ): Promise<{
+    uint256_1: BigNumber;
+    uint256_2: BigNumber;
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
+  view_stat_array(overrides?: TransactionOverrides): Promise<number[]>;
+
+  "view_stat_array()"(overrides?: TransactionOverrides): Promise<number[]>;
+
+  view_string(overrides?: TransactionOverrides): Promise<string>;
+
+  "view_string()"(overrides?: TransactionOverrides): Promise<string>;
+
+  view_struct(
+    overrides?: TransactionOverrides
+  ): Promise<{
+    uint256_0: BigNumber;
+    uint256_1: BigNumber;
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
+  "view_struct()"(
+    overrides?: TransactionOverrides
+  ): Promise<{
+    uint256_0: BigNumber;
+    uint256_1: BigNumber;
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
+  view_tuple(
+    overrides?: TransactionOverrides
+  ): Promise<{
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
+  "view_tuple()"(
+    overrides?: TransactionOverrides
+  ): Promise<{
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
+  view_uint256(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+  "view_uint256()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+  view_uint8(overrides?: TransactionOverrides): Promise<number>;
+
+  "view_uint8()"(overrides?: TransactionOverrides): Promise<number>;
+
+  filters: {};
+
+  estimate: {
+    view_address(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "view_address()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    view_bool(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "view_bool()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    view_bytes(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "view_bytes()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    view_bytes1(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "view_bytes1()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    view_enum(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "view_enum()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    view_int256(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "view_int256()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    view_int8(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "view_int8()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    view_named(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "view_named()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    view_stat_array(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "view_stat_array()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    view_string(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "view_string()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    view_struct(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "view_struct()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    view_tuple(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "view_tuple()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    view_uint256(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "view_uint256()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    view_uint8(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "view_uint8()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+  };
+}
diff --git a/packages/target-ethers-v4-test/types/DataTypesViewFactory.ts b/packages/target-ethers-v4-test/types/DataTypesViewFactory.ts
new file mode 100644
index 000000000..d1a7c9e14
--- /dev/null
+++ b/packages/target-ethers-v4-test/types/DataTypesViewFactory.ts
@@ -0,0 +1,223 @@
+/* Generated by ts-generator ver. 0.0.8 */
+/* tslint:disable */
+
+import { Contract, Signer } from "ethers";
+import { Provider } from "ethers/providers";
+
+import { DataTypesView } from "./DataTypesView";
+
+export class DataTypesViewFactory {
+  static connect(
+    address: string,
+    signerOrProvider: Signer | Provider
+  ): DataTypesView {
+    return new Contract(address, _abi, signerOrProvider) as DataTypesView;
+  }
+}
+
+const _abi = [
+  {
+    inputs: [],
+    name: "view_address",
+    outputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "view_bool",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "view_bytes",
+    outputs: [
+      {
+        internalType: "bytes",
+        name: "",
+        type: "bytes"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "view_bytes1",
+    outputs: [
+      {
+        internalType: "bytes1",
+        name: "",
+        type: "bytes1"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "view_enum",
+    outputs: [
+      {
+        internalType: "enum DataTypesView.Enum1",
+        name: "",
+        type: "uint8"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "view_int256",
+    outputs: [
+      {
+        internalType: "int256",
+        name: "",
+        type: "int256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "view_int8",
+    outputs: [
+      {
+        internalType: "int8",
+        name: "",
+        type: "int8"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "view_named",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "uint256_1",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "uint256_2",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "view_stat_array",
+    outputs: [
+      {
+        internalType: "uint8[3]",
+        name: "",
+        type: "uint8[3]"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "view_string",
+    outputs: [
+      {
+        internalType: "string",
+        name: "",
+        type: "string"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "view_struct",
+    outputs: [
+      {
+        components: [
+          {
+            internalType: "uint256",
+            name: "uint256_0",
+            type: "uint256"
+          },
+          {
+            internalType: "uint256",
+            name: "uint256_1",
+            type: "uint256"
+          }
+        ],
+        internalType: "struct DataTypesView.Struct1",
+        name: "",
+        type: "tuple"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "view_tuple",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "view_uint256",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "view_uint8",
+    outputs: [
+      {
+        internalType: "uint8",
+        name: "",
+        type: "uint8"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  }
+];
diff --git a/packages/target-ethers-v4-test/types/Events.d.ts b/packages/target-ethers-v4-test/types/Events.d.ts
new file mode 100644
index 000000000..67d7469ae
--- /dev/null
+++ b/packages/target-ethers-v4-test/types/Events.d.ts
@@ -0,0 +1,159 @@
+/* Generated by ts-generator ver. 0.0.8 */
+/* tslint:disable */
+
+import { Contract, ContractTransaction, EventFilter, Signer } from "ethers";
+import { Listener, Provider } from "ethers/providers";
+import { Arrayish, BigNumber, BigNumberish, Interface } from "ethers/utils";
+import {
+  TransactionOverrides,
+  TypedEventDescription,
+  TypedFunctionDescription
+} from ".";
+
+interface EventsInterface extends Interface {
+  functions: {
+    emit_anon1: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    emit_event1: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    emit_event2: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    emit_event3: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    emit_event3_overloaded: TypedFunctionDescription<{
+      encode([]: []): string;
+    }>;
+  };
+
+  events: {
+    AnonEvent1: TypedEventDescription<{
+      encodeTopics([value1]: [BigNumberish | null]): string[];
+    }>;
+
+    Event1: TypedEventDescription<{
+      encodeTopics([value1, value2]: [BigNumberish | null, null]): string[];
+    }>;
+
+    Event2: TypedEventDescription<{ encodeTopics([]: [null]): string[] }>;
+
+    Event3: TypedEventDescription<{
+      encodeTopics([value1, value2]: [boolean | null, null]): string[];
+    }>;
+  };
+}
+
+export class Events extends Contract {
+  connect(signerOrProvider: Signer | Provider | string): Events;
+  attach(addressOrName: string): Events;
+  deployed(): Promise<Events>;
+
+  on(event: EventFilter | string, listener: Listener): Events;
+  once(event: EventFilter | string, listener: Listener): Events;
+  addListener(eventName: EventFilter | string, listener: Listener): Events;
+  removeAllListeners(eventName: EventFilter | string): Events;
+  removeListener(eventName: any, listener: Listener): Events;
+
+  interface: EventsInterface;
+
+  functions: {
+    emit_anon1(overrides?: TransactionOverrides): Promise<ContractTransaction>;
+
+    "emit_anon1()"(
+      overrides?: TransactionOverrides
+    ): Promise<ContractTransaction>;
+
+    emit_event1(overrides?: TransactionOverrides): Promise<ContractTransaction>;
+
+    "emit_event1()"(
+      overrides?: TransactionOverrides
+    ): Promise<ContractTransaction>;
+
+    emit_event2(overrides?: TransactionOverrides): Promise<ContractTransaction>;
+
+    "emit_event2()"(
+      overrides?: TransactionOverrides
+    ): Promise<ContractTransaction>;
+
+    emit_event3(overrides?: TransactionOverrides): Promise<ContractTransaction>;
+
+    "emit_event3()"(
+      overrides?: TransactionOverrides
+    ): Promise<ContractTransaction>;
+
+    emit_event3_overloaded(
+      overrides?: TransactionOverrides
+    ): Promise<ContractTransaction>;
+
+    "emit_event3_overloaded()"(
+      overrides?: TransactionOverrides
+    ): Promise<ContractTransaction>;
+  };
+
+  emit_anon1(overrides?: TransactionOverrides): Promise<ContractTransaction>;
+
+  "emit_anon1()"(
+    overrides?: TransactionOverrides
+  ): Promise<ContractTransaction>;
+
+  emit_event1(overrides?: TransactionOverrides): Promise<ContractTransaction>;
+
+  "emit_event1()"(
+    overrides?: TransactionOverrides
+  ): Promise<ContractTransaction>;
+
+  emit_event2(overrides?: TransactionOverrides): Promise<ContractTransaction>;
+
+  "emit_event2()"(
+    overrides?: TransactionOverrides
+  ): Promise<ContractTransaction>;
+
+  emit_event3(overrides?: TransactionOverrides): Promise<ContractTransaction>;
+
+  "emit_event3()"(
+    overrides?: TransactionOverrides
+  ): Promise<ContractTransaction>;
+
+  emit_event3_overloaded(
+    overrides?: TransactionOverrides
+  ): Promise<ContractTransaction>;
+
+  "emit_event3_overloaded()"(
+    overrides?: TransactionOverrides
+  ): Promise<ContractTransaction>;
+
+  filters: {
+    AnonEvent1(value1: BigNumberish | null): EventFilter;
+
+    Event1(value1: BigNumberish | null, value2: null): EventFilter;
+
+    Event2(undefined: null): EventFilter;
+
+    Event3(value1: boolean | null, value2: null): EventFilter;
+  };
+
+  estimate: {
+    emit_anon1(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "emit_anon1()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    emit_event1(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "emit_event1()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    emit_event2(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "emit_event2()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    emit_event3(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "emit_event3()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    emit_event3_overloaded(
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+
+    "emit_event3_overloaded()"(
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+  };
+}
diff --git a/packages/target-ethers-v4-test/types/EventsFactory.ts b/packages/target-ethers-v4-test/types/EventsFactory.ts
new file mode 100644
index 000000000..cec0acf94
--- /dev/null
+++ b/packages/target-ethers-v4-test/types/EventsFactory.ts
@@ -0,0 +1,128 @@
+/* Generated by ts-generator ver. 0.0.8 */
+/* tslint:disable */
+
+import { Contract, Signer } from "ethers";
+import { Provider } from "ethers/providers";
+
+import { Events } from "./Events";
+
+export class EventsFactory {
+  static connect(address: string, signerOrProvider: Signer | Provider): Events {
+    return new Contract(address, _abi, signerOrProvider) as Events;
+  }
+}
+
+const _abi = [
+  {
+    anonymous: true,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "uint256",
+        name: "value1",
+        type: "uint256"
+      }
+    ],
+    name: "AnonEvent1",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "uint256",
+        name: "value1",
+        type: "uint256"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "value2",
+        type: "uint256"
+      }
+    ],
+    name: "Event1",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    name: "Event2",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "bool",
+        name: "value1",
+        type: "bool"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "value2",
+        type: "uint256"
+      }
+    ],
+    name: "Event3",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "uint256",
+        name: "value1",
+        type: "uint256"
+      }
+    ],
+    name: "Event3",
+    type: "event"
+  },
+  {
+    inputs: [],
+    name: "emit_anon1",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "emit_event1",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "emit_event2",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "emit_event3",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "emit_event3_overloaded",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
diff --git a/packages/target-ethers-v4-test/types/NameMangling.d.ts b/packages/target-ethers-v4-test/types/NameMangling.d.ts
new file mode 100644
index 000000000..6c60de7b8
--- /dev/null
+++ b/packages/target-ethers-v4-test/types/NameMangling.d.ts
@@ -0,0 +1,54 @@
+/* Generated by ts-generator ver. 0.0.8 */
+/* tslint:disable */
+
+import { Contract, ContractTransaction, EventFilter, Signer } from "ethers";
+import { Listener, Provider } from "ethers/providers";
+import { Arrayish, BigNumber, BigNumberish, Interface } from "ethers/utils";
+import {
+  TransactionOverrides,
+  TypedEventDescription,
+  TypedFunctionDescription
+} from ".";
+
+interface NameManglingInterface extends Interface {
+  functions: {
+    works: TypedFunctionDescription<{ encode([]: []): string }>;
+  };
+
+  events: {};
+}
+
+export class NameMangling extends Contract {
+  connect(signerOrProvider: Signer | Provider | string): NameMangling;
+  attach(addressOrName: string): NameMangling;
+  deployed(): Promise<NameMangling>;
+
+  on(event: EventFilter | string, listener: Listener): NameMangling;
+  once(event: EventFilter | string, listener: Listener): NameMangling;
+  addListener(
+    eventName: EventFilter | string,
+    listener: Listener
+  ): NameMangling;
+  removeAllListeners(eventName: EventFilter | string): NameMangling;
+  removeListener(eventName: any, listener: Listener): NameMangling;
+
+  interface: NameManglingInterface;
+
+  functions: {
+    works(overrides?: TransactionOverrides): Promise<boolean>;
+
+    "works()"(overrides?: TransactionOverrides): Promise<boolean>;
+  };
+
+  works(overrides?: TransactionOverrides): Promise<boolean>;
+
+  "works()"(overrides?: TransactionOverrides): Promise<boolean>;
+
+  filters: {};
+
+  estimate: {
+    works(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "works()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+  };
+}
diff --git a/packages/target-ethers-v4-test/types/NameManglingFactory.ts b/packages/target-ethers-v4-test/types/NameManglingFactory.ts
new file mode 100644
index 000000000..f2e0b5796
--- /dev/null
+++ b/packages/target-ethers-v4-test/types/NameManglingFactory.ts
@@ -0,0 +1,32 @@
+/* Generated by ts-generator ver. 0.0.8 */
+/* tslint:disable */
+
+import { Contract, Signer } from "ethers";
+import { Provider } from "ethers/providers";
+
+import { NameMangling } from "./NameMangling";
+
+export class NameManglingFactory {
+  static connect(
+    address: string,
+    signerOrProvider: Signer | Provider
+  ): NameMangling {
+    return new Contract(address, _abi, signerOrProvider) as NameMangling;
+  }
+}
+
+const _abi = [
+  {
+    inputs: [],
+    name: "works",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  }
+];
diff --git a/packages/target-ethers-v4-test/types/Overloads.d.ts b/packages/target-ethers-v4-test/types/Overloads.d.ts
new file mode 100644
index 000000000..ecfeecfdc
--- /dev/null
+++ b/packages/target-ethers-v4-test/types/Overloads.d.ts
@@ -0,0 +1,89 @@
+/* Generated by ts-generator ver. 0.0.8 */
+/* tslint:disable */
+
+import { Contract, ContractTransaction, EventFilter, Signer } from "ethers";
+import { Listener, Provider } from "ethers/providers";
+import { Arrayish, BigNumber, BigNumberish, Interface } from "ethers/utils";
+import {
+  TransactionOverrides,
+  TypedEventDescription,
+  TypedFunctionDescription
+} from ".";
+
+interface OverloadsInterface extends Interface {
+  functions: {
+    overload1: TypedFunctionDescription<{
+      encode([input1]: [BigNumberish]): string;
+    }>;
+  };
+
+  events: {};
+}
+
+export class Overloads extends Contract {
+  connect(signerOrProvider: Signer | Provider | string): Overloads;
+  attach(addressOrName: string): Overloads;
+  deployed(): Promise<Overloads>;
+
+  on(event: EventFilter | string, listener: Listener): Overloads;
+  once(event: EventFilter | string, listener: Listener): Overloads;
+  addListener(eventName: EventFilter | string, listener: Listener): Overloads;
+  removeAllListeners(eventName: EventFilter | string): Overloads;
+  removeListener(eventName: any, listener: Listener): Overloads;
+
+  interface: OverloadsInterface;
+
+  functions: {
+    overload1(
+      input1: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+
+    "overload1(int256)"(
+      input1: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+
+    "overload1(uint256,uint256)"(
+      input1: BigNumberish,
+      input2: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+  };
+
+  overload1(
+    input1: BigNumberish,
+    overrides?: TransactionOverrides
+  ): Promise<BigNumber>;
+
+  "overload1(int256)"(
+    input1: BigNumberish,
+    overrides?: TransactionOverrides
+  ): Promise<BigNumber>;
+
+  "overload1(uint256,uint256)"(
+    input1: BigNumberish,
+    input2: BigNumberish,
+    overrides?: TransactionOverrides
+  ): Promise<BigNumber>;
+
+  filters: {};
+
+  estimate: {
+    overload1(
+      input1: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+
+    "overload1(int256)"(
+      input1: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+
+    "overload1(uint256,uint256)"(
+      input1: BigNumberish,
+      input2: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+  };
+}
diff --git a/packages/target-ethers-v4-test/types/OverloadsFactory.ts b/packages/target-ethers-v4-test/types/OverloadsFactory.ts
new file mode 100644
index 000000000..5aa7f5a44
--- /dev/null
+++ b/packages/target-ethers-v4-test/types/OverloadsFactory.ts
@@ -0,0 +1,62 @@
+/* Generated by ts-generator ver. 0.0.8 */
+/* tslint:disable */
+
+import { Contract, Signer } from "ethers";
+import { Provider } from "ethers/providers";
+
+import { Overloads } from "./Overloads";
+
+export class OverloadsFactory {
+  static connect(
+    address: string,
+    signerOrProvider: Signer | Provider
+  ): Overloads {
+    return new Contract(address, _abi, signerOrProvider) as Overloads;
+  }
+}
+
+const _abi = [
+  {
+    inputs: [
+      {
+        internalType: "int256",
+        name: "input1",
+        type: "int256"
+      }
+    ],
+    name: "overload1",
+    outputs: [
+      {
+        internalType: "int256",
+        name: "",
+        type: "int256"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "input1",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "input2",
+        type: "uint256"
+      }
+    ],
+    name: "overload1",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  }
+];
diff --git a/packages/target-ethers-v4-test/types/Payable.d.ts b/packages/target-ethers-v4-test/types/Payable.d.ts
new file mode 100644
index 000000000..e541f05e5
--- /dev/null
+++ b/packages/target-ethers-v4-test/types/Payable.d.ts
@@ -0,0 +1,79 @@
+/* Generated by ts-generator ver. 0.0.8 */
+/* tslint:disable */
+
+import { Contract, ContractTransaction, EventFilter, Signer } from "ethers";
+import { Listener, Provider } from "ethers/providers";
+import { Arrayish, BigNumber, BigNumberish, Interface } from "ethers/utils";
+import {
+  TransactionOverrides,
+  TypedEventDescription,
+  TypedFunctionDescription
+} from ".";
+
+interface PayableInterface extends Interface {
+  functions: {
+    non_payable_func: TypedFunctionDescription<{ encode([]: []): string }>;
+
+    payable_func: TypedFunctionDescription<{ encode([]: []): string }>;
+  };
+
+  events: {};
+}
+
+export class Payable extends Contract {
+  connect(signerOrProvider: Signer | Provider | string): Payable;
+  attach(addressOrName: string): Payable;
+  deployed(): Promise<Payable>;
+
+  on(event: EventFilter | string, listener: Listener): Payable;
+  once(event: EventFilter | string, listener: Listener): Payable;
+  addListener(eventName: EventFilter | string, listener: Listener): Payable;
+  removeAllListeners(eventName: EventFilter | string): Payable;
+  removeListener(eventName: any, listener: Listener): Payable;
+
+  interface: PayableInterface;
+
+  functions: {
+    non_payable_func(
+      overrides?: TransactionOverrides
+    ): Promise<ContractTransaction>;
+
+    "non_payable_func()"(
+      overrides?: TransactionOverrides
+    ): Promise<ContractTransaction>;
+
+    payable_func(
+      overrides?: TransactionOverrides
+    ): Promise<ContractTransaction>;
+
+    "payable_func()"(
+      overrides?: TransactionOverrides
+    ): Promise<ContractTransaction>;
+  };
+
+  non_payable_func(
+    overrides?: TransactionOverrides
+  ): Promise<ContractTransaction>;
+
+  "non_payable_func()"(
+    overrides?: TransactionOverrides
+  ): Promise<ContractTransaction>;
+
+  payable_func(overrides?: TransactionOverrides): Promise<ContractTransaction>;
+
+  "payable_func()"(
+    overrides?: TransactionOverrides
+  ): Promise<ContractTransaction>;
+
+  filters: {};
+
+  estimate: {
+    non_payable_func(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "non_payable_func()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    payable_func(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "payable_func()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+  };
+}
diff --git a/packages/target-ethers-v4-test/types/PayableFactory.ts b/packages/target-ethers-v4-test/types/PayableFactory.ts
new file mode 100644
index 000000000..1fbc7d681
--- /dev/null
+++ b/packages/target-ethers-v4-test/types/PayableFactory.ts
@@ -0,0 +1,33 @@
+/* Generated by ts-generator ver. 0.0.8 */
+/* tslint:disable */
+
+import { Contract, Signer } from "ethers";
+import { Provider } from "ethers/providers";
+
+import { Payable } from "./Payable";
+
+export class PayableFactory {
+  static connect(
+    address: string,
+    signerOrProvider: Signer | Provider
+  ): Payable {
+    return new Contract(address, _abi, signerOrProvider) as Payable;
+  }
+}
+
+const _abi = [
+  {
+    inputs: [],
+    name: "non_payable_func",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "payable_func",
+    outputs: [],
+    stateMutability: "payable",
+    type: "function"
+  }
+];
diff --git a/packages/target-ethers-v4-test/types/index.d.ts b/packages/target-ethers-v4-test/types/index.d.ts
new file mode 100644
index 000000000..66fcc6887
--- /dev/null
+++ b/packages/target-ethers-v4-test/types/index.d.ts
@@ -0,0 +1,28 @@
+/* Generated by ts-generator ver. 0.0.8 */
+/* tslint:disable */
+import {
+  BigNumberish,
+  EventDescription,
+  FunctionDescription
+} from "ethers/utils";
+
+export interface TransactionOverrides {
+  gasLimit?: BigNumberish | Promise<BigNumberish>;
+  gasPrice?: BigNumberish | Promise<BigNumberish>;
+  nonce?: BigNumberish | Promise<BigNumberish>;
+  value?: BigNumberish | Promise<BigNumberish>;
+  from?: string | Promise<string>;
+  chainId?: number | Promise<number>;
+}
+
+export interface TypedEventDescription<
+  T extends Pick<EventDescription, "encodeTopics">
+> extends EventDescription {
+  encodeTopics: T["encodeTopics"];
+}
+
+export interface TypedFunctionDescription<
+  T extends Pick<FunctionDescription, "encode">
+> extends FunctionDescription {
+  encode: T["encode"];
+}
diff --git a/packages/target-ethers-v5-test/types/DataTypesInput.d.ts b/packages/target-ethers-v5-test/types/DataTypesInput.d.ts
new file mode 100644
index 000000000..75afa3bcf
--- /dev/null
+++ b/packages/target-ethers-v5-test/types/DataTypesInput.d.ts
@@ -0,0 +1,868 @@
+/* Generated by ts-generator ver. 0.0.8 */
+/* tslint:disable */
+
+import {
+  ethers,
+  EventFilter,
+  Signer,
+  BigNumber,
+  BigNumberish,
+  PopulatedTransaction
+} from "ethers";
+import {
+  Contract,
+  ContractTransaction,
+  CallOverrides
+} from "@ethersproject/contracts";
+import { BytesLike } from "@ethersproject/bytes";
+import { Listener, Provider } from "@ethersproject/providers";
+import { FunctionFragment, EventFragment, Result } from "@ethersproject/abi";
+
+interface DataTypesInputInterface extends ethers.utils.Interface {
+  functions: {
+    "input_address(address)": FunctionFragment;
+    "input_bool(bool)": FunctionFragment;
+    "input_bytes(bytes)": FunctionFragment;
+    "input_bytes1(bytes1)": FunctionFragment;
+    "input_enum(uint8)": FunctionFragment;
+    "input_int256(int256)": FunctionFragment;
+    "input_int8(int8)": FunctionFragment;
+    "input_stat_array(uint8[3])": FunctionFragment;
+    "input_string(string)": FunctionFragment;
+    "input_struct(tuple)": FunctionFragment;
+    "input_tuple(uint256,uint256)": FunctionFragment;
+    "input_uint256(uint256)": FunctionFragment;
+    "input_uint8(uint8)": FunctionFragment;
+  };
+
+  encodeFunctionData(
+    functionFragment: "input_address",
+    values: [string]
+  ): string;
+  encodeFunctionData(functionFragment: "input_bool", values: [boolean]): string;
+  encodeFunctionData(
+    functionFragment: "input_bytes",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "input_bytes1",
+    values: [BytesLike]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "input_enum",
+    values: [BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "input_int256",
+    values: [BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "input_int8",
+    values: [BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "input_stat_array",
+    values: [BigNumberish[]]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "input_string",
+    values: [string]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "input_struct",
+    values: [{ uint256_0: BigNumberish; uint256_1: BigNumberish }]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "input_tuple",
+    values: [BigNumberish, BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "input_uint256",
+    values: [BigNumberish]
+  ): string;
+  encodeFunctionData(
+    functionFragment: "input_uint8",
+    values: [BigNumberish]
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "input_address",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "input_bool", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "input_bytes",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "input_bytes1",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "input_enum", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "input_int256",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "input_int8", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "input_stat_array",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "input_string",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "input_struct",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "input_tuple",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "input_uint256",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "input_uint8",
+    data: BytesLike
+  ): Result;
+
+  events: {};
+}
+
+export class DataTypesInput extends Contract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  on(event: EventFilter | string, listener: Listener): this;
+  once(event: EventFilter | string, listener: Listener): this;
+  addListener(eventName: EventFilter | string, listener: Listener): this;
+  removeAllListeners(eventName: EventFilter | string): this;
+  removeListener(eventName: any, listener: Listener): this;
+
+  interface: DataTypesInputInterface;
+
+  functions: {
+    input_address(
+      input1: string,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
+
+    "input_address(address)"(
+      input1: string,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
+
+    input_bool(
+      input1: boolean,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: boolean;
+    }>;
+
+    "input_bool(bool)"(
+      input1: boolean,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: boolean;
+    }>;
+
+    input_bytes(
+      input1: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
+
+    "input_bytes(bytes)"(
+      input1: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
+
+    input_bytes1(
+      input1: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
+
+    "input_bytes1(bytes1)"(
+      input1: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
+
+    input_enum(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number;
+    }>;
+
+    "input_enum(uint8)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number;
+    }>;
+
+    input_int256(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+    }>;
+
+    "input_int256(int256)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+    }>;
+
+    input_int8(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number;
+    }>;
+
+    "input_int8(int8)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number;
+    }>;
+
+    input_stat_array(
+      input1: BigNumberish[],
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number[];
+    }>;
+
+    "input_stat_array(uint8[3])"(
+      input1: BigNumberish[],
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number[];
+    }>;
+
+    input_string(
+      input1: string,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
+
+    "input_string(string)"(
+      input1: string,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
+
+    input_struct(
+      input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
+      overrides?: CallOverrides
+    ): Promise<{
+      0: {
+        uint256_0: BigNumber;
+        uint256_1: BigNumber;
+        0: BigNumber;
+        1: BigNumber;
+      };
+    }>;
+
+    "input_struct(tuple)"(
+      input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
+      overrides?: CallOverrides
+    ): Promise<{
+      0: {
+        uint256_0: BigNumber;
+        uint256_1: BigNumber;
+        0: BigNumber;
+        1: BigNumber;
+      };
+    }>;
+
+    input_tuple(
+      input1: BigNumberish,
+      input2: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    "input_tuple(uint256,uint256)"(
+      input1: BigNumberish,
+      input2: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    input_uint256(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+    }>;
+
+    "input_uint256(uint256)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+    }>;
+
+    input_uint8(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number;
+    }>;
+
+    "input_uint8(uint8)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number;
+    }>;
+  };
+
+  input_address(input1: string, overrides?: CallOverrides): Promise<string>;
+
+  "input_address(address)"(
+    input1: string,
+    overrides?: CallOverrides
+  ): Promise<string>;
+
+  input_bool(input1: boolean, overrides?: CallOverrides): Promise<boolean>;
+
+  "input_bool(bool)"(
+    input1: boolean,
+    overrides?: CallOverrides
+  ): Promise<boolean>;
+
+  input_bytes(input1: BytesLike, overrides?: CallOverrides): Promise<string>;
+
+  "input_bytes(bytes)"(
+    input1: BytesLike,
+    overrides?: CallOverrides
+  ): Promise<string>;
+
+  input_bytes1(input1: BytesLike, overrides?: CallOverrides): Promise<string>;
+
+  "input_bytes1(bytes1)"(
+    input1: BytesLike,
+    overrides?: CallOverrides
+  ): Promise<string>;
+
+  input_enum(input1: BigNumberish, overrides?: CallOverrides): Promise<number>;
+
+  "input_enum(uint8)"(
+    input1: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<number>;
+
+  input_int256(
+    input1: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  "input_int256(int256)"(
+    input1: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  input_int8(input1: BigNumberish, overrides?: CallOverrides): Promise<number>;
+
+  "input_int8(int8)"(
+    input1: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<number>;
+
+  input_stat_array(
+    input1: BigNumberish[],
+    overrides?: CallOverrides
+  ): Promise<number[]>;
+
+  "input_stat_array(uint8[3])"(
+    input1: BigNumberish[],
+    overrides?: CallOverrides
+  ): Promise<number[]>;
+
+  input_string(input1: string, overrides?: CallOverrides): Promise<string>;
+
+  "input_string(string)"(
+    input1: string,
+    overrides?: CallOverrides
+  ): Promise<string>;
+
+  input_struct(
+    input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
+    overrides?: CallOverrides
+  ): Promise<{
+    uint256_0: BigNumber;
+    uint256_1: BigNumber;
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
+  "input_struct(tuple)"(
+    input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
+    overrides?: CallOverrides
+  ): Promise<{
+    uint256_0: BigNumber;
+    uint256_1: BigNumber;
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
+  input_tuple(
+    input1: BigNumberish,
+    input2: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<{
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
+  "input_tuple(uint256,uint256)"(
+    input1: BigNumberish,
+    input2: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<{
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
+  input_uint256(
+    input1: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  "input_uint256(uint256)"(
+    input1: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  input_uint8(input1: BigNumberish, overrides?: CallOverrides): Promise<number>;
+
+  "input_uint8(uint8)"(
+    input1: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<number>;
+
+  callStatic: {
+    input_address(input1: string, overrides?: CallOverrides): Promise<string>;
+
+    "input_address(address)"(
+      input1: string,
+      overrides?: CallOverrides
+    ): Promise<string>;
+
+    input_bool(input1: boolean, overrides?: CallOverrides): Promise<boolean>;
+
+    "input_bool(bool)"(
+      input1: boolean,
+      overrides?: CallOverrides
+    ): Promise<boolean>;
+
+    input_bytes(input1: BytesLike, overrides?: CallOverrides): Promise<string>;
+
+    "input_bytes(bytes)"(
+      input1: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<string>;
+
+    input_bytes1(input1: BytesLike, overrides?: CallOverrides): Promise<string>;
+
+    "input_bytes1(bytes1)"(
+      input1: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<string>;
+
+    input_enum(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<number>;
+
+    "input_enum(uint8)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<number>;
+
+    input_int256(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    "input_int256(int256)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    input_int8(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<number>;
+
+    "input_int8(int8)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<number>;
+
+    input_stat_array(
+      input1: BigNumberish[],
+      overrides?: CallOverrides
+    ): Promise<number[]>;
+
+    "input_stat_array(uint8[3])"(
+      input1: BigNumberish[],
+      overrides?: CallOverrides
+    ): Promise<number[]>;
+
+    input_string(input1: string, overrides?: CallOverrides): Promise<string>;
+
+    "input_string(string)"(
+      input1: string,
+      overrides?: CallOverrides
+    ): Promise<string>;
+
+    input_struct(
+      input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
+      overrides?: CallOverrides
+    ): Promise<{
+      uint256_0: BigNumber;
+      uint256_1: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    "input_struct(tuple)"(
+      input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
+      overrides?: CallOverrides
+    ): Promise<{
+      uint256_0: BigNumber;
+      uint256_1: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    input_tuple(
+      input1: BigNumberish,
+      input2: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    "input_tuple(uint256,uint256)"(
+      input1: BigNumberish,
+      input2: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    input_uint256(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    "input_uint256(uint256)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    input_uint8(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<number>;
+
+    "input_uint8(uint8)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<number>;
+  };
+
+  filters: {};
+
+  estimateGas: {
+    input_address(
+      input1: string,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    "input_address(address)"(
+      input1: string,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    input_bool(input1: boolean, overrides?: CallOverrides): Promise<BigNumber>;
+
+    "input_bool(bool)"(
+      input1: boolean,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    input_bytes(
+      input1: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    "input_bytes(bytes)"(
+      input1: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    input_bytes1(
+      input1: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    "input_bytes1(bytes1)"(
+      input1: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    input_enum(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    "input_enum(uint8)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    input_int256(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    "input_int256(int256)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    input_int8(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    "input_int8(int8)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    input_stat_array(
+      input1: BigNumberish[],
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    "input_stat_array(uint8[3])"(
+      input1: BigNumberish[],
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    input_string(input1: string, overrides?: CallOverrides): Promise<BigNumber>;
+
+    "input_string(string)"(
+      input1: string,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    input_struct(
+      input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    "input_struct(tuple)"(
+      input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    input_tuple(
+      input1: BigNumberish,
+      input2: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    "input_tuple(uint256,uint256)"(
+      input1: BigNumberish,
+      input2: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    input_uint256(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    "input_uint256(uint256)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    input_uint8(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    "input_uint8(uint8)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    input_address(
+      input1: string,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    "input_address(address)"(
+      input1: string,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    input_bool(
+      input1: boolean,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    "input_bool(bool)"(
+      input1: boolean,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    input_bytes(
+      input1: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    "input_bytes(bytes)"(
+      input1: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    input_bytes1(
+      input1: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    "input_bytes1(bytes1)"(
+      input1: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    input_enum(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    "input_enum(uint8)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    input_int256(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    "input_int256(int256)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    input_int8(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    "input_int8(int8)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    input_stat_array(
+      input1: BigNumberish[],
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    "input_stat_array(uint8[3])"(
+      input1: BigNumberish[],
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    input_string(
+      input1: string,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    "input_string(string)"(
+      input1: string,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    input_struct(
+      input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    "input_struct(tuple)"(
+      input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    input_tuple(
+      input1: BigNumberish,
+      input2: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    "input_tuple(uint256,uint256)"(
+      input1: BigNumberish,
+      input2: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    input_uint256(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    "input_uint256(uint256)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    input_uint8(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    "input_uint8(uint8)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+  };
+}
diff --git a/packages/target-ethers-v5-test/types/DataTypesInputContract.ts b/packages/target-ethers-v5-test/types/DataTypesInputContract.ts
new file mode 100644
index 000000000..7305cb107
--- /dev/null
+++ b/packages/target-ethers-v5-test/types/DataTypesInputContract.ts
@@ -0,0 +1,300 @@
+/* Generated by ts-generator ver. 0.0.8 */
+/* tslint:disable */
+
+import { Contract, Signer } from "ethers";
+import { Provider } from "@ethersproject/providers";
+
+import { DataTypesInput } from "./DataTypesInput";
+
+export class DataTypesInputFactory {
+  static connect(
+    address: string,
+    signerOrProvider: Signer | Provider
+  ): DataTypesInput {
+    return new Contract(address, _abi, signerOrProvider) as DataTypesInput;
+  }
+}
+
+const _abi = [
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "input1",
+        type: "address"
+      }
+    ],
+    name: "input_address",
+    outputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bool",
+        name: "input1",
+        type: "bool"
+      }
+    ],
+    name: "input_bool",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "input1",
+        type: "bytes"
+      }
+    ],
+    name: "input_bytes",
+    outputs: [
+      {
+        internalType: "bytes",
+        name: "",
+        type: "bytes"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes1",
+        name: "input1",
+        type: "bytes1"
+      }
+    ],
+    name: "input_bytes1",
+    outputs: [
+      {
+        internalType: "bytes1",
+        name: "",
+        type: "bytes1"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "enum DataTypesInput.Enum1",
+        name: "input1",
+        type: "uint8"
+      }
+    ],
+    name: "input_enum",
+    outputs: [
+      {
+        internalType: "enum DataTypesInput.Enum1",
+        name: "",
+        type: "uint8"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "int256",
+        name: "input1",
+        type: "int256"
+      }
+    ],
+    name: "input_int256",
+    outputs: [
+      {
+        internalType: "int256",
+        name: "",
+        type: "int256"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "int8",
+        name: "input1",
+        type: "int8"
+      }
+    ],
+    name: "input_int8",
+    outputs: [
+      {
+        internalType: "int8",
+        name: "",
+        type: "int8"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint8[3]",
+        name: "input1",
+        type: "uint8[3]"
+      }
+    ],
+    name: "input_stat_array",
+    outputs: [
+      {
+        internalType: "uint8[3]",
+        name: "",
+        type: "uint8[3]"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "string",
+        name: "input1",
+        type: "string"
+      }
+    ],
+    name: "input_string",
+    outputs: [
+      {
+        internalType: "string",
+        name: "",
+        type: "string"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        components: [
+          {
+            internalType: "uint256",
+            name: "uint256_0",
+            type: "uint256"
+          },
+          {
+            internalType: "uint256",
+            name: "uint256_1",
+            type: "uint256"
+          }
+        ],
+        internalType: "struct DataTypesInput.Struct1",
+        name: "input1",
+        type: "tuple"
+      }
+    ],
+    name: "input_struct",
+    outputs: [
+      {
+        components: [
+          {
+            internalType: "uint256",
+            name: "uint256_0",
+            type: "uint256"
+          },
+          {
+            internalType: "uint256",
+            name: "uint256_1",
+            type: "uint256"
+          }
+        ],
+        internalType: "struct DataTypesInput.Struct1",
+        name: "",
+        type: "tuple"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "input1",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "input2",
+        type: "uint256"
+      }
+    ],
+    name: "input_tuple",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "input1",
+        type: "uint256"
+      }
+    ],
+    name: "input_uint256",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint8",
+        name: "input1",
+        type: "uint8"
+      }
+    ],
+    name: "input_uint8",
+    outputs: [
+      {
+        internalType: "uint8",
+        name: "",
+        type: "uint8"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  }
+];
diff --git a/packages/target-ethers-v5-test/types/DataTypesPure.d.ts b/packages/target-ethers-v5-test/types/DataTypesPure.d.ts
new file mode 100644
index 000000000..c80486d59
--- /dev/null
+++ b/packages/target-ethers-v5-test/types/DataTypesPure.d.ts
@@ -0,0 +1,636 @@
+/* Generated by ts-generator ver. 0.0.8 */
+/* tslint:disable */
+
+import {
+  ethers,
+  EventFilter,
+  Signer,
+  BigNumber,
+  BigNumberish,
+  PopulatedTransaction
+} from "ethers";
+import {
+  Contract,
+  ContractTransaction,
+  CallOverrides
+} from "@ethersproject/contracts";
+import { BytesLike } from "@ethersproject/bytes";
+import { Listener, Provider } from "@ethersproject/providers";
+import { FunctionFragment, EventFragment, Result } from "@ethersproject/abi";
+
+interface DataTypesPureInterface extends ethers.utils.Interface {
+  functions: {
+    "pure_address()": FunctionFragment;
+    "pure_bool()": FunctionFragment;
+    "pure_bytes()": FunctionFragment;
+    "pure_bytes1()": FunctionFragment;
+    "pure_enum()": FunctionFragment;
+    "pure_int256()": FunctionFragment;
+    "pure_int8()": FunctionFragment;
+    "pure_named()": FunctionFragment;
+    "pure_stat_array()": FunctionFragment;
+    "pure_string()": FunctionFragment;
+    "pure_struct()": FunctionFragment;
+    "pure_tuple()": FunctionFragment;
+    "pure_uint256()": FunctionFragment;
+    "pure_uint8()": FunctionFragment;
+  };
+
+  encodeFunctionData(
+    functionFragment: "pure_address",
+    values?: undefined
+  ): string;
+  encodeFunctionData(functionFragment: "pure_bool", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "pure_bytes",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "pure_bytes1",
+    values?: undefined
+  ): string;
+  encodeFunctionData(functionFragment: "pure_enum", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "pure_int256",
+    values?: undefined
+  ): string;
+  encodeFunctionData(functionFragment: "pure_int8", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "pure_named",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "pure_stat_array",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "pure_string",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "pure_struct",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "pure_tuple",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "pure_uint256",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "pure_uint8",
+    values?: undefined
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "pure_address",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "pure_bool", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "pure_bytes", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "pure_bytes1",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "pure_enum", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "pure_int256",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "pure_int8", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "pure_named", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "pure_stat_array",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "pure_string",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "pure_struct",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "pure_tuple", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "pure_uint256",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "pure_uint8", data: BytesLike): Result;
+
+  events: {};
+}
+
+export class DataTypesPure extends Contract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  on(event: EventFilter | string, listener: Listener): this;
+  once(event: EventFilter | string, listener: Listener): this;
+  addListener(eventName: EventFilter | string, listener: Listener): this;
+  removeAllListeners(eventName: EventFilter | string): this;
+  removeListener(eventName: any, listener: Listener): this;
+
+  interface: DataTypesPureInterface;
+
+  functions: {
+    pure_address(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
+
+    "pure_address()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
+
+    pure_bool(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: boolean;
+    }>;
+
+    "pure_bool()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: boolean;
+    }>;
+
+    pure_bytes(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
+
+    "pure_bytes()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
+
+    pure_bytes1(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
+
+    "pure_bytes1()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
+
+    pure_enum(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number;
+    }>;
+
+    "pure_enum()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number;
+    }>;
+
+    pure_int256(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+    }>;
+
+    "pure_int256()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+    }>;
+
+    pure_int8(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number;
+    }>;
+
+    "pure_int8()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number;
+    }>;
+
+    pure_named(
+      overrides?: CallOverrides
+    ): Promise<{
+      uint256_1: BigNumber;
+      uint256_2: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    "pure_named()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      uint256_1: BigNumber;
+      uint256_2: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    pure_stat_array(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number[];
+    }>;
+
+    "pure_stat_array()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number[];
+    }>;
+
+    pure_string(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
+
+    "pure_string()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
+
+    pure_struct(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: {
+        uint256_0: BigNumber;
+        uint256_1: BigNumber;
+        0: BigNumber;
+        1: BigNumber;
+      };
+    }>;
+
+    "pure_struct()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: {
+        uint256_0: BigNumber;
+        uint256_1: BigNumber;
+        0: BigNumber;
+        1: BigNumber;
+      };
+    }>;
+
+    pure_tuple(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    "pure_tuple()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    pure_uint256(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+    }>;
+
+    "pure_uint256()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+    }>;
+
+    pure_uint8(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number;
+    }>;
+
+    "pure_uint8()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number;
+    }>;
+  };
+
+  pure_address(overrides?: CallOverrides): Promise<string>;
+
+  "pure_address()"(overrides?: CallOverrides): Promise<string>;
+
+  pure_bool(overrides?: CallOverrides): Promise<boolean>;
+
+  "pure_bool()"(overrides?: CallOverrides): Promise<boolean>;
+
+  pure_bytes(overrides?: CallOverrides): Promise<string>;
+
+  "pure_bytes()"(overrides?: CallOverrides): Promise<string>;
+
+  pure_bytes1(overrides?: CallOverrides): Promise<string>;
+
+  "pure_bytes1()"(overrides?: CallOverrides): Promise<string>;
+
+  pure_enum(overrides?: CallOverrides): Promise<number>;
+
+  "pure_enum()"(overrides?: CallOverrides): Promise<number>;
+
+  pure_int256(overrides?: CallOverrides): Promise<BigNumber>;
+
+  "pure_int256()"(overrides?: CallOverrides): Promise<BigNumber>;
+
+  pure_int8(overrides?: CallOverrides): Promise<number>;
+
+  "pure_int8()"(overrides?: CallOverrides): Promise<number>;
+
+  pure_named(
+    overrides?: CallOverrides
+  ): Promise<{
+    uint256_1: BigNumber;
+    uint256_2: BigNumber;
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
+  "pure_named()"(
+    overrides?: CallOverrides
+  ): Promise<{
+    uint256_1: BigNumber;
+    uint256_2: BigNumber;
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
+  pure_stat_array(overrides?: CallOverrides): Promise<number[]>;
+
+  "pure_stat_array()"(overrides?: CallOverrides): Promise<number[]>;
+
+  pure_string(overrides?: CallOverrides): Promise<string>;
+
+  "pure_string()"(overrides?: CallOverrides): Promise<string>;
+
+  pure_struct(
+    overrides?: CallOverrides
+  ): Promise<{
+    uint256_0: BigNumber;
+    uint256_1: BigNumber;
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
+  "pure_struct()"(
+    overrides?: CallOverrides
+  ): Promise<{
+    uint256_0: BigNumber;
+    uint256_1: BigNumber;
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
+  pure_tuple(
+    overrides?: CallOverrides
+  ): Promise<{
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
+  "pure_tuple()"(
+    overrides?: CallOverrides
+  ): Promise<{
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
+  pure_uint256(overrides?: CallOverrides): Promise<BigNumber>;
+
+  "pure_uint256()"(overrides?: CallOverrides): Promise<BigNumber>;
+
+  pure_uint8(overrides?: CallOverrides): Promise<number>;
+
+  "pure_uint8()"(overrides?: CallOverrides): Promise<number>;
+
+  callStatic: {
+    pure_address(overrides?: CallOverrides): Promise<string>;
+
+    "pure_address()"(overrides?: CallOverrides): Promise<string>;
+
+    pure_bool(overrides?: CallOverrides): Promise<boolean>;
+
+    "pure_bool()"(overrides?: CallOverrides): Promise<boolean>;
+
+    pure_bytes(overrides?: CallOverrides): Promise<string>;
+
+    "pure_bytes()"(overrides?: CallOverrides): Promise<string>;
+
+    pure_bytes1(overrides?: CallOverrides): Promise<string>;
+
+    "pure_bytes1()"(overrides?: CallOverrides): Promise<string>;
+
+    pure_enum(overrides?: CallOverrides): Promise<number>;
+
+    "pure_enum()"(overrides?: CallOverrides): Promise<number>;
+
+    pure_int256(overrides?: CallOverrides): Promise<BigNumber>;
+
+    "pure_int256()"(overrides?: CallOverrides): Promise<BigNumber>;
+
+    pure_int8(overrides?: CallOverrides): Promise<number>;
+
+    "pure_int8()"(overrides?: CallOverrides): Promise<number>;
+
+    pure_named(
+      overrides?: CallOverrides
+    ): Promise<{
+      uint256_1: BigNumber;
+      uint256_2: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    "pure_named()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      uint256_1: BigNumber;
+      uint256_2: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    pure_stat_array(overrides?: CallOverrides): Promise<number[]>;
+
+    "pure_stat_array()"(overrides?: CallOverrides): Promise<number[]>;
+
+    pure_string(overrides?: CallOverrides): Promise<string>;
+
+    "pure_string()"(overrides?: CallOverrides): Promise<string>;
+
+    pure_struct(
+      overrides?: CallOverrides
+    ): Promise<{
+      uint256_0: BigNumber;
+      uint256_1: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    "pure_struct()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      uint256_0: BigNumber;
+      uint256_1: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    pure_tuple(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    "pure_tuple()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    pure_uint256(overrides?: CallOverrides): Promise<BigNumber>;
+
+    "pure_uint256()"(overrides?: CallOverrides): Promise<BigNumber>;
+
+    pure_uint8(overrides?: CallOverrides): Promise<number>;
+
+    "pure_uint8()"(overrides?: CallOverrides): Promise<number>;
+  };
+
+  filters: {};
+
+  estimateGas: {
+    pure_address(overrides?: CallOverrides): Promise<BigNumber>;
+
+    "pure_address()"(overrides?: CallOverrides): Promise<BigNumber>;
+
+    pure_bool(overrides?: CallOverrides): Promise<BigNumber>;
+
+    "pure_bool()"(overrides?: CallOverrides): Promise<BigNumber>;
+
+    pure_bytes(overrides?: CallOverrides): Promise<BigNumber>;
+
+    "pure_bytes()"(overrides?: CallOverrides): Promise<BigNumber>;
+
+    pure_bytes1(overrides?: CallOverrides): Promise<BigNumber>;
+
+    "pure_bytes1()"(overrides?: CallOverrides): Promise<BigNumber>;
+
+    pure_enum(overrides?: CallOverrides): Promise<BigNumber>;
+
+    "pure_enum()"(overrides?: CallOverrides): Promise<BigNumber>;
+
+    pure_int256(overrides?: CallOverrides): Promise<BigNumber>;
+
+    "pure_int256()"(overrides?: CallOverrides): Promise<BigNumber>;
+
+    pure_int8(overrides?: CallOverrides): Promise<BigNumber>;
+
+    "pure_int8()"(overrides?: CallOverrides): Promise<BigNumber>;
+
+    pure_named(overrides?: CallOverrides): Promise<BigNumber>;
+
+    "pure_named()"(overrides?: CallOverrides): Promise<BigNumber>;
+
+    pure_stat_array(overrides?: CallOverrides): Promise<BigNumber>;
+
+    "pure_stat_array()"(overrides?: CallOverrides): Promise<BigNumber>;
+
+    pure_string(overrides?: CallOverrides): Promise<BigNumber>;
+
+    "pure_string()"(overrides?: CallOverrides): Promise<BigNumber>;
+
+    pure_struct(overrides?: CallOverrides): Promise<BigNumber>;
+
+    "pure_struct()"(overrides?: CallOverrides): Promise<BigNumber>;
+
+    pure_tuple(overrides?: CallOverrides): Promise<BigNumber>;
+
+    "pure_tuple()"(overrides?: CallOverrides): Promise<BigNumber>;
+
+    pure_uint256(overrides?: CallOverrides): Promise<BigNumber>;
+
+    "pure_uint256()"(overrides?: CallOverrides): Promise<BigNumber>;
+
+    pure_uint8(overrides?: CallOverrides): Promise<BigNumber>;
+
+    "pure_uint8()"(overrides?: CallOverrides): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    pure_address(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    "pure_address()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    pure_bool(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    "pure_bool()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    pure_bytes(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    "pure_bytes()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    pure_bytes1(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    "pure_bytes1()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    pure_enum(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    "pure_enum()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    pure_int256(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    "pure_int256()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    pure_int8(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    "pure_int8()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    pure_named(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    "pure_named()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    pure_stat_array(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    "pure_stat_array()"(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    pure_string(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    "pure_string()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    pure_struct(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    "pure_struct()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    pure_tuple(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    "pure_tuple()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    pure_uint256(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    "pure_uint256()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    pure_uint8(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    "pure_uint8()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+  };
+}
diff --git a/packages/target-ethers-v5-test/types/DataTypesPureContract.ts b/packages/target-ethers-v5-test/types/DataTypesPureContract.ts
new file mode 100644
index 000000000..b42b99a4c
--- /dev/null
+++ b/packages/target-ethers-v5-test/types/DataTypesPureContract.ts
@@ -0,0 +1,223 @@
+/* Generated by ts-generator ver. 0.0.8 */
+/* tslint:disable */
+
+import { Contract, Signer } from "ethers";
+import { Provider } from "@ethersproject/providers";
+
+import { DataTypesPure } from "./DataTypesPure";
+
+export class DataTypesPureFactory {
+  static connect(
+    address: string,
+    signerOrProvider: Signer | Provider
+  ): DataTypesPure {
+    return new Contract(address, _abi, signerOrProvider) as DataTypesPure;
+  }
+}
+
+const _abi = [
+  {
+    inputs: [],
+    name: "pure_address",
+    outputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "pure_bool",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "pure_bytes",
+    outputs: [
+      {
+        internalType: "bytes",
+        name: "",
+        type: "bytes"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "pure_bytes1",
+    outputs: [
+      {
+        internalType: "bytes1",
+        name: "",
+        type: "bytes1"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "pure_enum",
+    outputs: [
+      {
+        internalType: "enum DataTypesPure.Enum1",
+        name: "",
+        type: "uint8"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "pure_int256",
+    outputs: [
+      {
+        internalType: "int256",
+        name: "",
+        type: "int256"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "pure_int8",
+    outputs: [
+      {
+        internalType: "int8",
+        name: "",
+        type: "int8"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "pure_named",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "uint256_1",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "uint256_2",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "pure_stat_array",
+    outputs: [
+      {
+        internalType: "uint8[3]",
+        name: "",
+        type: "uint8[3]"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "pure_string",
+    outputs: [
+      {
+        internalType: "string",
+        name: "",
+        type: "string"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "pure_struct",
+    outputs: [
+      {
+        components: [
+          {
+            internalType: "uint256",
+            name: "uint256_0",
+            type: "uint256"
+          },
+          {
+            internalType: "uint256",
+            name: "uint256_1",
+            type: "uint256"
+          }
+        ],
+        internalType: "struct DataTypesPure.Struct1",
+        name: "",
+        type: "tuple"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "pure_tuple",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "pure_uint256",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "pure_uint8",
+    outputs: [
+      {
+        internalType: "uint8",
+        name: "",
+        type: "uint8"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  }
+];
diff --git a/packages/target-ethers-v5-test/types/DataTypesView.d.ts b/packages/target-ethers-v5-test/types/DataTypesView.d.ts
new file mode 100644
index 000000000..7b7c7214e
--- /dev/null
+++ b/packages/target-ethers-v5-test/types/DataTypesView.d.ts
@@ -0,0 +1,636 @@
+/* Generated by ts-generator ver. 0.0.8 */
+/* tslint:disable */
+
+import {
+  ethers,
+  EventFilter,
+  Signer,
+  BigNumber,
+  BigNumberish,
+  PopulatedTransaction
+} from "ethers";
+import {
+  Contract,
+  ContractTransaction,
+  CallOverrides
+} from "@ethersproject/contracts";
+import { BytesLike } from "@ethersproject/bytes";
+import { Listener, Provider } from "@ethersproject/providers";
+import { FunctionFragment, EventFragment, Result } from "@ethersproject/abi";
+
+interface DataTypesViewInterface extends ethers.utils.Interface {
+  functions: {
+    "view_address()": FunctionFragment;
+    "view_bool()": FunctionFragment;
+    "view_bytes()": FunctionFragment;
+    "view_bytes1()": FunctionFragment;
+    "view_enum()": FunctionFragment;
+    "view_int256()": FunctionFragment;
+    "view_int8()": FunctionFragment;
+    "view_named()": FunctionFragment;
+    "view_stat_array()": FunctionFragment;
+    "view_string()": FunctionFragment;
+    "view_struct()": FunctionFragment;
+    "view_tuple()": FunctionFragment;
+    "view_uint256()": FunctionFragment;
+    "view_uint8()": FunctionFragment;
+  };
+
+  encodeFunctionData(
+    functionFragment: "view_address",
+    values?: undefined
+  ): string;
+  encodeFunctionData(functionFragment: "view_bool", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "view_bytes",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "view_bytes1",
+    values?: undefined
+  ): string;
+  encodeFunctionData(functionFragment: "view_enum", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "view_int256",
+    values?: undefined
+  ): string;
+  encodeFunctionData(functionFragment: "view_int8", values?: undefined): string;
+  encodeFunctionData(
+    functionFragment: "view_named",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "view_stat_array",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "view_string",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "view_struct",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "view_tuple",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "view_uint256",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "view_uint8",
+    values?: undefined
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "view_address",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "view_bool", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "view_bytes", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "view_bytes1",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "view_enum", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "view_int256",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "view_int8", data: BytesLike): Result;
+  decodeFunctionResult(functionFragment: "view_named", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "view_stat_array",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "view_string",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "view_struct",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "view_tuple", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "view_uint256",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(functionFragment: "view_uint8", data: BytesLike): Result;
+
+  events: {};
+}
+
+export class DataTypesView extends Contract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  on(event: EventFilter | string, listener: Listener): this;
+  once(event: EventFilter | string, listener: Listener): this;
+  addListener(eventName: EventFilter | string, listener: Listener): this;
+  removeAllListeners(eventName: EventFilter | string): this;
+  removeListener(eventName: any, listener: Listener): this;
+
+  interface: DataTypesViewInterface;
+
+  functions: {
+    view_address(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
+
+    "view_address()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
+
+    view_bool(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: boolean;
+    }>;
+
+    "view_bool()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: boolean;
+    }>;
+
+    view_bytes(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
+
+    "view_bytes()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
+
+    view_bytes1(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
+
+    "view_bytes1()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
+
+    view_enum(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number;
+    }>;
+
+    "view_enum()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number;
+    }>;
+
+    view_int256(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+    }>;
+
+    "view_int256()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+    }>;
+
+    view_int8(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number;
+    }>;
+
+    "view_int8()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number;
+    }>;
+
+    view_named(
+      overrides?: CallOverrides
+    ): Promise<{
+      uint256_1: BigNumber;
+      uint256_2: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    "view_named()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      uint256_1: BigNumber;
+      uint256_2: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    view_stat_array(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number[];
+    }>;
+
+    "view_stat_array()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number[];
+    }>;
+
+    view_string(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
+
+    "view_string()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
+
+    view_struct(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: {
+        uint256_0: BigNumber;
+        uint256_1: BigNumber;
+        0: BigNumber;
+        1: BigNumber;
+      };
+    }>;
+
+    "view_struct()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: {
+        uint256_0: BigNumber;
+        uint256_1: BigNumber;
+        0: BigNumber;
+        1: BigNumber;
+      };
+    }>;
+
+    view_tuple(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    "view_tuple()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    view_uint256(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+    }>;
+
+    "view_uint256()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+    }>;
+
+    view_uint8(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number;
+    }>;
+
+    "view_uint8()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number;
+    }>;
+  };
+
+  view_address(overrides?: CallOverrides): Promise<string>;
+
+  "view_address()"(overrides?: CallOverrides): Promise<string>;
+
+  view_bool(overrides?: CallOverrides): Promise<boolean>;
+
+  "view_bool()"(overrides?: CallOverrides): Promise<boolean>;
+
+  view_bytes(overrides?: CallOverrides): Promise<string>;
+
+  "view_bytes()"(overrides?: CallOverrides): Promise<string>;
+
+  view_bytes1(overrides?: CallOverrides): Promise<string>;
+
+  "view_bytes1()"(overrides?: CallOverrides): Promise<string>;
+
+  view_enum(overrides?: CallOverrides): Promise<number>;
+
+  "view_enum()"(overrides?: CallOverrides): Promise<number>;
+
+  view_int256(overrides?: CallOverrides): Promise<BigNumber>;
+
+  "view_int256()"(overrides?: CallOverrides): Promise<BigNumber>;
+
+  view_int8(overrides?: CallOverrides): Promise<number>;
+
+  "view_int8()"(overrides?: CallOverrides): Promise<number>;
+
+  view_named(
+    overrides?: CallOverrides
+  ): Promise<{
+    uint256_1: BigNumber;
+    uint256_2: BigNumber;
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
+  "view_named()"(
+    overrides?: CallOverrides
+  ): Promise<{
+    uint256_1: BigNumber;
+    uint256_2: BigNumber;
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
+  view_stat_array(overrides?: CallOverrides): Promise<number[]>;
+
+  "view_stat_array()"(overrides?: CallOverrides): Promise<number[]>;
+
+  view_string(overrides?: CallOverrides): Promise<string>;
+
+  "view_string()"(overrides?: CallOverrides): Promise<string>;
+
+  view_struct(
+    overrides?: CallOverrides
+  ): Promise<{
+    uint256_0: BigNumber;
+    uint256_1: BigNumber;
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
+  "view_struct()"(
+    overrides?: CallOverrides
+  ): Promise<{
+    uint256_0: BigNumber;
+    uint256_1: BigNumber;
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
+  view_tuple(
+    overrides?: CallOverrides
+  ): Promise<{
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
+  "view_tuple()"(
+    overrides?: CallOverrides
+  ): Promise<{
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
+  view_uint256(overrides?: CallOverrides): Promise<BigNumber>;
+
+  "view_uint256()"(overrides?: CallOverrides): Promise<BigNumber>;
+
+  view_uint8(overrides?: CallOverrides): Promise<number>;
+
+  "view_uint8()"(overrides?: CallOverrides): Promise<number>;
+
+  callStatic: {
+    view_address(overrides?: CallOverrides): Promise<string>;
+
+    "view_address()"(overrides?: CallOverrides): Promise<string>;
+
+    view_bool(overrides?: CallOverrides): Promise<boolean>;
+
+    "view_bool()"(overrides?: CallOverrides): Promise<boolean>;
+
+    view_bytes(overrides?: CallOverrides): Promise<string>;
+
+    "view_bytes()"(overrides?: CallOverrides): Promise<string>;
+
+    view_bytes1(overrides?: CallOverrides): Promise<string>;
+
+    "view_bytes1()"(overrides?: CallOverrides): Promise<string>;
+
+    view_enum(overrides?: CallOverrides): Promise<number>;
+
+    "view_enum()"(overrides?: CallOverrides): Promise<number>;
+
+    view_int256(overrides?: CallOverrides): Promise<BigNumber>;
+
+    "view_int256()"(overrides?: CallOverrides): Promise<BigNumber>;
+
+    view_int8(overrides?: CallOverrides): Promise<number>;
+
+    "view_int8()"(overrides?: CallOverrides): Promise<number>;
+
+    view_named(
+      overrides?: CallOverrides
+    ): Promise<{
+      uint256_1: BigNumber;
+      uint256_2: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    "view_named()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      uint256_1: BigNumber;
+      uint256_2: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    view_stat_array(overrides?: CallOverrides): Promise<number[]>;
+
+    "view_stat_array()"(overrides?: CallOverrides): Promise<number[]>;
+
+    view_string(overrides?: CallOverrides): Promise<string>;
+
+    "view_string()"(overrides?: CallOverrides): Promise<string>;
+
+    view_struct(
+      overrides?: CallOverrides
+    ): Promise<{
+      uint256_0: BigNumber;
+      uint256_1: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    "view_struct()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      uint256_0: BigNumber;
+      uint256_1: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    view_tuple(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    "view_tuple()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    view_uint256(overrides?: CallOverrides): Promise<BigNumber>;
+
+    "view_uint256()"(overrides?: CallOverrides): Promise<BigNumber>;
+
+    view_uint8(overrides?: CallOverrides): Promise<number>;
+
+    "view_uint8()"(overrides?: CallOverrides): Promise<number>;
+  };
+
+  filters: {};
+
+  estimateGas: {
+    view_address(overrides?: CallOverrides): Promise<BigNumber>;
+
+    "view_address()"(overrides?: CallOverrides): Promise<BigNumber>;
+
+    view_bool(overrides?: CallOverrides): Promise<BigNumber>;
+
+    "view_bool()"(overrides?: CallOverrides): Promise<BigNumber>;
+
+    view_bytes(overrides?: CallOverrides): Promise<BigNumber>;
+
+    "view_bytes()"(overrides?: CallOverrides): Promise<BigNumber>;
+
+    view_bytes1(overrides?: CallOverrides): Promise<BigNumber>;
+
+    "view_bytes1()"(overrides?: CallOverrides): Promise<BigNumber>;
+
+    view_enum(overrides?: CallOverrides): Promise<BigNumber>;
+
+    "view_enum()"(overrides?: CallOverrides): Promise<BigNumber>;
+
+    view_int256(overrides?: CallOverrides): Promise<BigNumber>;
+
+    "view_int256()"(overrides?: CallOverrides): Promise<BigNumber>;
+
+    view_int8(overrides?: CallOverrides): Promise<BigNumber>;
+
+    "view_int8()"(overrides?: CallOverrides): Promise<BigNumber>;
+
+    view_named(overrides?: CallOverrides): Promise<BigNumber>;
+
+    "view_named()"(overrides?: CallOverrides): Promise<BigNumber>;
+
+    view_stat_array(overrides?: CallOverrides): Promise<BigNumber>;
+
+    "view_stat_array()"(overrides?: CallOverrides): Promise<BigNumber>;
+
+    view_string(overrides?: CallOverrides): Promise<BigNumber>;
+
+    "view_string()"(overrides?: CallOverrides): Promise<BigNumber>;
+
+    view_struct(overrides?: CallOverrides): Promise<BigNumber>;
+
+    "view_struct()"(overrides?: CallOverrides): Promise<BigNumber>;
+
+    view_tuple(overrides?: CallOverrides): Promise<BigNumber>;
+
+    "view_tuple()"(overrides?: CallOverrides): Promise<BigNumber>;
+
+    view_uint256(overrides?: CallOverrides): Promise<BigNumber>;
+
+    "view_uint256()"(overrides?: CallOverrides): Promise<BigNumber>;
+
+    view_uint8(overrides?: CallOverrides): Promise<BigNumber>;
+
+    "view_uint8()"(overrides?: CallOverrides): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    view_address(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    "view_address()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    view_bool(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    "view_bool()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    view_bytes(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    "view_bytes()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    view_bytes1(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    "view_bytes1()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    view_enum(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    "view_enum()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    view_int256(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    "view_int256()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    view_int8(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    "view_int8()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    view_named(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    "view_named()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    view_stat_array(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    "view_stat_array()"(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    view_string(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    "view_string()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    view_struct(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    "view_struct()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    view_tuple(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    "view_tuple()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    view_uint256(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    "view_uint256()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    view_uint8(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    "view_uint8()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+  };
+}
diff --git a/packages/target-ethers-v5-test/types/DataTypesViewContract.ts b/packages/target-ethers-v5-test/types/DataTypesViewContract.ts
new file mode 100644
index 000000000..2140a2f31
--- /dev/null
+++ b/packages/target-ethers-v5-test/types/DataTypesViewContract.ts
@@ -0,0 +1,223 @@
+/* Generated by ts-generator ver. 0.0.8 */
+/* tslint:disable */
+
+import { Contract, Signer } from "ethers";
+import { Provider } from "@ethersproject/providers";
+
+import { DataTypesView } from "./DataTypesView";
+
+export class DataTypesViewFactory {
+  static connect(
+    address: string,
+    signerOrProvider: Signer | Provider
+  ): DataTypesView {
+    return new Contract(address, _abi, signerOrProvider) as DataTypesView;
+  }
+}
+
+const _abi = [
+  {
+    inputs: [],
+    name: "view_address",
+    outputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "view_bool",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "view_bytes",
+    outputs: [
+      {
+        internalType: "bytes",
+        name: "",
+        type: "bytes"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "view_bytes1",
+    outputs: [
+      {
+        internalType: "bytes1",
+        name: "",
+        type: "bytes1"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "view_enum",
+    outputs: [
+      {
+        internalType: "enum DataTypesView.Enum1",
+        name: "",
+        type: "uint8"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "view_int256",
+    outputs: [
+      {
+        internalType: "int256",
+        name: "",
+        type: "int256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "view_int8",
+    outputs: [
+      {
+        internalType: "int8",
+        name: "",
+        type: "int8"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "view_named",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "uint256_1",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "uint256_2",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "view_stat_array",
+    outputs: [
+      {
+        internalType: "uint8[3]",
+        name: "",
+        type: "uint8[3]"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "view_string",
+    outputs: [
+      {
+        internalType: "string",
+        name: "",
+        type: "string"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "view_struct",
+    outputs: [
+      {
+        components: [
+          {
+            internalType: "uint256",
+            name: "uint256_0",
+            type: "uint256"
+          },
+          {
+            internalType: "uint256",
+            name: "uint256_1",
+            type: "uint256"
+          }
+        ],
+        internalType: "struct DataTypesView.Struct1",
+        name: "",
+        type: "tuple"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "view_tuple",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "view_uint256",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "view_uint8",
+    outputs: [
+      {
+        internalType: "uint8",
+        name: "",
+        type: "uint8"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  }
+];
diff --git a/packages/target-ethers-v5-test/types/Events.d.ts b/packages/target-ethers-v5-test/types/Events.d.ts
new file mode 100644
index 000000000..cbeda2009
--- /dev/null
+++ b/packages/target-ethers-v5-test/types/Events.d.ts
@@ -0,0 +1,220 @@
+/* Generated by ts-generator ver. 0.0.8 */
+/* tslint:disable */
+
+import {
+  ethers,
+  EventFilter,
+  Signer,
+  BigNumber,
+  BigNumberish,
+  PopulatedTransaction
+} from "ethers";
+import {
+  Contract,
+  ContractTransaction,
+  Overrides
+} from "@ethersproject/contracts";
+import { BytesLike } from "@ethersproject/bytes";
+import { Listener, Provider } from "@ethersproject/providers";
+import { FunctionFragment, EventFragment, Result } from "@ethersproject/abi";
+
+interface EventsInterface extends ethers.utils.Interface {
+  functions: {
+    "emit_anon1()": FunctionFragment;
+    "emit_event1()": FunctionFragment;
+    "emit_event2()": FunctionFragment;
+    "emit_event3()": FunctionFragment;
+    "emit_event3_overloaded()": FunctionFragment;
+  };
+
+  encodeFunctionData(
+    functionFragment: "emit_anon1",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "emit_event1",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "emit_event2",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "emit_event3",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "emit_event3_overloaded",
+    values?: undefined
+  ): string;
+
+  decodeFunctionResult(functionFragment: "emit_anon1", data: BytesLike): Result;
+  decodeFunctionResult(
+    functionFragment: "emit_event1",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "emit_event2",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "emit_event3",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "emit_event3_overloaded",
+    data: BytesLike
+  ): Result;
+
+  events: {
+    "AnonEvent1(uint256)": EventFragment;
+    "Event1(uint256,uint256)": EventFragment;
+    "Event2(uint256)": EventFragment;
+    "Event3(bool,uint256)": EventFragment;
+  };
+
+  getEvent(nameOrSignatureOrTopic: "AnonEvent1"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "Event1"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "Event2"): EventFragment;
+  getEvent(nameOrSignatureOrTopic: "Event3"): EventFragment;
+}
+
+export class Events extends Contract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  on(event: EventFilter | string, listener: Listener): this;
+  once(event: EventFilter | string, listener: Listener): this;
+  addListener(eventName: EventFilter | string, listener: Listener): this;
+  removeAllListeners(eventName: EventFilter | string): this;
+  removeListener(eventName: any, listener: Listener): this;
+
+  interface: EventsInterface;
+
+  functions: {
+    emit_anon1(overrides?: Overrides): Promise<ContractTransaction>;
+
+    "emit_anon1()"(overrides?: Overrides): Promise<ContractTransaction>;
+
+    emit_event1(overrides?: Overrides): Promise<ContractTransaction>;
+
+    "emit_event1()"(overrides?: Overrides): Promise<ContractTransaction>;
+
+    emit_event2(overrides?: Overrides): Promise<ContractTransaction>;
+
+    "emit_event2()"(overrides?: Overrides): Promise<ContractTransaction>;
+
+    emit_event3(overrides?: Overrides): Promise<ContractTransaction>;
+
+    "emit_event3()"(overrides?: Overrides): Promise<ContractTransaction>;
+
+    emit_event3_overloaded(overrides?: Overrides): Promise<ContractTransaction>;
+
+    "emit_event3_overloaded()"(
+      overrides?: Overrides
+    ): Promise<ContractTransaction>;
+  };
+
+  emit_anon1(overrides?: Overrides): Promise<ContractTransaction>;
+
+  "emit_anon1()"(overrides?: Overrides): Promise<ContractTransaction>;
+
+  emit_event1(overrides?: Overrides): Promise<ContractTransaction>;
+
+  "emit_event1()"(overrides?: Overrides): Promise<ContractTransaction>;
+
+  emit_event2(overrides?: Overrides): Promise<ContractTransaction>;
+
+  "emit_event2()"(overrides?: Overrides): Promise<ContractTransaction>;
+
+  emit_event3(overrides?: Overrides): Promise<ContractTransaction>;
+
+  "emit_event3()"(overrides?: Overrides): Promise<ContractTransaction>;
+
+  emit_event3_overloaded(overrides?: Overrides): Promise<ContractTransaction>;
+
+  "emit_event3_overloaded()"(
+    overrides?: Overrides
+  ): Promise<ContractTransaction>;
+
+  callStatic: {
+    emit_anon1(overrides?: Overrides): Promise<void>;
+
+    "emit_anon1()"(overrides?: Overrides): Promise<void>;
+
+    emit_event1(overrides?: Overrides): Promise<void>;
+
+    "emit_event1()"(overrides?: Overrides): Promise<void>;
+
+    emit_event2(overrides?: Overrides): Promise<void>;
+
+    "emit_event2()"(overrides?: Overrides): Promise<void>;
+
+    emit_event3(overrides?: Overrides): Promise<void>;
+
+    "emit_event3()"(overrides?: Overrides): Promise<void>;
+
+    emit_event3_overloaded(overrides?: Overrides): Promise<void>;
+
+    "emit_event3_overloaded()"(overrides?: Overrides): Promise<void>;
+  };
+
+  filters: {
+    AnonEvent1(value1: BigNumberish | null): EventFilter;
+
+    Event1(value1: BigNumberish | null, value2: null): EventFilter;
+
+    Event2(undefined: null): EventFilter;
+
+    Event3(value1: boolean | null, value2: null): EventFilter;
+  };
+
+  estimateGas: {
+    emit_anon1(overrides?: Overrides): Promise<BigNumber>;
+
+    "emit_anon1()"(overrides?: Overrides): Promise<BigNumber>;
+
+    emit_event1(overrides?: Overrides): Promise<BigNumber>;
+
+    "emit_event1()"(overrides?: Overrides): Promise<BigNumber>;
+
+    emit_event2(overrides?: Overrides): Promise<BigNumber>;
+
+    "emit_event2()"(overrides?: Overrides): Promise<BigNumber>;
+
+    emit_event3(overrides?: Overrides): Promise<BigNumber>;
+
+    "emit_event3()"(overrides?: Overrides): Promise<BigNumber>;
+
+    emit_event3_overloaded(overrides?: Overrides): Promise<BigNumber>;
+
+    "emit_event3_overloaded()"(overrides?: Overrides): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    emit_anon1(overrides?: Overrides): Promise<PopulatedTransaction>;
+
+    "emit_anon1()"(overrides?: Overrides): Promise<PopulatedTransaction>;
+
+    emit_event1(overrides?: Overrides): Promise<PopulatedTransaction>;
+
+    "emit_event1()"(overrides?: Overrides): Promise<PopulatedTransaction>;
+
+    emit_event2(overrides?: Overrides): Promise<PopulatedTransaction>;
+
+    "emit_event2()"(overrides?: Overrides): Promise<PopulatedTransaction>;
+
+    emit_event3(overrides?: Overrides): Promise<PopulatedTransaction>;
+
+    "emit_event3()"(overrides?: Overrides): Promise<PopulatedTransaction>;
+
+    emit_event3_overloaded(
+      overrides?: Overrides
+    ): Promise<PopulatedTransaction>;
+
+    "emit_event3_overloaded()"(
+      overrides?: Overrides
+    ): Promise<PopulatedTransaction>;
+  };
+}
diff --git a/packages/target-ethers-v5-test/types/EventsContract.ts b/packages/target-ethers-v5-test/types/EventsContract.ts
new file mode 100644
index 000000000..b9c613478
--- /dev/null
+++ b/packages/target-ethers-v5-test/types/EventsContract.ts
@@ -0,0 +1,128 @@
+/* Generated by ts-generator ver. 0.0.8 */
+/* tslint:disable */
+
+import { Contract, Signer } from "ethers";
+import { Provider } from "@ethersproject/providers";
+
+import { Events } from "./Events";
+
+export class EventsFactory {
+  static connect(address: string, signerOrProvider: Signer | Provider): Events {
+    return new Contract(address, _abi, signerOrProvider) as Events;
+  }
+}
+
+const _abi = [
+  {
+    anonymous: true,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "uint256",
+        name: "value1",
+        type: "uint256"
+      }
+    ],
+    name: "AnonEvent1",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "uint256",
+        name: "value1",
+        type: "uint256"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "value2",
+        type: "uint256"
+      }
+    ],
+    name: "Event1",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    name: "Event2",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "bool",
+        name: "value1",
+        type: "bool"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "value2",
+        type: "uint256"
+      }
+    ],
+    name: "Event3",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "uint256",
+        name: "value1",
+        type: "uint256"
+      }
+    ],
+    name: "Event3",
+    type: "event"
+  },
+  {
+    inputs: [],
+    name: "emit_anon1",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "emit_event1",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "emit_event2",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "emit_event3",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "emit_event3_overloaded",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
diff --git a/packages/target-ethers-v5-test/types/NameMangling.d.ts b/packages/target-ethers-v5-test/types/NameMangling.d.ts
new file mode 100644
index 000000000..ac2abd352
--- /dev/null
+++ b/packages/target-ethers-v5-test/types/NameMangling.d.ts
@@ -0,0 +1,83 @@
+/* Generated by ts-generator ver. 0.0.8 */
+/* tslint:disable */
+
+import {
+  ethers,
+  EventFilter,
+  Signer,
+  BigNumber,
+  BigNumberish,
+  PopulatedTransaction
+} from "ethers";
+import {
+  Contract,
+  ContractTransaction,
+  CallOverrides
+} from "@ethersproject/contracts";
+import { BytesLike } from "@ethersproject/bytes";
+import { Listener, Provider } from "@ethersproject/providers";
+import { FunctionFragment, EventFragment, Result } from "@ethersproject/abi";
+
+interface NameManglingInterface extends ethers.utils.Interface {
+  functions: {
+    "works()": FunctionFragment;
+  };
+
+  encodeFunctionData(functionFragment: "works", values?: undefined): string;
+
+  decodeFunctionResult(functionFragment: "works", data: BytesLike): Result;
+
+  events: {};
+}
+
+export class NameMangling extends Contract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  on(event: EventFilter | string, listener: Listener): this;
+  once(event: EventFilter | string, listener: Listener): this;
+  addListener(eventName: EventFilter | string, listener: Listener): this;
+  removeAllListeners(eventName: EventFilter | string): this;
+  removeListener(eventName: any, listener: Listener): this;
+
+  interface: NameManglingInterface;
+
+  functions: {
+    works(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: boolean;
+    }>;
+
+    "works()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: boolean;
+    }>;
+  };
+
+  works(overrides?: CallOverrides): Promise<boolean>;
+
+  "works()"(overrides?: CallOverrides): Promise<boolean>;
+
+  callStatic: {
+    works(overrides?: CallOverrides): Promise<boolean>;
+
+    "works()"(overrides?: CallOverrides): Promise<boolean>;
+  };
+
+  filters: {};
+
+  estimateGas: {
+    works(overrides?: CallOverrides): Promise<BigNumber>;
+
+    "works()"(overrides?: CallOverrides): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    works(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    "works()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+  };
+}
diff --git a/packages/target-ethers-v5-test/types/NameManglingContract.ts b/packages/target-ethers-v5-test/types/NameManglingContract.ts
new file mode 100644
index 000000000..af158f2a5
--- /dev/null
+++ b/packages/target-ethers-v5-test/types/NameManglingContract.ts
@@ -0,0 +1,32 @@
+/* Generated by ts-generator ver. 0.0.8 */
+/* tslint:disable */
+
+import { Contract, Signer } from "ethers";
+import { Provider } from "@ethersproject/providers";
+
+import { NameMangling } from "./NameMangling";
+
+export class NameManglingFactory {
+  static connect(
+    address: string,
+    signerOrProvider: Signer | Provider
+  ): NameMangling {
+    return new Contract(address, _abi, signerOrProvider) as NameMangling;
+  }
+}
+
+const _abi = [
+  {
+    inputs: [],
+    name: "works",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  }
+];
diff --git a/packages/target-ethers-v5-test/types/Overloads.d.ts b/packages/target-ethers-v5-test/types/Overloads.d.ts
new file mode 100644
index 000000000..ad3e8a940
--- /dev/null
+++ b/packages/target-ethers-v5-test/types/Overloads.d.ts
@@ -0,0 +1,117 @@
+/* Generated by ts-generator ver. 0.0.8 */
+/* tslint:disable */
+
+import {
+  ethers,
+  EventFilter,
+  Signer,
+  BigNumber,
+  BigNumberish,
+  PopulatedTransaction
+} from "ethers";
+import {
+  Contract,
+  ContractTransaction,
+  CallOverrides
+} from "@ethersproject/contracts";
+import { BytesLike } from "@ethersproject/bytes";
+import { Listener, Provider } from "@ethersproject/providers";
+import { FunctionFragment, EventFragment, Result } from "@ethersproject/abi";
+
+interface OverloadsInterface extends ethers.utils.Interface {
+  functions: {
+    "overload1(int256)": FunctionFragment;
+  };
+
+  encodeFunctionData(
+    functionFragment: "overload1",
+    values: [BigNumberish]
+  ): string;
+
+  decodeFunctionResult(functionFragment: "overload1", data: BytesLike): Result;
+
+  events: {};
+}
+
+export class Overloads extends Contract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  on(event: EventFilter | string, listener: Listener): this;
+  once(event: EventFilter | string, listener: Listener): this;
+  addListener(eventName: EventFilter | string, listener: Listener): this;
+  removeAllListeners(eventName: EventFilter | string): this;
+  removeListener(eventName: any, listener: Listener): this;
+
+  interface: OverloadsInterface;
+
+  functions: {
+    "overload1(int256)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+    }>;
+
+    "overload1(uint256,uint256)"(
+      input1: BigNumberish,
+      input2: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+    }>;
+  };
+
+  "overload1(int256)"(
+    input1: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  "overload1(uint256,uint256)"(
+    input1: BigNumberish,
+    input2: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
+  callStatic: {
+    "overload1(int256)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    "overload1(uint256,uint256)"(
+      input1: BigNumberish,
+      input2: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+  };
+
+  filters: {};
+
+  estimateGas: {
+    "overload1(int256)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
+    "overload1(uint256,uint256)"(
+      input1: BigNumberish,
+      input2: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    "overload1(int256)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
+    "overload1(uint256,uint256)"(
+      input1: BigNumberish,
+      input2: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+  };
+}
diff --git a/packages/target-ethers-v5-test/types/OverloadsContract.ts b/packages/target-ethers-v5-test/types/OverloadsContract.ts
new file mode 100644
index 000000000..9abb149e9
--- /dev/null
+++ b/packages/target-ethers-v5-test/types/OverloadsContract.ts
@@ -0,0 +1,62 @@
+/* Generated by ts-generator ver. 0.0.8 */
+/* tslint:disable */
+
+import { Contract, Signer } from "ethers";
+import { Provider } from "@ethersproject/providers";
+
+import { Overloads } from "./Overloads";
+
+export class OverloadsFactory {
+  static connect(
+    address: string,
+    signerOrProvider: Signer | Provider
+  ): Overloads {
+    return new Contract(address, _abi, signerOrProvider) as Overloads;
+  }
+}
+
+const _abi = [
+  {
+    inputs: [
+      {
+        internalType: "int256",
+        name: "input1",
+        type: "int256"
+      }
+    ],
+    name: "overload1",
+    outputs: [
+      {
+        internalType: "int256",
+        name: "",
+        type: "int256"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "input1",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "input2",
+        type: "uint256"
+      }
+    ],
+    name: "overload1",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "pure",
+    type: "function"
+  }
+];
diff --git a/packages/target-ethers-v5-test/types/Payable.d.ts b/packages/target-ethers-v5-test/types/Payable.d.ts
new file mode 100644
index 000000000..3054174ef
--- /dev/null
+++ b/packages/target-ethers-v5-test/types/Payable.d.ts
@@ -0,0 +1,115 @@
+/* Generated by ts-generator ver. 0.0.8 */
+/* tslint:disable */
+
+import {
+  ethers,
+  EventFilter,
+  Signer,
+  BigNumber,
+  BigNumberish,
+  PopulatedTransaction
+} from "ethers";
+import {
+  Contract,
+  ContractTransaction,
+  Overrides,
+  PayableOverrides
+} from "@ethersproject/contracts";
+import { BytesLike } from "@ethersproject/bytes";
+import { Listener, Provider } from "@ethersproject/providers";
+import { FunctionFragment, EventFragment, Result } from "@ethersproject/abi";
+
+interface PayableInterface extends ethers.utils.Interface {
+  functions: {
+    "non_payable_func()": FunctionFragment;
+    "payable_func()": FunctionFragment;
+  };
+
+  encodeFunctionData(
+    functionFragment: "non_payable_func",
+    values?: undefined
+  ): string;
+  encodeFunctionData(
+    functionFragment: "payable_func",
+    values?: undefined
+  ): string;
+
+  decodeFunctionResult(
+    functionFragment: "non_payable_func",
+    data: BytesLike
+  ): Result;
+  decodeFunctionResult(
+    functionFragment: "payable_func",
+    data: BytesLike
+  ): Result;
+
+  events: {};
+}
+
+export class Payable extends Contract {
+  connect(signerOrProvider: Signer | Provider | string): this;
+  attach(addressOrName: string): this;
+  deployed(): Promise<this>;
+
+  on(event: EventFilter | string, listener: Listener): this;
+  once(event: EventFilter | string, listener: Listener): this;
+  addListener(eventName: EventFilter | string, listener: Listener): this;
+  removeAllListeners(eventName: EventFilter | string): this;
+  removeListener(eventName: any, listener: Listener): this;
+
+  interface: PayableInterface;
+
+  functions: {
+    non_payable_func(overrides?: Overrides): Promise<ContractTransaction>;
+
+    "non_payable_func()"(overrides?: Overrides): Promise<ContractTransaction>;
+
+    payable_func(overrides?: PayableOverrides): Promise<ContractTransaction>;
+
+    "payable_func()"(
+      overrides?: PayableOverrides
+    ): Promise<ContractTransaction>;
+  };
+
+  non_payable_func(overrides?: Overrides): Promise<ContractTransaction>;
+
+  "non_payable_func()"(overrides?: Overrides): Promise<ContractTransaction>;
+
+  payable_func(overrides?: PayableOverrides): Promise<ContractTransaction>;
+
+  "payable_func()"(overrides?: PayableOverrides): Promise<ContractTransaction>;
+
+  callStatic: {
+    non_payable_func(overrides?: Overrides): Promise<void>;
+
+    "non_payable_func()"(overrides?: Overrides): Promise<void>;
+
+    payable_func(overrides?: PayableOverrides): Promise<void>;
+
+    "payable_func()"(overrides?: PayableOverrides): Promise<void>;
+  };
+
+  filters: {};
+
+  estimateGas: {
+    non_payable_func(overrides?: Overrides): Promise<BigNumber>;
+
+    "non_payable_func()"(overrides?: Overrides): Promise<BigNumber>;
+
+    payable_func(overrides?: PayableOverrides): Promise<BigNumber>;
+
+    "payable_func()"(overrides?: PayableOverrides): Promise<BigNumber>;
+  };
+
+  populateTransaction: {
+    non_payable_func(overrides?: Overrides): Promise<PopulatedTransaction>;
+
+    "non_payable_func()"(overrides?: Overrides): Promise<PopulatedTransaction>;
+
+    payable_func(overrides?: PayableOverrides): Promise<PopulatedTransaction>;
+
+    "payable_func()"(
+      overrides?: PayableOverrides
+    ): Promise<PopulatedTransaction>;
+  };
+}
diff --git a/packages/target-ethers-v5-test/types/PayableContract.ts b/packages/target-ethers-v5-test/types/PayableContract.ts
new file mode 100644
index 000000000..dd9dbf766
--- /dev/null
+++ b/packages/target-ethers-v5-test/types/PayableContract.ts
@@ -0,0 +1,33 @@
+/* Generated by ts-generator ver. 0.0.8 */
+/* tslint:disable */
+
+import { Contract, Signer } from "ethers";
+import { Provider } from "@ethersproject/providers";
+
+import { Payable } from "./Payable";
+
+export class PayableFactory {
+  static connect(
+    address: string,
+    signerOrProvider: Signer | Provider
+  ): Payable {
+    return new Contract(address, _abi, signerOrProvider) as Payable;
+  }
+}
+
+const _abi = [
+  {
+    inputs: [],
+    name: "non_payable_func",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "payable_func",
+    outputs: [],
+    stateMutability: "payable",
+    type: "function"
+  }
+];
diff --git a/packages/target-ethers-v5-test/types/index.ts b/packages/target-ethers-v5-test/types/index.ts
new file mode 100644
index 000000000..ce9f1dac4
--- /dev/null
+++ b/packages/target-ethers-v5-test/types/index.ts
@@ -0,0 +1,2 @@
+/* Generated by ts-generator ver. 0.0.8 */
+/* tslint:disable */

From b28e7d6e6a0ac465fecb2bf2e26c465f37800a62 Mon Sep 17 00:00:00 2001
From: Braden Napier <bradynapier+github@gmail.com>
Date: Thu, 9 Jul 2020 05:06:44 -0400
Subject: [PATCH 49/64] Update
 packages/target-ethers-v5/src/codegen/functions.ts

per @zemse review
---
 packages/target-ethers-v5/src/codegen/functions.ts | 4 +---
 1 file changed, 1 insertion(+), 3 deletions(-)

diff --git a/packages/target-ethers-v5/src/codegen/functions.ts b/packages/target-ethers-v5/src/codegen/functions.ts
index 8ea677260..72df31494 100644
--- a/packages/target-ethers-v5/src/codegen/functions.ts
+++ b/packages/target-ethers-v5/src/codegen/functions.ts
@@ -31,9 +31,7 @@ function generateFunction(options: GenerateFunctionOptions, fn: FunctionDeclarat
       ? `overrides?: ${isPayable(fn) ? 'PayableOverrides' : 'Overrides'}`
       : 'overrides?: CallOverrides'
   }): ${
-    options.overrideOutput
-      ? options.overrideOutput
-      : `Promise<${
+    options.overrideOutput ?? `Promise<${
           options.isStaticCall || fn.stateMutability === 'pure' || fn.stateMutability === 'view'
             ? generateOutputTypes(!!options.returnResultObject, fn.outputs)
             : 'ContractTransaction'

From baa964f4f28460f9d396cb8aeea0fa61a257f3e9 Mon Sep 17 00:00:00 2001
From: Braden Napier <brady.napier@dashos.net>
Date: Thu, 9 Jul 2020 05:11:40 -0400
Subject: [PATCH 50/64] fix: prettier on the suggestion commit

---
 .../types/DataTypesInput.d.ts                 | 425 +++++++++++++++---
 .../types/DataTypesPure.d.ts                  | 218 +++++++--
 .../types/DataTypesView.d.ts                  | 218 +++++++--
 .../target-ethers-v4-test/types/Events.d.ts   |  64 ++-
 .../types/NameMangling.d.ts                   |  12 +-
 .../types/Overloads.d.ts                      |  42 +-
 .../target-ethers-v4-test/types/Payable.d.ts  |  24 +-
 .../types/DataTypesInput.d.ts                 | 378 ++++++++++++++++
 .../types/DataTypesPure.d.ts                  | 245 ++++++++++
 .../types/DataTypesView.d.ts                  | 245 ++++++++++
 .../target-ethers-v5-test/types/Events.d.ts   |  56 +++
 .../types/NameMangling.d.ts                   |  14 +
 .../target-ethers-v5-test/types/Payable.d.ts  |  24 +
 .../target-ethers-v5/src/codegen/functions.ts |  11 +-
 14 files changed, 1819 insertions(+), 157 deletions(-)

diff --git a/packages/target-ethers-v4-test/types/DataTypesInput.d.ts b/packages/target-ethers-v4-test/types/DataTypesInput.d.ts
index 6ab731907..572887d63 100644
--- a/packages/target-ethers-v4-test/types/DataTypesInput.d.ts
+++ b/packages/target-ethers-v4-test/types/DataTypesInput.d.ts
@@ -87,28 +87,110 @@ export class DataTypesInput extends Contract {
   interface: DataTypesInputInterface;
 
   functions: {
-    input_address(input1: string): Promise<string>;
-
-    input_bool(input1: boolean): Promise<boolean>;
-
-    input_bytes(input1: Arrayish): Promise<string>;
-
-    input_bytes1(input1: Arrayish): Promise<string>;
+    input_address(
+      input1: string,
+      overrides?: TransactionOverrides
+    ): Promise<string>;
+
+    "input_address(address)"(
+      input1: string,
+      overrides?: TransactionOverrides
+    ): Promise<string>;
+
+    input_bool(
+      input1: boolean,
+      overrides?: TransactionOverrides
+    ): Promise<boolean>;
+
+    "input_bool(bool)"(
+      input1: boolean,
+      overrides?: TransactionOverrides
+    ): Promise<boolean>;
+
+    input_bytes(
+      input1: Arrayish,
+      overrides?: TransactionOverrides
+    ): Promise<string>;
+
+    "input_bytes(bytes)"(
+      input1: Arrayish,
+      overrides?: TransactionOverrides
+    ): Promise<string>;
+
+    input_bytes1(
+      input1: Arrayish,
+      overrides?: TransactionOverrides
+    ): Promise<string>;
+
+    "input_bytes1(bytes1)"(
+      input1: Arrayish,
+      overrides?: TransactionOverrides
+    ): Promise<string>;
+
+    input_enum(
+      input1: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<number>;
 
-    input_enum(input1: BigNumberish): Promise<number>;
+    "input_enum(uint8)"(
+      input1: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<number>;
 
-    input_int256(input1: BigNumberish): Promise<BigNumber>;
+    input_int256(
+      input1: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
 
-    input_int8(input1: BigNumberish): Promise<number>;
+    "input_int256(int256)"(
+      input1: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
 
-    input_stat_array(input1: BigNumberish[]): Promise<number[]>;
+    input_int8(
+      input1: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<number>;
 
-    input_string(input1: string): Promise<string>;
+    "input_int8(int8)"(
+      input1: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<number>;
+
+    input_stat_array(
+      input1: BigNumberish[],
+      overrides?: TransactionOverrides
+    ): Promise<number[]>;
+
+    "input_stat_array(uint8[3])"(
+      input1: BigNumberish[],
+      overrides?: TransactionOverrides
+    ): Promise<number[]>;
+
+    input_string(
+      input1: string,
+      overrides?: TransactionOverrides
+    ): Promise<string>;
+
+    "input_string(string)"(
+      input1: string,
+      overrides?: TransactionOverrides
+    ): Promise<string>;
+
+    input_struct(
+      input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
+      overrides?: TransactionOverrides
+    ): Promise<{
+      uint256_0: BigNumber;
+      uint256_1: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
 
-    input_struct(input1: {
-      uint256_0: BigNumberish;
-      uint256_1: BigNumberish;
-    }): Promise<{
+    "input_struct(tuple)"(
+      input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
+      overrides?: TransactionOverrides
+    ): Promise<{
       uint256_0: BigNumber;
       uint256_1: BigNumber;
       0: BigNumber;
@@ -117,39 +199,147 @@ export class DataTypesInput extends Contract {
 
     input_tuple(
       input1: BigNumberish,
-      input2: BigNumberish
+      input2: BigNumberish,
+      overrides?: TransactionOverrides
     ): Promise<{
       0: BigNumber;
       1: BigNumber;
     }>;
 
-    input_uint256(input1: BigNumberish): Promise<BigNumber>;
+    "input_tuple(uint256,uint256)"(
+      input1: BigNumberish,
+      input2: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<{
+      0: BigNumber;
+      1: BigNumber;
+    }>;
 
-    input_uint8(input1: BigNumberish): Promise<number>;
-  };
+    input_uint256(
+      input1: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
 
-  input_address(input1: string): Promise<string>;
+    "input_uint256(uint256)"(
+      input1: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
 
-  input_bool(input1: boolean): Promise<boolean>;
+    input_uint8(
+      input1: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<number>;
 
-  input_bytes(input1: Arrayish): Promise<string>;
+    "input_uint8(uint8)"(
+      input1: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<number>;
+  };
 
-  input_bytes1(input1: Arrayish): Promise<string>;
+  input_address(
+    input1: string,
+    overrides?: TransactionOverrides
+  ): Promise<string>;
+
+  "input_address(address)"(
+    input1: string,
+    overrides?: TransactionOverrides
+  ): Promise<string>;
+
+  input_bool(
+    input1: boolean,
+    overrides?: TransactionOverrides
+  ): Promise<boolean>;
+
+  "input_bool(bool)"(
+    input1: boolean,
+    overrides?: TransactionOverrides
+  ): Promise<boolean>;
+
+  input_bytes(
+    input1: Arrayish,
+    overrides?: TransactionOverrides
+  ): Promise<string>;
+
+  "input_bytes(bytes)"(
+    input1: Arrayish,
+    overrides?: TransactionOverrides
+  ): Promise<string>;
+
+  input_bytes1(
+    input1: Arrayish,
+    overrides?: TransactionOverrides
+  ): Promise<string>;
+
+  "input_bytes1(bytes1)"(
+    input1: Arrayish,
+    overrides?: TransactionOverrides
+  ): Promise<string>;
+
+  input_enum(
+    input1: BigNumberish,
+    overrides?: TransactionOverrides
+  ): Promise<number>;
 
-  input_enum(input1: BigNumberish): Promise<number>;
+  "input_enum(uint8)"(
+    input1: BigNumberish,
+    overrides?: TransactionOverrides
+  ): Promise<number>;
 
-  input_int256(input1: BigNumberish): Promise<BigNumber>;
+  input_int256(
+    input1: BigNumberish,
+    overrides?: TransactionOverrides
+  ): Promise<BigNumber>;
 
-  input_int8(input1: BigNumberish): Promise<number>;
+  "input_int256(int256)"(
+    input1: BigNumberish,
+    overrides?: TransactionOverrides
+  ): Promise<BigNumber>;
 
-  input_stat_array(input1: BigNumberish[]): Promise<number[]>;
+  input_int8(
+    input1: BigNumberish,
+    overrides?: TransactionOverrides
+  ): Promise<number>;
 
-  input_string(input1: string): Promise<string>;
+  "input_int8(int8)"(
+    input1: BigNumberish,
+    overrides?: TransactionOverrides
+  ): Promise<number>;
+
+  input_stat_array(
+    input1: BigNumberish[],
+    overrides?: TransactionOverrides
+  ): Promise<number[]>;
+
+  "input_stat_array(uint8[3])"(
+    input1: BigNumberish[],
+    overrides?: TransactionOverrides
+  ): Promise<number[]>;
+
+  input_string(
+    input1: string,
+    overrides?: TransactionOverrides
+  ): Promise<string>;
+
+  "input_string(string)"(
+    input1: string,
+    overrides?: TransactionOverrides
+  ): Promise<string>;
+
+  input_struct(
+    input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
+    overrides?: TransactionOverrides
+  ): Promise<{
+    uint256_0: BigNumber;
+    uint256_1: BigNumber;
+    0: BigNumber;
+    1: BigNumber;
+  }>;
 
-  input_struct(input1: {
-    uint256_0: BigNumberish;
-    uint256_1: BigNumberish;
-  }): Promise<{
+  "input_struct(tuple)"(
+    input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
+    overrides?: TransactionOverrides
+  ): Promise<{
     uint256_0: BigNumber;
     uint256_1: BigNumber;
     0: BigNumber;
@@ -158,46 +348,175 @@ export class DataTypesInput extends Contract {
 
   input_tuple(
     input1: BigNumberish,
-    input2: BigNumberish
+    input2: BigNumberish,
+    overrides?: TransactionOverrides
   ): Promise<{
     0: BigNumber;
     1: BigNumber;
   }>;
 
-  input_uint256(input1: BigNumberish): Promise<BigNumber>;
+  "input_tuple(uint256,uint256)"(
+    input1: BigNumberish,
+    input2: BigNumberish,
+    overrides?: TransactionOverrides
+  ): Promise<{
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
+  input_uint256(
+    input1: BigNumberish,
+    overrides?: TransactionOverrides
+  ): Promise<BigNumber>;
+
+  "input_uint256(uint256)"(
+    input1: BigNumberish,
+    overrides?: TransactionOverrides
+  ): Promise<BigNumber>;
 
-  input_uint8(input1: BigNumberish): Promise<number>;
+  input_uint8(
+    input1: BigNumberish,
+    overrides?: TransactionOverrides
+  ): Promise<number>;
+
+  "input_uint8(uint8)"(
+    input1: BigNumberish,
+    overrides?: TransactionOverrides
+  ): Promise<number>;
 
   filters: {};
 
   estimate: {
-    input_address(input1: string): Promise<BigNumber>;
-
-    input_bool(input1: boolean): Promise<BigNumber>;
+    input_address(
+      input1: string,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+
+    "input_address(address)"(
+      input1: string,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+
+    input_bool(
+      input1: boolean,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+
+    "input_bool(bool)"(
+      input1: boolean,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+
+    input_bytes(
+      input1: Arrayish,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+
+    "input_bytes(bytes)"(
+      input1: Arrayish,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+
+    input_bytes1(
+      input1: Arrayish,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+
+    "input_bytes1(bytes1)"(
+      input1: Arrayish,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+
+    input_enum(
+      input1: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
 
-    input_bytes(input1: Arrayish): Promise<BigNumber>;
+    "input_enum(uint8)"(
+      input1: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
 
-    input_bytes1(input1: Arrayish): Promise<BigNumber>;
+    input_int256(
+      input1: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
 
-    input_enum(input1: BigNumberish): Promise<BigNumber>;
+    "input_int256(int256)"(
+      input1: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
 
-    input_int256(input1: BigNumberish): Promise<BigNumber>;
+    input_int8(
+      input1: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
 
-    input_int8(input1: BigNumberish): Promise<BigNumber>;
+    "input_int8(int8)"(
+      input1: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+
+    input_stat_array(
+      input1: BigNumberish[],
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+
+    "input_stat_array(uint8[3])"(
+      input1: BigNumberish[],
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+
+    input_string(
+      input1: string,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+
+    "input_string(string)"(
+      input1: string,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+
+    input_struct(
+      input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+
+    "input_struct(tuple)"(
+      input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
 
-    input_stat_array(input1: BigNumberish[]): Promise<BigNumber>;
+    input_tuple(
+      input1: BigNumberish,
+      input2: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
 
-    input_string(input1: string): Promise<BigNumber>;
+    "input_tuple(uint256,uint256)"(
+      input1: BigNumberish,
+      input2: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
 
-    input_struct(input1: {
-      uint256_0: BigNumberish;
-      uint256_1: BigNumberish;
-    }): Promise<BigNumber>;
+    input_uint256(
+      input1: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
 
-    input_tuple(input1: BigNumberish, input2: BigNumberish): Promise<BigNumber>;
+    "input_uint256(uint256)"(
+      input1: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
 
-    input_uint256(input1: BigNumberish): Promise<BigNumber>;
+    input_uint8(
+      input1: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
 
-    input_uint8(input1: BigNumberish): Promise<BigNumber>;
+    "input_uint8(uint8)"(
+      input1: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
   };
 }
diff --git a/packages/target-ethers-v4-test/types/DataTypesPure.d.ts b/packages/target-ethers-v4-test/types/DataTypesPure.d.ts
index 6e81fa219..80b7d9ad2 100644
--- a/packages/target-ethers-v4-test/types/DataTypesPure.d.ts
+++ b/packages/target-ethers-v4-test/types/DataTypesPure.d.ts
@@ -61,118 +61,252 @@ export class DataTypesPure extends Contract {
   interface: DataTypesPureInterface;
 
   functions: {
-    pure_address(): Promise<string>;
+    pure_address(overrides?: TransactionOverrides): Promise<string>;
 
-    pure_bool(): Promise<boolean>;
+    "pure_address()"(overrides?: TransactionOverrides): Promise<string>;
 
-    pure_bytes(): Promise<string>;
+    pure_bool(overrides?: TransactionOverrides): Promise<boolean>;
 
-    pure_bytes1(): Promise<string>;
+    "pure_bool()"(overrides?: TransactionOverrides): Promise<boolean>;
 
-    pure_enum(): Promise<number>;
+    pure_bytes(overrides?: TransactionOverrides): Promise<string>;
 
-    pure_int256(): Promise<BigNumber>;
+    "pure_bytes()"(overrides?: TransactionOverrides): Promise<string>;
 
-    pure_int8(): Promise<number>;
+    pure_bytes1(overrides?: TransactionOverrides): Promise<string>;
 
-    pure_named(): Promise<{
+    "pure_bytes1()"(overrides?: TransactionOverrides): Promise<string>;
+
+    pure_enum(overrides?: TransactionOverrides): Promise<number>;
+
+    "pure_enum()"(overrides?: TransactionOverrides): Promise<number>;
+
+    pure_int256(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "pure_int256()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    pure_int8(overrides?: TransactionOverrides): Promise<number>;
+
+    "pure_int8()"(overrides?: TransactionOverrides): Promise<number>;
+
+    pure_named(
+      overrides?: TransactionOverrides
+    ): Promise<{
       uint256_1: BigNumber;
       uint256_2: BigNumber;
       0: BigNumber;
       1: BigNumber;
     }>;
 
-    pure_stat_array(): Promise<number[]>;
+    "pure_named()"(
+      overrides?: TransactionOverrides
+    ): Promise<{
+      uint256_1: BigNumber;
+      uint256_2: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    pure_stat_array(overrides?: TransactionOverrides): Promise<number[]>;
 
-    pure_string(): Promise<string>;
+    "pure_stat_array()"(overrides?: TransactionOverrides): Promise<number[]>;
+
+    pure_string(overrides?: TransactionOverrides): Promise<string>;
+
+    "pure_string()"(overrides?: TransactionOverrides): Promise<string>;
+
+    pure_struct(
+      overrides?: TransactionOverrides
+    ): Promise<{
+      uint256_0: BigNumber;
+      uint256_1: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
 
-    pure_struct(): Promise<{
+    "pure_struct()"(
+      overrides?: TransactionOverrides
+    ): Promise<{
       uint256_0: BigNumber;
       uint256_1: BigNumber;
       0: BigNumber;
       1: BigNumber;
     }>;
 
-    pure_tuple(): Promise<{
+    pure_tuple(
+      overrides?: TransactionOverrides
+    ): Promise<{
       0: BigNumber;
       1: BigNumber;
     }>;
 
-    pure_uint256(): Promise<BigNumber>;
+    "pure_tuple()"(
+      overrides?: TransactionOverrides
+    ): Promise<{
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    pure_uint256(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "pure_uint256()"(overrides?: TransactionOverrides): Promise<BigNumber>;
 
-    pure_uint8(): Promise<number>;
+    pure_uint8(overrides?: TransactionOverrides): Promise<number>;
+
+    "pure_uint8()"(overrides?: TransactionOverrides): Promise<number>;
   };
 
-  pure_address(): Promise<string>;
+  pure_address(overrides?: TransactionOverrides): Promise<string>;
+
+  "pure_address()"(overrides?: TransactionOverrides): Promise<string>;
+
+  pure_bool(overrides?: TransactionOverrides): Promise<boolean>;
+
+  "pure_bool()"(overrides?: TransactionOverrides): Promise<boolean>;
+
+  pure_bytes(overrides?: TransactionOverrides): Promise<string>;
+
+  "pure_bytes()"(overrides?: TransactionOverrides): Promise<string>;
+
+  pure_bytes1(overrides?: TransactionOverrides): Promise<string>;
+
+  "pure_bytes1()"(overrides?: TransactionOverrides): Promise<string>;
 
-  pure_bool(): Promise<boolean>;
+  pure_enum(overrides?: TransactionOverrides): Promise<number>;
 
-  pure_bytes(): Promise<string>;
+  "pure_enum()"(overrides?: TransactionOverrides): Promise<number>;
 
-  pure_bytes1(): Promise<string>;
+  pure_int256(overrides?: TransactionOverrides): Promise<BigNumber>;
 
-  pure_enum(): Promise<number>;
+  "pure_int256()"(overrides?: TransactionOverrides): Promise<BigNumber>;
 
-  pure_int256(): Promise<BigNumber>;
+  pure_int8(overrides?: TransactionOverrides): Promise<number>;
 
-  pure_int8(): Promise<number>;
+  "pure_int8()"(overrides?: TransactionOverrides): Promise<number>;
 
-  pure_named(): Promise<{
+  pure_named(
+    overrides?: TransactionOverrides
+  ): Promise<{
     uint256_1: BigNumber;
     uint256_2: BigNumber;
     0: BigNumber;
     1: BigNumber;
   }>;
 
-  pure_stat_array(): Promise<number[]>;
+  "pure_named()"(
+    overrides?: TransactionOverrides
+  ): Promise<{
+    uint256_1: BigNumber;
+    uint256_2: BigNumber;
+    0: BigNumber;
+    1: BigNumber;
+  }>;
 
-  pure_string(): Promise<string>;
+  pure_stat_array(overrides?: TransactionOverrides): Promise<number[]>;
 
-  pure_struct(): Promise<{
+  "pure_stat_array()"(overrides?: TransactionOverrides): Promise<number[]>;
+
+  pure_string(overrides?: TransactionOverrides): Promise<string>;
+
+  "pure_string()"(overrides?: TransactionOverrides): Promise<string>;
+
+  pure_struct(
+    overrides?: TransactionOverrides
+  ): Promise<{
     uint256_0: BigNumber;
     uint256_1: BigNumber;
     0: BigNumber;
     1: BigNumber;
   }>;
 
-  pure_tuple(): Promise<{
+  "pure_struct()"(
+    overrides?: TransactionOverrides
+  ): Promise<{
+    uint256_0: BigNumber;
+    uint256_1: BigNumber;
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
+  pure_tuple(
+    overrides?: TransactionOverrides
+  ): Promise<{
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
+  "pure_tuple()"(
+    overrides?: TransactionOverrides
+  ): Promise<{
     0: BigNumber;
     1: BigNumber;
   }>;
 
-  pure_uint256(): Promise<BigNumber>;
+  pure_uint256(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+  "pure_uint256()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+  pure_uint8(overrides?: TransactionOverrides): Promise<number>;
 
-  pure_uint8(): Promise<number>;
+  "pure_uint8()"(overrides?: TransactionOverrides): Promise<number>;
 
   filters: {};
 
   estimate: {
-    pure_address(): Promise<BigNumber>;
+    pure_address(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "pure_address()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    pure_bool(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "pure_bool()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    pure_bytes(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "pure_bytes()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    pure_bytes1(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "pure_bytes1()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    pure_enum(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "pure_enum()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    pure_int256(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "pure_int256()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    pure_int8(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "pure_int8()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    pure_named(overrides?: TransactionOverrides): Promise<BigNumber>;
 
-    pure_bool(): Promise<BigNumber>;
+    "pure_named()"(overrides?: TransactionOverrides): Promise<BigNumber>;
 
-    pure_bytes(): Promise<BigNumber>;
+    pure_stat_array(overrides?: TransactionOverrides): Promise<BigNumber>;
 
-    pure_bytes1(): Promise<BigNumber>;
+    "pure_stat_array()"(overrides?: TransactionOverrides): Promise<BigNumber>;
 
-    pure_enum(): Promise<BigNumber>;
+    pure_string(overrides?: TransactionOverrides): Promise<BigNumber>;
 
-    pure_int256(): Promise<BigNumber>;
+    "pure_string()"(overrides?: TransactionOverrides): Promise<BigNumber>;
 
-    pure_int8(): Promise<BigNumber>;
+    pure_struct(overrides?: TransactionOverrides): Promise<BigNumber>;
 
-    pure_named(): Promise<BigNumber>;
+    "pure_struct()"(overrides?: TransactionOverrides): Promise<BigNumber>;
 
-    pure_stat_array(): Promise<BigNumber>;
+    pure_tuple(overrides?: TransactionOverrides): Promise<BigNumber>;
 
-    pure_string(): Promise<BigNumber>;
+    "pure_tuple()"(overrides?: TransactionOverrides): Promise<BigNumber>;
 
-    pure_struct(): Promise<BigNumber>;
+    pure_uint256(overrides?: TransactionOverrides): Promise<BigNumber>;
 
-    pure_tuple(): Promise<BigNumber>;
+    "pure_uint256()"(overrides?: TransactionOverrides): Promise<BigNumber>;
 
-    pure_uint256(): Promise<BigNumber>;
+    pure_uint8(overrides?: TransactionOverrides): Promise<BigNumber>;
 
-    pure_uint8(): Promise<BigNumber>;
+    "pure_uint8()"(overrides?: TransactionOverrides): Promise<BigNumber>;
   };
 }
diff --git a/packages/target-ethers-v4-test/types/DataTypesView.d.ts b/packages/target-ethers-v4-test/types/DataTypesView.d.ts
index d489c6ba3..9ec7bf803 100644
--- a/packages/target-ethers-v4-test/types/DataTypesView.d.ts
+++ b/packages/target-ethers-v4-test/types/DataTypesView.d.ts
@@ -61,118 +61,252 @@ export class DataTypesView extends Contract {
   interface: DataTypesViewInterface;
 
   functions: {
-    view_address(): Promise<string>;
+    view_address(overrides?: TransactionOverrides): Promise<string>;
 
-    view_bool(): Promise<boolean>;
+    "view_address()"(overrides?: TransactionOverrides): Promise<string>;
 
-    view_bytes(): Promise<string>;
+    view_bool(overrides?: TransactionOverrides): Promise<boolean>;
 
-    view_bytes1(): Promise<string>;
+    "view_bool()"(overrides?: TransactionOverrides): Promise<boolean>;
 
-    view_enum(): Promise<number>;
+    view_bytes(overrides?: TransactionOverrides): Promise<string>;
 
-    view_int256(): Promise<BigNumber>;
+    "view_bytes()"(overrides?: TransactionOverrides): Promise<string>;
 
-    view_int8(): Promise<number>;
+    view_bytes1(overrides?: TransactionOverrides): Promise<string>;
 
-    view_named(): Promise<{
+    "view_bytes1()"(overrides?: TransactionOverrides): Promise<string>;
+
+    view_enum(overrides?: TransactionOverrides): Promise<number>;
+
+    "view_enum()"(overrides?: TransactionOverrides): Promise<number>;
+
+    view_int256(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "view_int256()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    view_int8(overrides?: TransactionOverrides): Promise<number>;
+
+    "view_int8()"(overrides?: TransactionOverrides): Promise<number>;
+
+    view_named(
+      overrides?: TransactionOverrides
+    ): Promise<{
       uint256_1: BigNumber;
       uint256_2: BigNumber;
       0: BigNumber;
       1: BigNumber;
     }>;
 
-    view_stat_array(): Promise<number[]>;
+    "view_named()"(
+      overrides?: TransactionOverrides
+    ): Promise<{
+      uint256_1: BigNumber;
+      uint256_2: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    view_stat_array(overrides?: TransactionOverrides): Promise<number[]>;
 
-    view_string(): Promise<string>;
+    "view_stat_array()"(overrides?: TransactionOverrides): Promise<number[]>;
+
+    view_string(overrides?: TransactionOverrides): Promise<string>;
+
+    "view_string()"(overrides?: TransactionOverrides): Promise<string>;
+
+    view_struct(
+      overrides?: TransactionOverrides
+    ): Promise<{
+      uint256_0: BigNumber;
+      uint256_1: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
 
-    view_struct(): Promise<{
+    "view_struct()"(
+      overrides?: TransactionOverrides
+    ): Promise<{
       uint256_0: BigNumber;
       uint256_1: BigNumber;
       0: BigNumber;
       1: BigNumber;
     }>;
 
-    view_tuple(): Promise<{
+    view_tuple(
+      overrides?: TransactionOverrides
+    ): Promise<{
       0: BigNumber;
       1: BigNumber;
     }>;
 
-    view_uint256(): Promise<BigNumber>;
+    "view_tuple()"(
+      overrides?: TransactionOverrides
+    ): Promise<{
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
+    view_uint256(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "view_uint256()"(overrides?: TransactionOverrides): Promise<BigNumber>;
 
-    view_uint8(): Promise<number>;
+    view_uint8(overrides?: TransactionOverrides): Promise<number>;
+
+    "view_uint8()"(overrides?: TransactionOverrides): Promise<number>;
   };
 
-  view_address(): Promise<string>;
+  view_address(overrides?: TransactionOverrides): Promise<string>;
+
+  "view_address()"(overrides?: TransactionOverrides): Promise<string>;
+
+  view_bool(overrides?: TransactionOverrides): Promise<boolean>;
+
+  "view_bool()"(overrides?: TransactionOverrides): Promise<boolean>;
+
+  view_bytes(overrides?: TransactionOverrides): Promise<string>;
+
+  "view_bytes()"(overrides?: TransactionOverrides): Promise<string>;
+
+  view_bytes1(overrides?: TransactionOverrides): Promise<string>;
+
+  "view_bytes1()"(overrides?: TransactionOverrides): Promise<string>;
 
-  view_bool(): Promise<boolean>;
+  view_enum(overrides?: TransactionOverrides): Promise<number>;
 
-  view_bytes(): Promise<string>;
+  "view_enum()"(overrides?: TransactionOverrides): Promise<number>;
 
-  view_bytes1(): Promise<string>;
+  view_int256(overrides?: TransactionOverrides): Promise<BigNumber>;
 
-  view_enum(): Promise<number>;
+  "view_int256()"(overrides?: TransactionOverrides): Promise<BigNumber>;
 
-  view_int256(): Promise<BigNumber>;
+  view_int8(overrides?: TransactionOverrides): Promise<number>;
 
-  view_int8(): Promise<number>;
+  "view_int8()"(overrides?: TransactionOverrides): Promise<number>;
 
-  view_named(): Promise<{
+  view_named(
+    overrides?: TransactionOverrides
+  ): Promise<{
     uint256_1: BigNumber;
     uint256_2: BigNumber;
     0: BigNumber;
     1: BigNumber;
   }>;
 
-  view_stat_array(): Promise<number[]>;
+  "view_named()"(
+    overrides?: TransactionOverrides
+  ): Promise<{
+    uint256_1: BigNumber;
+    uint256_2: BigNumber;
+    0: BigNumber;
+    1: BigNumber;
+  }>;
 
-  view_string(): Promise<string>;
+  view_stat_array(overrides?: TransactionOverrides): Promise<number[]>;
 
-  view_struct(): Promise<{
+  "view_stat_array()"(overrides?: TransactionOverrides): Promise<number[]>;
+
+  view_string(overrides?: TransactionOverrides): Promise<string>;
+
+  "view_string()"(overrides?: TransactionOverrides): Promise<string>;
+
+  view_struct(
+    overrides?: TransactionOverrides
+  ): Promise<{
     uint256_0: BigNumber;
     uint256_1: BigNumber;
     0: BigNumber;
     1: BigNumber;
   }>;
 
-  view_tuple(): Promise<{
+  "view_struct()"(
+    overrides?: TransactionOverrides
+  ): Promise<{
+    uint256_0: BigNumber;
+    uint256_1: BigNumber;
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
+  view_tuple(
+    overrides?: TransactionOverrides
+  ): Promise<{
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
+  "view_tuple()"(
+    overrides?: TransactionOverrides
+  ): Promise<{
     0: BigNumber;
     1: BigNumber;
   }>;
 
-  view_uint256(): Promise<BigNumber>;
+  view_uint256(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+  "view_uint256()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+  view_uint8(overrides?: TransactionOverrides): Promise<number>;
 
-  view_uint8(): Promise<number>;
+  "view_uint8()"(overrides?: TransactionOverrides): Promise<number>;
 
   filters: {};
 
   estimate: {
-    view_address(): Promise<BigNumber>;
+    view_address(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "view_address()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    view_bool(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "view_bool()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    view_bytes(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "view_bytes()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    view_bytes1(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "view_bytes1()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    view_enum(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "view_enum()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    view_int256(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "view_int256()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    view_int8(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "view_int8()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    view_named(overrides?: TransactionOverrides): Promise<BigNumber>;
 
-    view_bool(): Promise<BigNumber>;
+    "view_named()"(overrides?: TransactionOverrides): Promise<BigNumber>;
 
-    view_bytes(): Promise<BigNumber>;
+    view_stat_array(overrides?: TransactionOverrides): Promise<BigNumber>;
 
-    view_bytes1(): Promise<BigNumber>;
+    "view_stat_array()"(overrides?: TransactionOverrides): Promise<BigNumber>;
 
-    view_enum(): Promise<BigNumber>;
+    view_string(overrides?: TransactionOverrides): Promise<BigNumber>;
 
-    view_int256(): Promise<BigNumber>;
+    "view_string()"(overrides?: TransactionOverrides): Promise<BigNumber>;
 
-    view_int8(): Promise<BigNumber>;
+    view_struct(overrides?: TransactionOverrides): Promise<BigNumber>;
 
-    view_named(): Promise<BigNumber>;
+    "view_struct()"(overrides?: TransactionOverrides): Promise<BigNumber>;
 
-    view_stat_array(): Promise<BigNumber>;
+    view_tuple(overrides?: TransactionOverrides): Promise<BigNumber>;
 
-    view_string(): Promise<BigNumber>;
+    "view_tuple()"(overrides?: TransactionOverrides): Promise<BigNumber>;
 
-    view_struct(): Promise<BigNumber>;
+    view_uint256(overrides?: TransactionOverrides): Promise<BigNumber>;
 
-    view_tuple(): Promise<BigNumber>;
+    "view_uint256()"(overrides?: TransactionOverrides): Promise<BigNumber>;
 
-    view_uint256(): Promise<BigNumber>;
+    view_uint8(overrides?: TransactionOverrides): Promise<BigNumber>;
 
-    view_uint8(): Promise<BigNumber>;
+    "view_uint8()"(overrides?: TransactionOverrides): Promise<BigNumber>;
   };
 }
diff --git a/packages/target-ethers-v4-test/types/Events.d.ts b/packages/target-ethers-v4-test/types/Events.d.ts
index 21dd4fd1c..67d7469ae 100644
--- a/packages/target-ethers-v4-test/types/Events.d.ts
+++ b/packages/target-ethers-v4-test/types/Events.d.ts
@@ -58,29 +58,69 @@ export class Events extends Contract {
   functions: {
     emit_anon1(overrides?: TransactionOverrides): Promise<ContractTransaction>;
 
+    "emit_anon1()"(
+      overrides?: TransactionOverrides
+    ): Promise<ContractTransaction>;
+
     emit_event1(overrides?: TransactionOverrides): Promise<ContractTransaction>;
 
+    "emit_event1()"(
+      overrides?: TransactionOverrides
+    ): Promise<ContractTransaction>;
+
     emit_event2(overrides?: TransactionOverrides): Promise<ContractTransaction>;
 
+    "emit_event2()"(
+      overrides?: TransactionOverrides
+    ): Promise<ContractTransaction>;
+
     emit_event3(overrides?: TransactionOverrides): Promise<ContractTransaction>;
 
+    "emit_event3()"(
+      overrides?: TransactionOverrides
+    ): Promise<ContractTransaction>;
+
     emit_event3_overloaded(
       overrides?: TransactionOverrides
     ): Promise<ContractTransaction>;
+
+    "emit_event3_overloaded()"(
+      overrides?: TransactionOverrides
+    ): Promise<ContractTransaction>;
   };
 
   emit_anon1(overrides?: TransactionOverrides): Promise<ContractTransaction>;
 
+  "emit_anon1()"(
+    overrides?: TransactionOverrides
+  ): Promise<ContractTransaction>;
+
   emit_event1(overrides?: TransactionOverrides): Promise<ContractTransaction>;
 
+  "emit_event1()"(
+    overrides?: TransactionOverrides
+  ): Promise<ContractTransaction>;
+
   emit_event2(overrides?: TransactionOverrides): Promise<ContractTransaction>;
 
+  "emit_event2()"(
+    overrides?: TransactionOverrides
+  ): Promise<ContractTransaction>;
+
   emit_event3(overrides?: TransactionOverrides): Promise<ContractTransaction>;
 
+  "emit_event3()"(
+    overrides?: TransactionOverrides
+  ): Promise<ContractTransaction>;
+
   emit_event3_overloaded(
     overrides?: TransactionOverrides
   ): Promise<ContractTransaction>;
 
+  "emit_event3_overloaded()"(
+    overrides?: TransactionOverrides
+  ): Promise<ContractTransaction>;
+
   filters: {
     AnonEvent1(value1: BigNumberish | null): EventFilter;
 
@@ -92,14 +132,28 @@ export class Events extends Contract {
   };
 
   estimate: {
-    emit_anon1(): Promise<BigNumber>;
+    emit_anon1(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "emit_anon1()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    emit_event1(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "emit_event1()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    emit_event2(overrides?: TransactionOverrides): Promise<BigNumber>;
 
-    emit_event1(): Promise<BigNumber>;
+    "emit_event2()"(overrides?: TransactionOverrides): Promise<BigNumber>;
 
-    emit_event2(): Promise<BigNumber>;
+    emit_event3(overrides?: TransactionOverrides): Promise<BigNumber>;
 
-    emit_event3(): Promise<BigNumber>;
+    "emit_event3()"(overrides?: TransactionOverrides): Promise<BigNumber>;
 
-    emit_event3_overloaded(): Promise<BigNumber>;
+    emit_event3_overloaded(
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+
+    "emit_event3_overloaded()"(
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
   };
 }
diff --git a/packages/target-ethers-v4-test/types/NameMangling.d.ts b/packages/target-ethers-v4-test/types/NameMangling.d.ts
index 5edbd9e8e..6c60de7b8 100644
--- a/packages/target-ethers-v4-test/types/NameMangling.d.ts
+++ b/packages/target-ethers-v4-test/types/NameMangling.d.ts
@@ -35,14 +35,20 @@ export class NameMangling extends Contract {
   interface: NameManglingInterface;
 
   functions: {
-    works(): Promise<boolean>;
+    works(overrides?: TransactionOverrides): Promise<boolean>;
+
+    "works()"(overrides?: TransactionOverrides): Promise<boolean>;
   };
 
-  works(): Promise<boolean>;
+  works(overrides?: TransactionOverrides): Promise<boolean>;
+
+  "works()"(overrides?: TransactionOverrides): Promise<boolean>;
 
   filters: {};
 
   estimate: {
-    works(): Promise<BigNumber>;
+    works(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "works()"(overrides?: TransactionOverrides): Promise<BigNumber>;
   };
 }
diff --git a/packages/target-ethers-v4-test/types/Overloads.d.ts b/packages/target-ethers-v4-test/types/Overloads.d.ts
index 73ed4f205..ecfeecfdc 100644
--- a/packages/target-ethers-v4-test/types/Overloads.d.ts
+++ b/packages/target-ethers-v4-test/types/Overloads.d.ts
@@ -34,24 +34,56 @@ export class Overloads extends Contract {
   interface: OverloadsInterface;
 
   functions: {
-    "overload1(int256)"(input1: BigNumberish): Promise<BigNumber>;
+    overload1(
+      input1: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+
+    "overload1(int256)"(
+      input1: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
 
     "overload1(uint256,uint256)"(
       input1: BigNumberish,
-      input2: BigNumberish
+      input2: BigNumberish,
+      overrides?: TransactionOverrides
     ): Promise<BigNumber>;
   };
 
-  "overload1(int256)"(input1: BigNumberish): Promise<BigNumber>;
+  overload1(
+    input1: BigNumberish,
+    overrides?: TransactionOverrides
+  ): Promise<BigNumber>;
+
+  "overload1(int256)"(
+    input1: BigNumberish,
+    overrides?: TransactionOverrides
+  ): Promise<BigNumber>;
 
   "overload1(uint256,uint256)"(
     input1: BigNumberish,
-    input2: BigNumberish
+    input2: BigNumberish,
+    overrides?: TransactionOverrides
   ): Promise<BigNumber>;
 
   filters: {};
 
   estimate: {
-    overload1(input1: BigNumberish): Promise<BigNumber>;
+    overload1(
+      input1: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+
+    "overload1(int256)"(
+      input1: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
+
+    "overload1(uint256,uint256)"(
+      input1: BigNumberish,
+      input2: BigNumberish,
+      overrides?: TransactionOverrides
+    ): Promise<BigNumber>;
   };
 }
diff --git a/packages/target-ethers-v4-test/types/Payable.d.ts b/packages/target-ethers-v4-test/types/Payable.d.ts
index c36e141ef..e541f05e5 100644
--- a/packages/target-ethers-v4-test/types/Payable.d.ts
+++ b/packages/target-ethers-v4-test/types/Payable.d.ts
@@ -38,22 +38,42 @@ export class Payable extends Contract {
       overrides?: TransactionOverrides
     ): Promise<ContractTransaction>;
 
+    "non_payable_func()"(
+      overrides?: TransactionOverrides
+    ): Promise<ContractTransaction>;
+
     payable_func(
       overrides?: TransactionOverrides
     ): Promise<ContractTransaction>;
+
+    "payable_func()"(
+      overrides?: TransactionOverrides
+    ): Promise<ContractTransaction>;
   };
 
   non_payable_func(
     overrides?: TransactionOverrides
   ): Promise<ContractTransaction>;
 
+  "non_payable_func()"(
+    overrides?: TransactionOverrides
+  ): Promise<ContractTransaction>;
+
   payable_func(overrides?: TransactionOverrides): Promise<ContractTransaction>;
 
+  "payable_func()"(
+    overrides?: TransactionOverrides
+  ): Promise<ContractTransaction>;
+
   filters: {};
 
   estimate: {
-    non_payable_func(): Promise<BigNumber>;
+    non_payable_func(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    "non_payable_func()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+
+    payable_func(overrides?: TransactionOverrides): Promise<BigNumber>;
 
-    payable_func(): Promise<BigNumber>;
+    "payable_func()"(overrides?: TransactionOverrides): Promise<BigNumber>;
   };
 }
diff --git a/packages/target-ethers-v5-test/types/DataTypesInput.d.ts b/packages/target-ethers-v5-test/types/DataTypesInput.d.ts
index 7c06ff7c9..75afa3bcf 100644
--- a/packages/target-ethers-v5-test/types/DataTypesInput.d.ts
+++ b/packages/target-ethers-v5-test/types/DataTypesInput.d.ts
@@ -153,6 +153,13 @@ export class DataTypesInput extends Contract {
       0: string;
     }>;
 
+    "input_address(address)"(
+      input1: string,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
+
     input_bool(
       input1: boolean,
       overrides?: CallOverrides
@@ -160,6 +167,13 @@ export class DataTypesInput extends Contract {
       0: boolean;
     }>;
 
+    "input_bool(bool)"(
+      input1: boolean,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: boolean;
+    }>;
+
     input_bytes(
       input1: BytesLike,
       overrides?: CallOverrides
@@ -167,6 +181,13 @@ export class DataTypesInput extends Contract {
       0: string;
     }>;
 
+    "input_bytes(bytes)"(
+      input1: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
+
     input_bytes1(
       input1: BytesLike,
       overrides?: CallOverrides
@@ -174,6 +195,13 @@ export class DataTypesInput extends Contract {
       0: string;
     }>;
 
+    "input_bytes1(bytes1)"(
+      input1: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
+
     input_enum(
       input1: BigNumberish,
       overrides?: CallOverrides
@@ -181,6 +209,13 @@ export class DataTypesInput extends Contract {
       0: number;
     }>;
 
+    "input_enum(uint8)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number;
+    }>;
+
     input_int256(
       input1: BigNumberish,
       overrides?: CallOverrides
@@ -188,6 +223,13 @@ export class DataTypesInput extends Contract {
       0: BigNumber;
     }>;
 
+    "input_int256(int256)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+    }>;
+
     input_int8(
       input1: BigNumberish,
       overrides?: CallOverrides
@@ -195,6 +237,13 @@ export class DataTypesInput extends Contract {
       0: number;
     }>;
 
+    "input_int8(int8)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number;
+    }>;
+
     input_stat_array(
       input1: BigNumberish[],
       overrides?: CallOverrides
@@ -202,6 +251,13 @@ export class DataTypesInput extends Contract {
       0: number[];
     }>;
 
+    "input_stat_array(uint8[3])"(
+      input1: BigNumberish[],
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number[];
+    }>;
+
     input_string(
       input1: string,
       overrides?: CallOverrides
@@ -209,6 +265,13 @@ export class DataTypesInput extends Contract {
       0: string;
     }>;
 
+    "input_string(string)"(
+      input1: string,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
+
     input_struct(
       input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
       overrides?: CallOverrides
@@ -221,6 +284,18 @@ export class DataTypesInput extends Contract {
       };
     }>;
 
+    "input_struct(tuple)"(
+      input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
+      overrides?: CallOverrides
+    ): Promise<{
+      0: {
+        uint256_0: BigNumber;
+        uint256_1: BigNumber;
+        0: BigNumber;
+        1: BigNumber;
+      };
+    }>;
+
     input_tuple(
       input1: BigNumberish,
       input2: BigNumberish,
@@ -230,6 +305,15 @@ export class DataTypesInput extends Contract {
       1: BigNumber;
     }>;
 
+    "input_tuple(uint256,uint256)"(
+      input1: BigNumberish,
+      input2: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
     input_uint256(
       input1: BigNumberish,
       overrides?: CallOverrides
@@ -237,38 +321,97 @@ export class DataTypesInput extends Contract {
       0: BigNumber;
     }>;
 
+    "input_uint256(uint256)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+    }>;
+
     input_uint8(
       input1: BigNumberish,
       overrides?: CallOverrides
     ): Promise<{
       0: number;
     }>;
+
+    "input_uint8(uint8)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number;
+    }>;
   };
 
   input_address(input1: string, overrides?: CallOverrides): Promise<string>;
 
+  "input_address(address)"(
+    input1: string,
+    overrides?: CallOverrides
+  ): Promise<string>;
+
   input_bool(input1: boolean, overrides?: CallOverrides): Promise<boolean>;
 
+  "input_bool(bool)"(
+    input1: boolean,
+    overrides?: CallOverrides
+  ): Promise<boolean>;
+
   input_bytes(input1: BytesLike, overrides?: CallOverrides): Promise<string>;
 
+  "input_bytes(bytes)"(
+    input1: BytesLike,
+    overrides?: CallOverrides
+  ): Promise<string>;
+
   input_bytes1(input1: BytesLike, overrides?: CallOverrides): Promise<string>;
 
+  "input_bytes1(bytes1)"(
+    input1: BytesLike,
+    overrides?: CallOverrides
+  ): Promise<string>;
+
   input_enum(input1: BigNumberish, overrides?: CallOverrides): Promise<number>;
 
+  "input_enum(uint8)"(
+    input1: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<number>;
+
   input_int256(
     input1: BigNumberish,
     overrides?: CallOverrides
   ): Promise<BigNumber>;
 
+  "input_int256(int256)"(
+    input1: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
   input_int8(input1: BigNumberish, overrides?: CallOverrides): Promise<number>;
 
+  "input_int8(int8)"(
+    input1: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<number>;
+
   input_stat_array(
     input1: BigNumberish[],
     overrides?: CallOverrides
   ): Promise<number[]>;
 
+  "input_stat_array(uint8[3])"(
+    input1: BigNumberish[],
+    overrides?: CallOverrides
+  ): Promise<number[]>;
+
   input_string(input1: string, overrides?: CallOverrides): Promise<string>;
 
+  "input_string(string)"(
+    input1: string,
+    overrides?: CallOverrides
+  ): Promise<string>;
+
   input_struct(
     input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
     overrides?: CallOverrides
@@ -279,6 +422,16 @@ export class DataTypesInput extends Contract {
     1: BigNumber;
   }>;
 
+  "input_struct(tuple)"(
+    input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
+    overrides?: CallOverrides
+  ): Promise<{
+    uint256_0: BigNumber;
+    uint256_1: BigNumber;
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
   input_tuple(
     input1: BigNumberish,
     input2: BigNumberish,
@@ -288,44 +441,108 @@ export class DataTypesInput extends Contract {
     1: BigNumber;
   }>;
 
+  "input_tuple(uint256,uint256)"(
+    input1: BigNumberish,
+    input2: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<{
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
   input_uint256(
     input1: BigNumberish,
     overrides?: CallOverrides
   ): Promise<BigNumber>;
 
+  "input_uint256(uint256)"(
+    input1: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<BigNumber>;
+
   input_uint8(input1: BigNumberish, overrides?: CallOverrides): Promise<number>;
 
+  "input_uint8(uint8)"(
+    input1: BigNumberish,
+    overrides?: CallOverrides
+  ): Promise<number>;
+
   callStatic: {
     input_address(input1: string, overrides?: CallOverrides): Promise<string>;
 
+    "input_address(address)"(
+      input1: string,
+      overrides?: CallOverrides
+    ): Promise<string>;
+
     input_bool(input1: boolean, overrides?: CallOverrides): Promise<boolean>;
 
+    "input_bool(bool)"(
+      input1: boolean,
+      overrides?: CallOverrides
+    ): Promise<boolean>;
+
     input_bytes(input1: BytesLike, overrides?: CallOverrides): Promise<string>;
 
+    "input_bytes(bytes)"(
+      input1: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<string>;
+
     input_bytes1(input1: BytesLike, overrides?: CallOverrides): Promise<string>;
 
+    "input_bytes1(bytes1)"(
+      input1: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<string>;
+
     input_enum(
       input1: BigNumberish,
       overrides?: CallOverrides
     ): Promise<number>;
 
+    "input_enum(uint8)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<number>;
+
     input_int256(
       input1: BigNumberish,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
+    "input_int256(int256)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
     input_int8(
       input1: BigNumberish,
       overrides?: CallOverrides
     ): Promise<number>;
 
+    "input_int8(int8)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<number>;
+
     input_stat_array(
       input1: BigNumberish[],
       overrides?: CallOverrides
     ): Promise<number[]>;
 
+    "input_stat_array(uint8[3])"(
+      input1: BigNumberish[],
+      overrides?: CallOverrides
+    ): Promise<number[]>;
+
     input_string(input1: string, overrides?: CallOverrides): Promise<string>;
 
+    "input_string(string)"(
+      input1: string,
+      overrides?: CallOverrides
+    ): Promise<string>;
+
     input_struct(
       input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
       overrides?: CallOverrides
@@ -336,6 +553,16 @@ export class DataTypesInput extends Contract {
       1: BigNumber;
     }>;
 
+    "input_struct(tuple)"(
+      input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
+      overrides?: CallOverrides
+    ): Promise<{
+      uint256_0: BigNumber;
+      uint256_1: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
     input_tuple(
       input1: BigNumberish,
       input2: BigNumberish,
@@ -345,15 +572,34 @@ export class DataTypesInput extends Contract {
       1: BigNumber;
     }>;
 
+    "input_tuple(uint256,uint256)"(
+      input1: BigNumberish,
+      input2: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
     input_uint256(
       input1: BigNumberish,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
+    "input_uint256(uint256)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
     input_uint8(
       input1: BigNumberish,
       overrides?: CallOverrides
     ): Promise<number>;
+
+    "input_uint8(uint8)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<number>;
   };
 
   filters: {};
@@ -364,60 +610,126 @@ export class DataTypesInput extends Contract {
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
+    "input_address(address)"(
+      input1: string,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
     input_bool(input1: boolean, overrides?: CallOverrides): Promise<BigNumber>;
 
+    "input_bool(bool)"(
+      input1: boolean,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
     input_bytes(
       input1: BytesLike,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
+    "input_bytes(bytes)"(
+      input1: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
     input_bytes1(
       input1: BytesLike,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
+    "input_bytes1(bytes1)"(
+      input1: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
     input_enum(
       input1: BigNumberish,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
+    "input_enum(uint8)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
     input_int256(
       input1: BigNumberish,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
+    "input_int256(int256)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
     input_int8(
       input1: BigNumberish,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
+    "input_int8(int8)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
     input_stat_array(
       input1: BigNumberish[],
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
+    "input_stat_array(uint8[3])"(
+      input1: BigNumberish[],
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
     input_string(input1: string, overrides?: CallOverrides): Promise<BigNumber>;
 
+    "input_string(string)"(
+      input1: string,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
     input_struct(
       input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
+    "input_struct(tuple)"(
+      input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
     input_tuple(
       input1: BigNumberish,
       input2: BigNumberish,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
+    "input_tuple(uint256,uint256)"(
+      input1: BigNumberish,
+      input2: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
     input_uint256(
       input1: BigNumberish,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
+    "input_uint256(uint256)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
+
     input_uint8(
       input1: BigNumberish,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
+
+    "input_uint8(uint8)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<BigNumber>;
   };
 
   populateTransaction: {
@@ -426,65 +738,131 @@ export class DataTypesInput extends Contract {
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
+    "input_address(address)"(
+      input1: string,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
     input_bool(
       input1: boolean,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
+    "input_bool(bool)"(
+      input1: boolean,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
     input_bytes(
       input1: BytesLike,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
+    "input_bytes(bytes)"(
+      input1: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
     input_bytes1(
       input1: BytesLike,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
+    "input_bytes1(bytes1)"(
+      input1: BytesLike,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
     input_enum(
       input1: BigNumberish,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
+    "input_enum(uint8)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
     input_int256(
       input1: BigNumberish,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
+    "input_int256(int256)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
     input_int8(
       input1: BigNumberish,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
+    "input_int8(int8)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
     input_stat_array(
       input1: BigNumberish[],
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
+    "input_stat_array(uint8[3])"(
+      input1: BigNumberish[],
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
     input_string(
       input1: string,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
+    "input_string(string)"(
+      input1: string,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
     input_struct(
       input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
+    "input_struct(tuple)"(
+      input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
     input_tuple(
       input1: BigNumberish,
       input2: BigNumberish,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
+    "input_tuple(uint256,uint256)"(
+      input1: BigNumberish,
+      input2: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
     input_uint256(
       input1: BigNumberish,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
+    "input_uint256(uint256)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
     input_uint8(
       input1: BigNumberish,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
+
+    "input_uint8(uint8)"(
+      input1: BigNumberish,
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
   };
 }
diff --git a/packages/target-ethers-v5-test/types/DataTypesPure.d.ts b/packages/target-ethers-v5-test/types/DataTypesPure.d.ts
index c40b9d313..c80486d59 100644
--- a/packages/target-ethers-v5-test/types/DataTypesPure.d.ts
+++ b/packages/target-ethers-v5-test/types/DataTypesPure.d.ts
@@ -143,42 +143,84 @@ export class DataTypesPure extends Contract {
       0: string;
     }>;
 
+    "pure_address()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
+
     pure_bool(
       overrides?: CallOverrides
     ): Promise<{
       0: boolean;
     }>;
 
+    "pure_bool()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: boolean;
+    }>;
+
     pure_bytes(
       overrides?: CallOverrides
     ): Promise<{
       0: string;
     }>;
 
+    "pure_bytes()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
+
     pure_bytes1(
       overrides?: CallOverrides
     ): Promise<{
       0: string;
     }>;
 
+    "pure_bytes1()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
+
     pure_enum(
       overrides?: CallOverrides
     ): Promise<{
       0: number;
     }>;
 
+    "pure_enum()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number;
+    }>;
+
     pure_int256(
       overrides?: CallOverrides
     ): Promise<{
       0: BigNumber;
     }>;
 
+    "pure_int256()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+    }>;
+
     pure_int8(
       overrides?: CallOverrides
     ): Promise<{
       0: number;
     }>;
 
+    "pure_int8()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number;
+    }>;
+
     pure_named(
       overrides?: CallOverrides
     ): Promise<{
@@ -188,18 +230,39 @@ export class DataTypesPure extends Contract {
       1: BigNumber;
     }>;
 
+    "pure_named()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      uint256_1: BigNumber;
+      uint256_2: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
     pure_stat_array(
       overrides?: CallOverrides
     ): Promise<{
       0: number[];
     }>;
 
+    "pure_stat_array()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number[];
+    }>;
+
     pure_string(
       overrides?: CallOverrides
     ): Promise<{
       0: string;
     }>;
 
+    "pure_string()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
+
     pure_struct(
       overrides?: CallOverrides
     ): Promise<{
@@ -211,6 +274,17 @@ export class DataTypesPure extends Contract {
       };
     }>;
 
+    "pure_struct()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: {
+        uint256_0: BigNumber;
+        uint256_1: BigNumber;
+        0: BigNumber;
+        1: BigNumber;
+      };
+    }>;
+
     pure_tuple(
       overrides?: CallOverrides
     ): Promise<{
@@ -218,33 +292,66 @@ export class DataTypesPure extends Contract {
       1: BigNumber;
     }>;
 
+    "pure_tuple()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
     pure_uint256(
       overrides?: CallOverrides
     ): Promise<{
       0: BigNumber;
     }>;
 
+    "pure_uint256()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+    }>;
+
     pure_uint8(
       overrides?: CallOverrides
     ): Promise<{
       0: number;
     }>;
+
+    "pure_uint8()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number;
+    }>;
   };
 
   pure_address(overrides?: CallOverrides): Promise<string>;
 
+  "pure_address()"(overrides?: CallOverrides): Promise<string>;
+
   pure_bool(overrides?: CallOverrides): Promise<boolean>;
 
+  "pure_bool()"(overrides?: CallOverrides): Promise<boolean>;
+
   pure_bytes(overrides?: CallOverrides): Promise<string>;
 
+  "pure_bytes()"(overrides?: CallOverrides): Promise<string>;
+
   pure_bytes1(overrides?: CallOverrides): Promise<string>;
 
+  "pure_bytes1()"(overrides?: CallOverrides): Promise<string>;
+
   pure_enum(overrides?: CallOverrides): Promise<number>;
 
+  "pure_enum()"(overrides?: CallOverrides): Promise<number>;
+
   pure_int256(overrides?: CallOverrides): Promise<BigNumber>;
 
+  "pure_int256()"(overrides?: CallOverrides): Promise<BigNumber>;
+
   pure_int8(overrides?: CallOverrides): Promise<number>;
 
+  "pure_int8()"(overrides?: CallOverrides): Promise<number>;
+
   pure_named(
     overrides?: CallOverrides
   ): Promise<{
@@ -254,10 +361,23 @@ export class DataTypesPure extends Contract {
     1: BigNumber;
   }>;
 
+  "pure_named()"(
+    overrides?: CallOverrides
+  ): Promise<{
+    uint256_1: BigNumber;
+    uint256_2: BigNumber;
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
   pure_stat_array(overrides?: CallOverrides): Promise<number[]>;
 
+  "pure_stat_array()"(overrides?: CallOverrides): Promise<number[]>;
+
   pure_string(overrides?: CallOverrides): Promise<string>;
 
+  "pure_string()"(overrides?: CallOverrides): Promise<string>;
+
   pure_struct(
     overrides?: CallOverrides
   ): Promise<{
@@ -267,6 +387,15 @@ export class DataTypesPure extends Contract {
     1: BigNumber;
   }>;
 
+  "pure_struct()"(
+    overrides?: CallOverrides
+  ): Promise<{
+    uint256_0: BigNumber;
+    uint256_1: BigNumber;
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
   pure_tuple(
     overrides?: CallOverrides
   ): Promise<{
@@ -274,25 +403,50 @@ export class DataTypesPure extends Contract {
     1: BigNumber;
   }>;
 
+  "pure_tuple()"(
+    overrides?: CallOverrides
+  ): Promise<{
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
   pure_uint256(overrides?: CallOverrides): Promise<BigNumber>;
 
+  "pure_uint256()"(overrides?: CallOverrides): Promise<BigNumber>;
+
   pure_uint8(overrides?: CallOverrides): Promise<number>;
 
+  "pure_uint8()"(overrides?: CallOverrides): Promise<number>;
+
   callStatic: {
     pure_address(overrides?: CallOverrides): Promise<string>;
 
+    "pure_address()"(overrides?: CallOverrides): Promise<string>;
+
     pure_bool(overrides?: CallOverrides): Promise<boolean>;
 
+    "pure_bool()"(overrides?: CallOverrides): Promise<boolean>;
+
     pure_bytes(overrides?: CallOverrides): Promise<string>;
 
+    "pure_bytes()"(overrides?: CallOverrides): Promise<string>;
+
     pure_bytes1(overrides?: CallOverrides): Promise<string>;
 
+    "pure_bytes1()"(overrides?: CallOverrides): Promise<string>;
+
     pure_enum(overrides?: CallOverrides): Promise<number>;
 
+    "pure_enum()"(overrides?: CallOverrides): Promise<number>;
+
     pure_int256(overrides?: CallOverrides): Promise<BigNumber>;
 
+    "pure_int256()"(overrides?: CallOverrides): Promise<BigNumber>;
+
     pure_int8(overrides?: CallOverrides): Promise<number>;
 
+    "pure_int8()"(overrides?: CallOverrides): Promise<number>;
+
     pure_named(
       overrides?: CallOverrides
     ): Promise<{
@@ -302,10 +456,23 @@ export class DataTypesPure extends Contract {
       1: BigNumber;
     }>;
 
+    "pure_named()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      uint256_1: BigNumber;
+      uint256_2: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
     pure_stat_array(overrides?: CallOverrides): Promise<number[]>;
 
+    "pure_stat_array()"(overrides?: CallOverrides): Promise<number[]>;
+
     pure_string(overrides?: CallOverrides): Promise<string>;
 
+    "pure_string()"(overrides?: CallOverrides): Promise<string>;
+
     pure_struct(
       overrides?: CallOverrides
     ): Promise<{
@@ -315,6 +482,15 @@ export class DataTypesPure extends Contract {
       1: BigNumber;
     }>;
 
+    "pure_struct()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      uint256_0: BigNumber;
+      uint256_1: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
     pure_tuple(
       overrides?: CallOverrides
     ): Promise<{
@@ -322,9 +498,20 @@ export class DataTypesPure extends Contract {
       1: BigNumber;
     }>;
 
+    "pure_tuple()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
     pure_uint256(overrides?: CallOverrides): Promise<BigNumber>;
 
+    "pure_uint256()"(overrides?: CallOverrides): Promise<BigNumber>;
+
     pure_uint8(overrides?: CallOverrides): Promise<number>;
+
+    "pure_uint8()"(overrides?: CallOverrides): Promise<number>;
   };
 
   filters: {};
@@ -332,60 +519,118 @@ export class DataTypesPure extends Contract {
   estimateGas: {
     pure_address(overrides?: CallOverrides): Promise<BigNumber>;
 
+    "pure_address()"(overrides?: CallOverrides): Promise<BigNumber>;
+
     pure_bool(overrides?: CallOverrides): Promise<BigNumber>;
 
+    "pure_bool()"(overrides?: CallOverrides): Promise<BigNumber>;
+
     pure_bytes(overrides?: CallOverrides): Promise<BigNumber>;
 
+    "pure_bytes()"(overrides?: CallOverrides): Promise<BigNumber>;
+
     pure_bytes1(overrides?: CallOverrides): Promise<BigNumber>;
 
+    "pure_bytes1()"(overrides?: CallOverrides): Promise<BigNumber>;
+
     pure_enum(overrides?: CallOverrides): Promise<BigNumber>;
 
+    "pure_enum()"(overrides?: CallOverrides): Promise<BigNumber>;
+
     pure_int256(overrides?: CallOverrides): Promise<BigNumber>;
 
+    "pure_int256()"(overrides?: CallOverrides): Promise<BigNumber>;
+
     pure_int8(overrides?: CallOverrides): Promise<BigNumber>;
 
+    "pure_int8()"(overrides?: CallOverrides): Promise<BigNumber>;
+
     pure_named(overrides?: CallOverrides): Promise<BigNumber>;
 
+    "pure_named()"(overrides?: CallOverrides): Promise<BigNumber>;
+
     pure_stat_array(overrides?: CallOverrides): Promise<BigNumber>;
 
+    "pure_stat_array()"(overrides?: CallOverrides): Promise<BigNumber>;
+
     pure_string(overrides?: CallOverrides): Promise<BigNumber>;
 
+    "pure_string()"(overrides?: CallOverrides): Promise<BigNumber>;
+
     pure_struct(overrides?: CallOverrides): Promise<BigNumber>;
 
+    "pure_struct()"(overrides?: CallOverrides): Promise<BigNumber>;
+
     pure_tuple(overrides?: CallOverrides): Promise<BigNumber>;
 
+    "pure_tuple()"(overrides?: CallOverrides): Promise<BigNumber>;
+
     pure_uint256(overrides?: CallOverrides): Promise<BigNumber>;
 
+    "pure_uint256()"(overrides?: CallOverrides): Promise<BigNumber>;
+
     pure_uint8(overrides?: CallOverrides): Promise<BigNumber>;
+
+    "pure_uint8()"(overrides?: CallOverrides): Promise<BigNumber>;
   };
 
   populateTransaction: {
     pure_address(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
+    "pure_address()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
     pure_bool(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
+    "pure_bool()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
     pure_bytes(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
+    "pure_bytes()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
     pure_bytes1(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
+    "pure_bytes1()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
     pure_enum(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
+    "pure_enum()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
     pure_int256(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
+    "pure_int256()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
     pure_int8(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
+    "pure_int8()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
     pure_named(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
+    "pure_named()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
     pure_stat_array(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
+    "pure_stat_array()"(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
     pure_string(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
+    "pure_string()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
     pure_struct(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
+    "pure_struct()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
     pure_tuple(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
+    "pure_tuple()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
     pure_uint256(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
+    "pure_uint256()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
     pure_uint8(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    "pure_uint8()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
   };
 }
diff --git a/packages/target-ethers-v5-test/types/DataTypesView.d.ts b/packages/target-ethers-v5-test/types/DataTypesView.d.ts
index 3c72c12eb..7b7c7214e 100644
--- a/packages/target-ethers-v5-test/types/DataTypesView.d.ts
+++ b/packages/target-ethers-v5-test/types/DataTypesView.d.ts
@@ -143,42 +143,84 @@ export class DataTypesView extends Contract {
       0: string;
     }>;
 
+    "view_address()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
+
     view_bool(
       overrides?: CallOverrides
     ): Promise<{
       0: boolean;
     }>;
 
+    "view_bool()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: boolean;
+    }>;
+
     view_bytes(
       overrides?: CallOverrides
     ): Promise<{
       0: string;
     }>;
 
+    "view_bytes()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
+
     view_bytes1(
       overrides?: CallOverrides
     ): Promise<{
       0: string;
     }>;
 
+    "view_bytes1()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
+
     view_enum(
       overrides?: CallOverrides
     ): Promise<{
       0: number;
     }>;
 
+    "view_enum()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number;
+    }>;
+
     view_int256(
       overrides?: CallOverrides
     ): Promise<{
       0: BigNumber;
     }>;
 
+    "view_int256()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+    }>;
+
     view_int8(
       overrides?: CallOverrides
     ): Promise<{
       0: number;
     }>;
 
+    "view_int8()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number;
+    }>;
+
     view_named(
       overrides?: CallOverrides
     ): Promise<{
@@ -188,18 +230,39 @@ export class DataTypesView extends Contract {
       1: BigNumber;
     }>;
 
+    "view_named()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      uint256_1: BigNumber;
+      uint256_2: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
     view_stat_array(
       overrides?: CallOverrides
     ): Promise<{
       0: number[];
     }>;
 
+    "view_stat_array()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number[];
+    }>;
+
     view_string(
       overrides?: CallOverrides
     ): Promise<{
       0: string;
     }>;
 
+    "view_string()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: string;
+    }>;
+
     view_struct(
       overrides?: CallOverrides
     ): Promise<{
@@ -211,6 +274,17 @@ export class DataTypesView extends Contract {
       };
     }>;
 
+    "view_struct()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: {
+        uint256_0: BigNumber;
+        uint256_1: BigNumber;
+        0: BigNumber;
+        1: BigNumber;
+      };
+    }>;
+
     view_tuple(
       overrides?: CallOverrides
     ): Promise<{
@@ -218,33 +292,66 @@ export class DataTypesView extends Contract {
       1: BigNumber;
     }>;
 
+    "view_tuple()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
     view_uint256(
       overrides?: CallOverrides
     ): Promise<{
       0: BigNumber;
     }>;
 
+    "view_uint256()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+    }>;
+
     view_uint8(
       overrides?: CallOverrides
     ): Promise<{
       0: number;
     }>;
+
+    "view_uint8()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: number;
+    }>;
   };
 
   view_address(overrides?: CallOverrides): Promise<string>;
 
+  "view_address()"(overrides?: CallOverrides): Promise<string>;
+
   view_bool(overrides?: CallOverrides): Promise<boolean>;
 
+  "view_bool()"(overrides?: CallOverrides): Promise<boolean>;
+
   view_bytes(overrides?: CallOverrides): Promise<string>;
 
+  "view_bytes()"(overrides?: CallOverrides): Promise<string>;
+
   view_bytes1(overrides?: CallOverrides): Promise<string>;
 
+  "view_bytes1()"(overrides?: CallOverrides): Promise<string>;
+
   view_enum(overrides?: CallOverrides): Promise<number>;
 
+  "view_enum()"(overrides?: CallOverrides): Promise<number>;
+
   view_int256(overrides?: CallOverrides): Promise<BigNumber>;
 
+  "view_int256()"(overrides?: CallOverrides): Promise<BigNumber>;
+
   view_int8(overrides?: CallOverrides): Promise<number>;
 
+  "view_int8()"(overrides?: CallOverrides): Promise<number>;
+
   view_named(
     overrides?: CallOverrides
   ): Promise<{
@@ -254,10 +361,23 @@ export class DataTypesView extends Contract {
     1: BigNumber;
   }>;
 
+  "view_named()"(
+    overrides?: CallOverrides
+  ): Promise<{
+    uint256_1: BigNumber;
+    uint256_2: BigNumber;
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
   view_stat_array(overrides?: CallOverrides): Promise<number[]>;
 
+  "view_stat_array()"(overrides?: CallOverrides): Promise<number[]>;
+
   view_string(overrides?: CallOverrides): Promise<string>;
 
+  "view_string()"(overrides?: CallOverrides): Promise<string>;
+
   view_struct(
     overrides?: CallOverrides
   ): Promise<{
@@ -267,6 +387,15 @@ export class DataTypesView extends Contract {
     1: BigNumber;
   }>;
 
+  "view_struct()"(
+    overrides?: CallOverrides
+  ): Promise<{
+    uint256_0: BigNumber;
+    uint256_1: BigNumber;
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
   view_tuple(
     overrides?: CallOverrides
   ): Promise<{
@@ -274,25 +403,50 @@ export class DataTypesView extends Contract {
     1: BigNumber;
   }>;
 
+  "view_tuple()"(
+    overrides?: CallOverrides
+  ): Promise<{
+    0: BigNumber;
+    1: BigNumber;
+  }>;
+
   view_uint256(overrides?: CallOverrides): Promise<BigNumber>;
 
+  "view_uint256()"(overrides?: CallOverrides): Promise<BigNumber>;
+
   view_uint8(overrides?: CallOverrides): Promise<number>;
 
+  "view_uint8()"(overrides?: CallOverrides): Promise<number>;
+
   callStatic: {
     view_address(overrides?: CallOverrides): Promise<string>;
 
+    "view_address()"(overrides?: CallOverrides): Promise<string>;
+
     view_bool(overrides?: CallOverrides): Promise<boolean>;
 
+    "view_bool()"(overrides?: CallOverrides): Promise<boolean>;
+
     view_bytes(overrides?: CallOverrides): Promise<string>;
 
+    "view_bytes()"(overrides?: CallOverrides): Promise<string>;
+
     view_bytes1(overrides?: CallOverrides): Promise<string>;
 
+    "view_bytes1()"(overrides?: CallOverrides): Promise<string>;
+
     view_enum(overrides?: CallOverrides): Promise<number>;
 
+    "view_enum()"(overrides?: CallOverrides): Promise<number>;
+
     view_int256(overrides?: CallOverrides): Promise<BigNumber>;
 
+    "view_int256()"(overrides?: CallOverrides): Promise<BigNumber>;
+
     view_int8(overrides?: CallOverrides): Promise<number>;
 
+    "view_int8()"(overrides?: CallOverrides): Promise<number>;
+
     view_named(
       overrides?: CallOverrides
     ): Promise<{
@@ -302,10 +456,23 @@ export class DataTypesView extends Contract {
       1: BigNumber;
     }>;
 
+    "view_named()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      uint256_1: BigNumber;
+      uint256_2: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
     view_stat_array(overrides?: CallOverrides): Promise<number[]>;
 
+    "view_stat_array()"(overrides?: CallOverrides): Promise<number[]>;
+
     view_string(overrides?: CallOverrides): Promise<string>;
 
+    "view_string()"(overrides?: CallOverrides): Promise<string>;
+
     view_struct(
       overrides?: CallOverrides
     ): Promise<{
@@ -315,6 +482,15 @@ export class DataTypesView extends Contract {
       1: BigNumber;
     }>;
 
+    "view_struct()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      uint256_0: BigNumber;
+      uint256_1: BigNumber;
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
     view_tuple(
       overrides?: CallOverrides
     ): Promise<{
@@ -322,9 +498,20 @@ export class DataTypesView extends Contract {
       1: BigNumber;
     }>;
 
+    "view_tuple()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: BigNumber;
+      1: BigNumber;
+    }>;
+
     view_uint256(overrides?: CallOverrides): Promise<BigNumber>;
 
+    "view_uint256()"(overrides?: CallOverrides): Promise<BigNumber>;
+
     view_uint8(overrides?: CallOverrides): Promise<number>;
+
+    "view_uint8()"(overrides?: CallOverrides): Promise<number>;
   };
 
   filters: {};
@@ -332,60 +519,118 @@ export class DataTypesView extends Contract {
   estimateGas: {
     view_address(overrides?: CallOverrides): Promise<BigNumber>;
 
+    "view_address()"(overrides?: CallOverrides): Promise<BigNumber>;
+
     view_bool(overrides?: CallOverrides): Promise<BigNumber>;
 
+    "view_bool()"(overrides?: CallOverrides): Promise<BigNumber>;
+
     view_bytes(overrides?: CallOverrides): Promise<BigNumber>;
 
+    "view_bytes()"(overrides?: CallOverrides): Promise<BigNumber>;
+
     view_bytes1(overrides?: CallOverrides): Promise<BigNumber>;
 
+    "view_bytes1()"(overrides?: CallOverrides): Promise<BigNumber>;
+
     view_enum(overrides?: CallOverrides): Promise<BigNumber>;
 
+    "view_enum()"(overrides?: CallOverrides): Promise<BigNumber>;
+
     view_int256(overrides?: CallOverrides): Promise<BigNumber>;
 
+    "view_int256()"(overrides?: CallOverrides): Promise<BigNumber>;
+
     view_int8(overrides?: CallOverrides): Promise<BigNumber>;
 
+    "view_int8()"(overrides?: CallOverrides): Promise<BigNumber>;
+
     view_named(overrides?: CallOverrides): Promise<BigNumber>;
 
+    "view_named()"(overrides?: CallOverrides): Promise<BigNumber>;
+
     view_stat_array(overrides?: CallOverrides): Promise<BigNumber>;
 
+    "view_stat_array()"(overrides?: CallOverrides): Promise<BigNumber>;
+
     view_string(overrides?: CallOverrides): Promise<BigNumber>;
 
+    "view_string()"(overrides?: CallOverrides): Promise<BigNumber>;
+
     view_struct(overrides?: CallOverrides): Promise<BigNumber>;
 
+    "view_struct()"(overrides?: CallOverrides): Promise<BigNumber>;
+
     view_tuple(overrides?: CallOverrides): Promise<BigNumber>;
 
+    "view_tuple()"(overrides?: CallOverrides): Promise<BigNumber>;
+
     view_uint256(overrides?: CallOverrides): Promise<BigNumber>;
 
+    "view_uint256()"(overrides?: CallOverrides): Promise<BigNumber>;
+
     view_uint8(overrides?: CallOverrides): Promise<BigNumber>;
+
+    "view_uint8()"(overrides?: CallOverrides): Promise<BigNumber>;
   };
 
   populateTransaction: {
     view_address(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
+    "view_address()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
     view_bool(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
+    "view_bool()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
     view_bytes(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
+    "view_bytes()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
     view_bytes1(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
+    "view_bytes1()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
     view_enum(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
+    "view_enum()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
     view_int256(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
+    "view_int256()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
     view_int8(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
+    "view_int8()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
     view_named(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
+    "view_named()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
     view_stat_array(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
+    "view_stat_array()"(
+      overrides?: CallOverrides
+    ): Promise<PopulatedTransaction>;
+
     view_string(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
+    "view_string()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
     view_struct(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
+    "view_struct()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
     view_tuple(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
+    "view_tuple()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
     view_uint256(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
+    "view_uint256()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
     view_uint8(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    "view_uint8()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
   };
 }
diff --git a/packages/target-ethers-v5-test/types/Events.d.ts b/packages/target-ethers-v5-test/types/Events.d.ts
index a959a2301..cbeda2009 100644
--- a/packages/target-ethers-v5-test/types/Events.d.ts
+++ b/packages/target-ethers-v5-test/types/Events.d.ts
@@ -95,35 +95,69 @@ export class Events extends Contract {
   functions: {
     emit_anon1(overrides?: Overrides): Promise<ContractTransaction>;
 
+    "emit_anon1()"(overrides?: Overrides): Promise<ContractTransaction>;
+
     emit_event1(overrides?: Overrides): Promise<ContractTransaction>;
 
+    "emit_event1()"(overrides?: Overrides): Promise<ContractTransaction>;
+
     emit_event2(overrides?: Overrides): Promise<ContractTransaction>;
 
+    "emit_event2()"(overrides?: Overrides): Promise<ContractTransaction>;
+
     emit_event3(overrides?: Overrides): Promise<ContractTransaction>;
 
+    "emit_event3()"(overrides?: Overrides): Promise<ContractTransaction>;
+
     emit_event3_overloaded(overrides?: Overrides): Promise<ContractTransaction>;
+
+    "emit_event3_overloaded()"(
+      overrides?: Overrides
+    ): Promise<ContractTransaction>;
   };
 
   emit_anon1(overrides?: Overrides): Promise<ContractTransaction>;
 
+  "emit_anon1()"(overrides?: Overrides): Promise<ContractTransaction>;
+
   emit_event1(overrides?: Overrides): Promise<ContractTransaction>;
 
+  "emit_event1()"(overrides?: Overrides): Promise<ContractTransaction>;
+
   emit_event2(overrides?: Overrides): Promise<ContractTransaction>;
 
+  "emit_event2()"(overrides?: Overrides): Promise<ContractTransaction>;
+
   emit_event3(overrides?: Overrides): Promise<ContractTransaction>;
 
+  "emit_event3()"(overrides?: Overrides): Promise<ContractTransaction>;
+
   emit_event3_overloaded(overrides?: Overrides): Promise<ContractTransaction>;
 
+  "emit_event3_overloaded()"(
+    overrides?: Overrides
+  ): Promise<ContractTransaction>;
+
   callStatic: {
     emit_anon1(overrides?: Overrides): Promise<void>;
 
+    "emit_anon1()"(overrides?: Overrides): Promise<void>;
+
     emit_event1(overrides?: Overrides): Promise<void>;
 
+    "emit_event1()"(overrides?: Overrides): Promise<void>;
+
     emit_event2(overrides?: Overrides): Promise<void>;
 
+    "emit_event2()"(overrides?: Overrides): Promise<void>;
+
     emit_event3(overrides?: Overrides): Promise<void>;
 
+    "emit_event3()"(overrides?: Overrides): Promise<void>;
+
     emit_event3_overloaded(overrides?: Overrides): Promise<void>;
+
+    "emit_event3_overloaded()"(overrides?: Overrides): Promise<void>;
   };
 
   filters: {
@@ -139,26 +173,48 @@ export class Events extends Contract {
   estimateGas: {
     emit_anon1(overrides?: Overrides): Promise<BigNumber>;
 
+    "emit_anon1()"(overrides?: Overrides): Promise<BigNumber>;
+
     emit_event1(overrides?: Overrides): Promise<BigNumber>;
 
+    "emit_event1()"(overrides?: Overrides): Promise<BigNumber>;
+
     emit_event2(overrides?: Overrides): Promise<BigNumber>;
 
+    "emit_event2()"(overrides?: Overrides): Promise<BigNumber>;
+
     emit_event3(overrides?: Overrides): Promise<BigNumber>;
 
+    "emit_event3()"(overrides?: Overrides): Promise<BigNumber>;
+
     emit_event3_overloaded(overrides?: Overrides): Promise<BigNumber>;
+
+    "emit_event3_overloaded()"(overrides?: Overrides): Promise<BigNumber>;
   };
 
   populateTransaction: {
     emit_anon1(overrides?: Overrides): Promise<PopulatedTransaction>;
 
+    "emit_anon1()"(overrides?: Overrides): Promise<PopulatedTransaction>;
+
     emit_event1(overrides?: Overrides): Promise<PopulatedTransaction>;
 
+    "emit_event1()"(overrides?: Overrides): Promise<PopulatedTransaction>;
+
     emit_event2(overrides?: Overrides): Promise<PopulatedTransaction>;
 
+    "emit_event2()"(overrides?: Overrides): Promise<PopulatedTransaction>;
+
     emit_event3(overrides?: Overrides): Promise<PopulatedTransaction>;
 
+    "emit_event3()"(overrides?: Overrides): Promise<PopulatedTransaction>;
+
     emit_event3_overloaded(
       overrides?: Overrides
     ): Promise<PopulatedTransaction>;
+
+    "emit_event3_overloaded()"(
+      overrides?: Overrides
+    ): Promise<PopulatedTransaction>;
   };
 }
diff --git a/packages/target-ethers-v5-test/types/NameMangling.d.ts b/packages/target-ethers-v5-test/types/NameMangling.d.ts
index 003f60f06..ac2abd352 100644
--- a/packages/target-ethers-v5-test/types/NameMangling.d.ts
+++ b/packages/target-ethers-v5-test/types/NameMangling.d.ts
@@ -49,21 +49,35 @@ export class NameMangling extends Contract {
     ): Promise<{
       0: boolean;
     }>;
+
+    "works()"(
+      overrides?: CallOverrides
+    ): Promise<{
+      0: boolean;
+    }>;
   };
 
   works(overrides?: CallOverrides): Promise<boolean>;
 
+  "works()"(overrides?: CallOverrides): Promise<boolean>;
+
   callStatic: {
     works(overrides?: CallOverrides): Promise<boolean>;
+
+    "works()"(overrides?: CallOverrides): Promise<boolean>;
   };
 
   filters: {};
 
   estimateGas: {
     works(overrides?: CallOverrides): Promise<BigNumber>;
+
+    "works()"(overrides?: CallOverrides): Promise<BigNumber>;
   };
 
   populateTransaction: {
     works(overrides?: CallOverrides): Promise<PopulatedTransaction>;
+
+    "works()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
   };
 }
diff --git a/packages/target-ethers-v5-test/types/Payable.d.ts b/packages/target-ethers-v5-test/types/Payable.d.ts
index 8a36dc317..3054174ef 100644
--- a/packages/target-ethers-v5-test/types/Payable.d.ts
+++ b/packages/target-ethers-v5-test/types/Payable.d.ts
@@ -62,17 +62,31 @@ export class Payable extends Contract {
   functions: {
     non_payable_func(overrides?: Overrides): Promise<ContractTransaction>;
 
+    "non_payable_func()"(overrides?: Overrides): Promise<ContractTransaction>;
+
     payable_func(overrides?: PayableOverrides): Promise<ContractTransaction>;
+
+    "payable_func()"(
+      overrides?: PayableOverrides
+    ): Promise<ContractTransaction>;
   };
 
   non_payable_func(overrides?: Overrides): Promise<ContractTransaction>;
 
+  "non_payable_func()"(overrides?: Overrides): Promise<ContractTransaction>;
+
   payable_func(overrides?: PayableOverrides): Promise<ContractTransaction>;
 
+  "payable_func()"(overrides?: PayableOverrides): Promise<ContractTransaction>;
+
   callStatic: {
     non_payable_func(overrides?: Overrides): Promise<void>;
 
+    "non_payable_func()"(overrides?: Overrides): Promise<void>;
+
     payable_func(overrides?: PayableOverrides): Promise<void>;
+
+    "payable_func()"(overrides?: PayableOverrides): Promise<void>;
   };
 
   filters: {};
@@ -80,12 +94,22 @@ export class Payable extends Contract {
   estimateGas: {
     non_payable_func(overrides?: Overrides): Promise<BigNumber>;
 
+    "non_payable_func()"(overrides?: Overrides): Promise<BigNumber>;
+
     payable_func(overrides?: PayableOverrides): Promise<BigNumber>;
+
+    "payable_func()"(overrides?: PayableOverrides): Promise<BigNumber>;
   };
 
   populateTransaction: {
     non_payable_func(overrides?: Overrides): Promise<PopulatedTransaction>;
 
+    "non_payable_func()"(overrides?: Overrides): Promise<PopulatedTransaction>;
+
     payable_func(overrides?: PayableOverrides): Promise<PopulatedTransaction>;
+
+    "payable_func()"(
+      overrides?: PayableOverrides
+    ): Promise<PopulatedTransaction>;
   };
 }
diff --git a/packages/target-ethers-v5/src/codegen/functions.ts b/packages/target-ethers-v5/src/codegen/functions.ts
index 72df31494..fd6d9a6ef 100644
--- a/packages/target-ethers-v5/src/codegen/functions.ts
+++ b/packages/target-ethers-v5/src/codegen/functions.ts
@@ -31,11 +31,12 @@ function generateFunction(options: GenerateFunctionOptions, fn: FunctionDeclarat
       ? `overrides?: ${isPayable(fn) ? 'PayableOverrides' : 'Overrides'}`
       : 'overrides?: CallOverrides'
   }): ${
-    options.overrideOutput ?? `Promise<${
-          options.isStaticCall || fn.stateMutability === 'pure' || fn.stateMutability === 'view'
-            ? generateOutputTypes(!!options.returnResultObject, fn.outputs)
-            : 'ContractTransaction'
-        }>`
+    options.overrideOutput ??
+    `Promise<${
+      options.isStaticCall || fn.stateMutability === 'pure' || fn.stateMutability === 'view'
+        ? generateOutputTypes(!!options.returnResultObject, fn.outputs)
+        : 'ContractTransaction'
+    }>`
   };
 `
 }

From a99ff795d4c3cc82b4e4a592506373304d2ae887 Mon Sep 17 00:00:00 2001
From: Braden Napier <brady.napier@dashos.net>
Date: Thu, 9 Jul 2020 05:12:54 -0400
Subject: [PATCH 51/64] fix: remove ethersv4 changes addidentally added

---
 .../types/DataTypesInput.d.ts                 | 425 +++---------------
 .../types/DataTypesPure.d.ts                  | 218 ++-------
 .../types/DataTypesView.d.ts                  | 218 ++-------
 .../target-ethers-v4-test/types/Events.d.ts   |  64 +--
 .../types/NameMangling.d.ts                   |  12 +-
 .../types/Overloads.d.ts                      |  42 +-
 .../target-ethers-v4-test/types/Payable.d.ts  |  24 +-
 7 files changed, 152 insertions(+), 851 deletions(-)

diff --git a/packages/target-ethers-v4-test/types/DataTypesInput.d.ts b/packages/target-ethers-v4-test/types/DataTypesInput.d.ts
index 572887d63..6ab731907 100644
--- a/packages/target-ethers-v4-test/types/DataTypesInput.d.ts
+++ b/packages/target-ethers-v4-test/types/DataTypesInput.d.ts
@@ -87,110 +87,28 @@ export class DataTypesInput extends Contract {
   interface: DataTypesInputInterface;
 
   functions: {
-    input_address(
-      input1: string,
-      overrides?: TransactionOverrides
-    ): Promise<string>;
-
-    "input_address(address)"(
-      input1: string,
-      overrides?: TransactionOverrides
-    ): Promise<string>;
-
-    input_bool(
-      input1: boolean,
-      overrides?: TransactionOverrides
-    ): Promise<boolean>;
-
-    "input_bool(bool)"(
-      input1: boolean,
-      overrides?: TransactionOverrides
-    ): Promise<boolean>;
-
-    input_bytes(
-      input1: Arrayish,
-      overrides?: TransactionOverrides
-    ): Promise<string>;
-
-    "input_bytes(bytes)"(
-      input1: Arrayish,
-      overrides?: TransactionOverrides
-    ): Promise<string>;
-
-    input_bytes1(
-      input1: Arrayish,
-      overrides?: TransactionOverrides
-    ): Promise<string>;
-
-    "input_bytes1(bytes1)"(
-      input1: Arrayish,
-      overrides?: TransactionOverrides
-    ): Promise<string>;
-
-    input_enum(
-      input1: BigNumberish,
-      overrides?: TransactionOverrides
-    ): Promise<number>;
+    input_address(input1: string): Promise<string>;
 
-    "input_enum(uint8)"(
-      input1: BigNumberish,
-      overrides?: TransactionOverrides
-    ): Promise<number>;
+    input_bool(input1: boolean): Promise<boolean>;
 
-    input_int256(
-      input1: BigNumberish,
-      overrides?: TransactionOverrides
-    ): Promise<BigNumber>;
+    input_bytes(input1: Arrayish): Promise<string>;
 
-    "input_int256(int256)"(
-      input1: BigNumberish,
-      overrides?: TransactionOverrides
-    ): Promise<BigNumber>;
+    input_bytes1(input1: Arrayish): Promise<string>;
 
-    input_int8(
-      input1: BigNumberish,
-      overrides?: TransactionOverrides
-    ): Promise<number>;
+    input_enum(input1: BigNumberish): Promise<number>;
 
-    "input_int8(int8)"(
-      input1: BigNumberish,
-      overrides?: TransactionOverrides
-    ): Promise<number>;
-
-    input_stat_array(
-      input1: BigNumberish[],
-      overrides?: TransactionOverrides
-    ): Promise<number[]>;
-
-    "input_stat_array(uint8[3])"(
-      input1: BigNumberish[],
-      overrides?: TransactionOverrides
-    ): Promise<number[]>;
-
-    input_string(
-      input1: string,
-      overrides?: TransactionOverrides
-    ): Promise<string>;
-
-    "input_string(string)"(
-      input1: string,
-      overrides?: TransactionOverrides
-    ): Promise<string>;
-
-    input_struct(
-      input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
-      overrides?: TransactionOverrides
-    ): Promise<{
-      uint256_0: BigNumber;
-      uint256_1: BigNumber;
-      0: BigNumber;
-      1: BigNumber;
-    }>;
+    input_int256(input1: BigNumberish): Promise<BigNumber>;
 
-    "input_struct(tuple)"(
-      input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
-      overrides?: TransactionOverrides
-    ): Promise<{
+    input_int8(input1: BigNumberish): Promise<number>;
+
+    input_stat_array(input1: BigNumberish[]): Promise<number[]>;
+
+    input_string(input1: string): Promise<string>;
+
+    input_struct(input1: {
+      uint256_0: BigNumberish;
+      uint256_1: BigNumberish;
+    }): Promise<{
       uint256_0: BigNumber;
       uint256_1: BigNumber;
       0: BigNumber;
@@ -199,147 +117,39 @@ export class DataTypesInput extends Contract {
 
     input_tuple(
       input1: BigNumberish,
-      input2: BigNumberish,
-      overrides?: TransactionOverrides
+      input2: BigNumberish
     ): Promise<{
       0: BigNumber;
       1: BigNumber;
     }>;
 
-    "input_tuple(uint256,uint256)"(
-      input1: BigNumberish,
-      input2: BigNumberish,
-      overrides?: TransactionOverrides
-    ): Promise<{
-      0: BigNumber;
-      1: BigNumber;
-    }>;
+    input_uint256(input1: BigNumberish): Promise<BigNumber>;
 
-    input_uint256(
-      input1: BigNumberish,
-      overrides?: TransactionOverrides
-    ): Promise<BigNumber>;
+    input_uint8(input1: BigNumberish): Promise<number>;
+  };
 
-    "input_uint256(uint256)"(
-      input1: BigNumberish,
-      overrides?: TransactionOverrides
-    ): Promise<BigNumber>;
+  input_address(input1: string): Promise<string>;
 
-    input_uint8(
-      input1: BigNumberish,
-      overrides?: TransactionOverrides
-    ): Promise<number>;
+  input_bool(input1: boolean): Promise<boolean>;
 
-    "input_uint8(uint8)"(
-      input1: BigNumberish,
-      overrides?: TransactionOverrides
-    ): Promise<number>;
-  };
+  input_bytes(input1: Arrayish): Promise<string>;
 
-  input_address(
-    input1: string,
-    overrides?: TransactionOverrides
-  ): Promise<string>;
-
-  "input_address(address)"(
-    input1: string,
-    overrides?: TransactionOverrides
-  ): Promise<string>;
-
-  input_bool(
-    input1: boolean,
-    overrides?: TransactionOverrides
-  ): Promise<boolean>;
-
-  "input_bool(bool)"(
-    input1: boolean,
-    overrides?: TransactionOverrides
-  ): Promise<boolean>;
-
-  input_bytes(
-    input1: Arrayish,
-    overrides?: TransactionOverrides
-  ): Promise<string>;
-
-  "input_bytes(bytes)"(
-    input1: Arrayish,
-    overrides?: TransactionOverrides
-  ): Promise<string>;
-
-  input_bytes1(
-    input1: Arrayish,
-    overrides?: TransactionOverrides
-  ): Promise<string>;
-
-  "input_bytes1(bytes1)"(
-    input1: Arrayish,
-    overrides?: TransactionOverrides
-  ): Promise<string>;
-
-  input_enum(
-    input1: BigNumberish,
-    overrides?: TransactionOverrides
-  ): Promise<number>;
+  input_bytes1(input1: Arrayish): Promise<string>;
 
-  "input_enum(uint8)"(
-    input1: BigNumberish,
-    overrides?: TransactionOverrides
-  ): Promise<number>;
+  input_enum(input1: BigNumberish): Promise<number>;
 
-  input_int256(
-    input1: BigNumberish,
-    overrides?: TransactionOverrides
-  ): Promise<BigNumber>;
+  input_int256(input1: BigNumberish): Promise<BigNumber>;
 
-  "input_int256(int256)"(
-    input1: BigNumberish,
-    overrides?: TransactionOverrides
-  ): Promise<BigNumber>;
+  input_int8(input1: BigNumberish): Promise<number>;
 
-  input_int8(
-    input1: BigNumberish,
-    overrides?: TransactionOverrides
-  ): Promise<number>;
+  input_stat_array(input1: BigNumberish[]): Promise<number[]>;
 
-  "input_int8(int8)"(
-    input1: BigNumberish,
-    overrides?: TransactionOverrides
-  ): Promise<number>;
-
-  input_stat_array(
-    input1: BigNumberish[],
-    overrides?: TransactionOverrides
-  ): Promise<number[]>;
-
-  "input_stat_array(uint8[3])"(
-    input1: BigNumberish[],
-    overrides?: TransactionOverrides
-  ): Promise<number[]>;
-
-  input_string(
-    input1: string,
-    overrides?: TransactionOverrides
-  ): Promise<string>;
-
-  "input_string(string)"(
-    input1: string,
-    overrides?: TransactionOverrides
-  ): Promise<string>;
-
-  input_struct(
-    input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
-    overrides?: TransactionOverrides
-  ): Promise<{
-    uint256_0: BigNumber;
-    uint256_1: BigNumber;
-    0: BigNumber;
-    1: BigNumber;
-  }>;
+  input_string(input1: string): Promise<string>;
 
-  "input_struct(tuple)"(
-    input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
-    overrides?: TransactionOverrides
-  ): Promise<{
+  input_struct(input1: {
+    uint256_0: BigNumberish;
+    uint256_1: BigNumberish;
+  }): Promise<{
     uint256_0: BigNumber;
     uint256_1: BigNumber;
     0: BigNumber;
@@ -348,175 +158,46 @@ export class DataTypesInput extends Contract {
 
   input_tuple(
     input1: BigNumberish,
-    input2: BigNumberish,
-    overrides?: TransactionOverrides
+    input2: BigNumberish
   ): Promise<{
     0: BigNumber;
     1: BigNumber;
   }>;
 
-  "input_tuple(uint256,uint256)"(
-    input1: BigNumberish,
-    input2: BigNumberish,
-    overrides?: TransactionOverrides
-  ): Promise<{
-    0: BigNumber;
-    1: BigNumber;
-  }>;
-
-  input_uint256(
-    input1: BigNumberish,
-    overrides?: TransactionOverrides
-  ): Promise<BigNumber>;
-
-  "input_uint256(uint256)"(
-    input1: BigNumberish,
-    overrides?: TransactionOverrides
-  ): Promise<BigNumber>;
+  input_uint256(input1: BigNumberish): Promise<BigNumber>;
 
-  input_uint8(
-    input1: BigNumberish,
-    overrides?: TransactionOverrides
-  ): Promise<number>;
-
-  "input_uint8(uint8)"(
-    input1: BigNumberish,
-    overrides?: TransactionOverrides
-  ): Promise<number>;
+  input_uint8(input1: BigNumberish): Promise<number>;
 
   filters: {};
 
   estimate: {
-    input_address(
-      input1: string,
-      overrides?: TransactionOverrides
-    ): Promise<BigNumber>;
-
-    "input_address(address)"(
-      input1: string,
-      overrides?: TransactionOverrides
-    ): Promise<BigNumber>;
-
-    input_bool(
-      input1: boolean,
-      overrides?: TransactionOverrides
-    ): Promise<BigNumber>;
-
-    "input_bool(bool)"(
-      input1: boolean,
-      overrides?: TransactionOverrides
-    ): Promise<BigNumber>;
-
-    input_bytes(
-      input1: Arrayish,
-      overrides?: TransactionOverrides
-    ): Promise<BigNumber>;
-
-    "input_bytes(bytes)"(
-      input1: Arrayish,
-      overrides?: TransactionOverrides
-    ): Promise<BigNumber>;
-
-    input_bytes1(
-      input1: Arrayish,
-      overrides?: TransactionOverrides
-    ): Promise<BigNumber>;
-
-    "input_bytes1(bytes1)"(
-      input1: Arrayish,
-      overrides?: TransactionOverrides
-    ): Promise<BigNumber>;
-
-    input_enum(
-      input1: BigNumberish,
-      overrides?: TransactionOverrides
-    ): Promise<BigNumber>;
+    input_address(input1: string): Promise<BigNumber>;
 
-    "input_enum(uint8)"(
-      input1: BigNumberish,
-      overrides?: TransactionOverrides
-    ): Promise<BigNumber>;
+    input_bool(input1: boolean): Promise<BigNumber>;
 
-    input_int256(
-      input1: BigNumberish,
-      overrides?: TransactionOverrides
-    ): Promise<BigNumber>;
+    input_bytes(input1: Arrayish): Promise<BigNumber>;
 
-    "input_int256(int256)"(
-      input1: BigNumberish,
-      overrides?: TransactionOverrides
-    ): Promise<BigNumber>;
+    input_bytes1(input1: Arrayish): Promise<BigNumber>;
 
-    input_int8(
-      input1: BigNumberish,
-      overrides?: TransactionOverrides
-    ): Promise<BigNumber>;
+    input_enum(input1: BigNumberish): Promise<BigNumber>;
 
-    "input_int8(int8)"(
-      input1: BigNumberish,
-      overrides?: TransactionOverrides
-    ): Promise<BigNumber>;
-
-    input_stat_array(
-      input1: BigNumberish[],
-      overrides?: TransactionOverrides
-    ): Promise<BigNumber>;
-
-    "input_stat_array(uint8[3])"(
-      input1: BigNumberish[],
-      overrides?: TransactionOverrides
-    ): Promise<BigNumber>;
-
-    input_string(
-      input1: string,
-      overrides?: TransactionOverrides
-    ): Promise<BigNumber>;
-
-    "input_string(string)"(
-      input1: string,
-      overrides?: TransactionOverrides
-    ): Promise<BigNumber>;
-
-    input_struct(
-      input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
-      overrides?: TransactionOverrides
-    ): Promise<BigNumber>;
-
-    "input_struct(tuple)"(
-      input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
-      overrides?: TransactionOverrides
-    ): Promise<BigNumber>;
+    input_int256(input1: BigNumberish): Promise<BigNumber>;
 
-    input_tuple(
-      input1: BigNumberish,
-      input2: BigNumberish,
-      overrides?: TransactionOverrides
-    ): Promise<BigNumber>;
+    input_int8(input1: BigNumberish): Promise<BigNumber>;
 
-    "input_tuple(uint256,uint256)"(
-      input1: BigNumberish,
-      input2: BigNumberish,
-      overrides?: TransactionOverrides
-    ): Promise<BigNumber>;
+    input_stat_array(input1: BigNumberish[]): Promise<BigNumber>;
 
-    input_uint256(
-      input1: BigNumberish,
-      overrides?: TransactionOverrides
-    ): Promise<BigNumber>;
+    input_string(input1: string): Promise<BigNumber>;
 
-    "input_uint256(uint256)"(
-      input1: BigNumberish,
-      overrides?: TransactionOverrides
-    ): Promise<BigNumber>;
+    input_struct(input1: {
+      uint256_0: BigNumberish;
+      uint256_1: BigNumberish;
+    }): Promise<BigNumber>;
 
-    input_uint8(
-      input1: BigNumberish,
-      overrides?: TransactionOverrides
-    ): Promise<BigNumber>;
+    input_tuple(input1: BigNumberish, input2: BigNumberish): Promise<BigNumber>;
 
-    "input_uint8(uint8)"(
-      input1: BigNumberish,
-      overrides?: TransactionOverrides
-    ): Promise<BigNumber>;
+    input_uint256(input1: BigNumberish): Promise<BigNumber>;
+
+    input_uint8(input1: BigNumberish): Promise<BigNumber>;
   };
 }
diff --git a/packages/target-ethers-v4-test/types/DataTypesPure.d.ts b/packages/target-ethers-v4-test/types/DataTypesPure.d.ts
index 80b7d9ad2..6e81fa219 100644
--- a/packages/target-ethers-v4-test/types/DataTypesPure.d.ts
+++ b/packages/target-ethers-v4-test/types/DataTypesPure.d.ts
@@ -61,252 +61,118 @@ export class DataTypesPure extends Contract {
   interface: DataTypesPureInterface;
 
   functions: {
-    pure_address(overrides?: TransactionOverrides): Promise<string>;
+    pure_address(): Promise<string>;
 
-    "pure_address()"(overrides?: TransactionOverrides): Promise<string>;
+    pure_bool(): Promise<boolean>;
 
-    pure_bool(overrides?: TransactionOverrides): Promise<boolean>;
+    pure_bytes(): Promise<string>;
 
-    "pure_bool()"(overrides?: TransactionOverrides): Promise<boolean>;
+    pure_bytes1(): Promise<string>;
 
-    pure_bytes(overrides?: TransactionOverrides): Promise<string>;
+    pure_enum(): Promise<number>;
 
-    "pure_bytes()"(overrides?: TransactionOverrides): Promise<string>;
+    pure_int256(): Promise<BigNumber>;
 
-    pure_bytes1(overrides?: TransactionOverrides): Promise<string>;
+    pure_int8(): Promise<number>;
 
-    "pure_bytes1()"(overrides?: TransactionOverrides): Promise<string>;
-
-    pure_enum(overrides?: TransactionOverrides): Promise<number>;
-
-    "pure_enum()"(overrides?: TransactionOverrides): Promise<number>;
-
-    pure_int256(overrides?: TransactionOverrides): Promise<BigNumber>;
-
-    "pure_int256()"(overrides?: TransactionOverrides): Promise<BigNumber>;
-
-    pure_int8(overrides?: TransactionOverrides): Promise<number>;
-
-    "pure_int8()"(overrides?: TransactionOverrides): Promise<number>;
-
-    pure_named(
-      overrides?: TransactionOverrides
-    ): Promise<{
+    pure_named(): Promise<{
       uint256_1: BigNumber;
       uint256_2: BigNumber;
       0: BigNumber;
       1: BigNumber;
     }>;
 
-    "pure_named()"(
-      overrides?: TransactionOverrides
-    ): Promise<{
-      uint256_1: BigNumber;
-      uint256_2: BigNumber;
-      0: BigNumber;
-      1: BigNumber;
-    }>;
-
-    pure_stat_array(overrides?: TransactionOverrides): Promise<number[]>;
+    pure_stat_array(): Promise<number[]>;
 
-    "pure_stat_array()"(overrides?: TransactionOverrides): Promise<number[]>;
-
-    pure_string(overrides?: TransactionOverrides): Promise<string>;
-
-    "pure_string()"(overrides?: TransactionOverrides): Promise<string>;
-
-    pure_struct(
-      overrides?: TransactionOverrides
-    ): Promise<{
-      uint256_0: BigNumber;
-      uint256_1: BigNumber;
-      0: BigNumber;
-      1: BigNumber;
-    }>;
+    pure_string(): Promise<string>;
 
-    "pure_struct()"(
-      overrides?: TransactionOverrides
-    ): Promise<{
+    pure_struct(): Promise<{
       uint256_0: BigNumber;
       uint256_1: BigNumber;
       0: BigNumber;
       1: BigNumber;
     }>;
 
-    pure_tuple(
-      overrides?: TransactionOverrides
-    ): Promise<{
+    pure_tuple(): Promise<{
       0: BigNumber;
       1: BigNumber;
     }>;
 
-    "pure_tuple()"(
-      overrides?: TransactionOverrides
-    ): Promise<{
-      0: BigNumber;
-      1: BigNumber;
-    }>;
-
-    pure_uint256(overrides?: TransactionOverrides): Promise<BigNumber>;
-
-    "pure_uint256()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+    pure_uint256(): Promise<BigNumber>;
 
-    pure_uint8(overrides?: TransactionOverrides): Promise<number>;
-
-    "pure_uint8()"(overrides?: TransactionOverrides): Promise<number>;
+    pure_uint8(): Promise<number>;
   };
 
-  pure_address(overrides?: TransactionOverrides): Promise<string>;
-
-  "pure_address()"(overrides?: TransactionOverrides): Promise<string>;
-
-  pure_bool(overrides?: TransactionOverrides): Promise<boolean>;
-
-  "pure_bool()"(overrides?: TransactionOverrides): Promise<boolean>;
-
-  pure_bytes(overrides?: TransactionOverrides): Promise<string>;
-
-  "pure_bytes()"(overrides?: TransactionOverrides): Promise<string>;
-
-  pure_bytes1(overrides?: TransactionOverrides): Promise<string>;
-
-  "pure_bytes1()"(overrides?: TransactionOverrides): Promise<string>;
+  pure_address(): Promise<string>;
 
-  pure_enum(overrides?: TransactionOverrides): Promise<number>;
+  pure_bool(): Promise<boolean>;
 
-  "pure_enum()"(overrides?: TransactionOverrides): Promise<number>;
+  pure_bytes(): Promise<string>;
 
-  pure_int256(overrides?: TransactionOverrides): Promise<BigNumber>;
+  pure_bytes1(): Promise<string>;
 
-  "pure_int256()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+  pure_enum(): Promise<number>;
 
-  pure_int8(overrides?: TransactionOverrides): Promise<number>;
+  pure_int256(): Promise<BigNumber>;
 
-  "pure_int8()"(overrides?: TransactionOverrides): Promise<number>;
+  pure_int8(): Promise<number>;
 
-  pure_named(
-    overrides?: TransactionOverrides
-  ): Promise<{
+  pure_named(): Promise<{
     uint256_1: BigNumber;
     uint256_2: BigNumber;
     0: BigNumber;
     1: BigNumber;
   }>;
 
-  "pure_named()"(
-    overrides?: TransactionOverrides
-  ): Promise<{
-    uint256_1: BigNumber;
-    uint256_2: BigNumber;
-    0: BigNumber;
-    1: BigNumber;
-  }>;
+  pure_stat_array(): Promise<number[]>;
 
-  pure_stat_array(overrides?: TransactionOverrides): Promise<number[]>;
+  pure_string(): Promise<string>;
 
-  "pure_stat_array()"(overrides?: TransactionOverrides): Promise<number[]>;
-
-  pure_string(overrides?: TransactionOverrides): Promise<string>;
-
-  "pure_string()"(overrides?: TransactionOverrides): Promise<string>;
-
-  pure_struct(
-    overrides?: TransactionOverrides
-  ): Promise<{
+  pure_struct(): Promise<{
     uint256_0: BigNumber;
     uint256_1: BigNumber;
     0: BigNumber;
     1: BigNumber;
   }>;
 
-  "pure_struct()"(
-    overrides?: TransactionOverrides
-  ): Promise<{
-    uint256_0: BigNumber;
-    uint256_1: BigNumber;
-    0: BigNumber;
-    1: BigNumber;
-  }>;
-
-  pure_tuple(
-    overrides?: TransactionOverrides
-  ): Promise<{
-    0: BigNumber;
-    1: BigNumber;
-  }>;
-
-  "pure_tuple()"(
-    overrides?: TransactionOverrides
-  ): Promise<{
+  pure_tuple(): Promise<{
     0: BigNumber;
     1: BigNumber;
   }>;
 
-  pure_uint256(overrides?: TransactionOverrides): Promise<BigNumber>;
-
-  "pure_uint256()"(overrides?: TransactionOverrides): Promise<BigNumber>;
-
-  pure_uint8(overrides?: TransactionOverrides): Promise<number>;
+  pure_uint256(): Promise<BigNumber>;
 
-  "pure_uint8()"(overrides?: TransactionOverrides): Promise<number>;
+  pure_uint8(): Promise<number>;
 
   filters: {};
 
   estimate: {
-    pure_address(overrides?: TransactionOverrides): Promise<BigNumber>;
-
-    "pure_address()"(overrides?: TransactionOverrides): Promise<BigNumber>;
-
-    pure_bool(overrides?: TransactionOverrides): Promise<BigNumber>;
-
-    "pure_bool()"(overrides?: TransactionOverrides): Promise<BigNumber>;
-
-    pure_bytes(overrides?: TransactionOverrides): Promise<BigNumber>;
-
-    "pure_bytes()"(overrides?: TransactionOverrides): Promise<BigNumber>;
-
-    pure_bytes1(overrides?: TransactionOverrides): Promise<BigNumber>;
-
-    "pure_bytes1()"(overrides?: TransactionOverrides): Promise<BigNumber>;
-
-    pure_enum(overrides?: TransactionOverrides): Promise<BigNumber>;
-
-    "pure_enum()"(overrides?: TransactionOverrides): Promise<BigNumber>;
-
-    pure_int256(overrides?: TransactionOverrides): Promise<BigNumber>;
-
-    "pure_int256()"(overrides?: TransactionOverrides): Promise<BigNumber>;
-
-    pure_int8(overrides?: TransactionOverrides): Promise<BigNumber>;
-
-    "pure_int8()"(overrides?: TransactionOverrides): Promise<BigNumber>;
-
-    pure_named(overrides?: TransactionOverrides): Promise<BigNumber>;
+    pure_address(): Promise<BigNumber>;
 
-    "pure_named()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+    pure_bool(): Promise<BigNumber>;
 
-    pure_stat_array(overrides?: TransactionOverrides): Promise<BigNumber>;
+    pure_bytes(): Promise<BigNumber>;
 
-    "pure_stat_array()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+    pure_bytes1(): Promise<BigNumber>;
 
-    pure_string(overrides?: TransactionOverrides): Promise<BigNumber>;
+    pure_enum(): Promise<BigNumber>;
 
-    "pure_string()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+    pure_int256(): Promise<BigNumber>;
 
-    pure_struct(overrides?: TransactionOverrides): Promise<BigNumber>;
+    pure_int8(): Promise<BigNumber>;
 
-    "pure_struct()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+    pure_named(): Promise<BigNumber>;
 
-    pure_tuple(overrides?: TransactionOverrides): Promise<BigNumber>;
+    pure_stat_array(): Promise<BigNumber>;
 
-    "pure_tuple()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+    pure_string(): Promise<BigNumber>;
 
-    pure_uint256(overrides?: TransactionOverrides): Promise<BigNumber>;
+    pure_struct(): Promise<BigNumber>;
 
-    "pure_uint256()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+    pure_tuple(): Promise<BigNumber>;
 
-    pure_uint8(overrides?: TransactionOverrides): Promise<BigNumber>;
+    pure_uint256(): Promise<BigNumber>;
 
-    "pure_uint8()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+    pure_uint8(): Promise<BigNumber>;
   };
 }
diff --git a/packages/target-ethers-v4-test/types/DataTypesView.d.ts b/packages/target-ethers-v4-test/types/DataTypesView.d.ts
index 9ec7bf803..d489c6ba3 100644
--- a/packages/target-ethers-v4-test/types/DataTypesView.d.ts
+++ b/packages/target-ethers-v4-test/types/DataTypesView.d.ts
@@ -61,252 +61,118 @@ export class DataTypesView extends Contract {
   interface: DataTypesViewInterface;
 
   functions: {
-    view_address(overrides?: TransactionOverrides): Promise<string>;
+    view_address(): Promise<string>;
 
-    "view_address()"(overrides?: TransactionOverrides): Promise<string>;
+    view_bool(): Promise<boolean>;
 
-    view_bool(overrides?: TransactionOverrides): Promise<boolean>;
+    view_bytes(): Promise<string>;
 
-    "view_bool()"(overrides?: TransactionOverrides): Promise<boolean>;
+    view_bytes1(): Promise<string>;
 
-    view_bytes(overrides?: TransactionOverrides): Promise<string>;
+    view_enum(): Promise<number>;
 
-    "view_bytes()"(overrides?: TransactionOverrides): Promise<string>;
+    view_int256(): Promise<BigNumber>;
 
-    view_bytes1(overrides?: TransactionOverrides): Promise<string>;
+    view_int8(): Promise<number>;
 
-    "view_bytes1()"(overrides?: TransactionOverrides): Promise<string>;
-
-    view_enum(overrides?: TransactionOverrides): Promise<number>;
-
-    "view_enum()"(overrides?: TransactionOverrides): Promise<number>;
-
-    view_int256(overrides?: TransactionOverrides): Promise<BigNumber>;
-
-    "view_int256()"(overrides?: TransactionOverrides): Promise<BigNumber>;
-
-    view_int8(overrides?: TransactionOverrides): Promise<number>;
-
-    "view_int8()"(overrides?: TransactionOverrides): Promise<number>;
-
-    view_named(
-      overrides?: TransactionOverrides
-    ): Promise<{
+    view_named(): Promise<{
       uint256_1: BigNumber;
       uint256_2: BigNumber;
       0: BigNumber;
       1: BigNumber;
     }>;
 
-    "view_named()"(
-      overrides?: TransactionOverrides
-    ): Promise<{
-      uint256_1: BigNumber;
-      uint256_2: BigNumber;
-      0: BigNumber;
-      1: BigNumber;
-    }>;
-
-    view_stat_array(overrides?: TransactionOverrides): Promise<number[]>;
+    view_stat_array(): Promise<number[]>;
 
-    "view_stat_array()"(overrides?: TransactionOverrides): Promise<number[]>;
-
-    view_string(overrides?: TransactionOverrides): Promise<string>;
-
-    "view_string()"(overrides?: TransactionOverrides): Promise<string>;
-
-    view_struct(
-      overrides?: TransactionOverrides
-    ): Promise<{
-      uint256_0: BigNumber;
-      uint256_1: BigNumber;
-      0: BigNumber;
-      1: BigNumber;
-    }>;
+    view_string(): Promise<string>;
 
-    "view_struct()"(
-      overrides?: TransactionOverrides
-    ): Promise<{
+    view_struct(): Promise<{
       uint256_0: BigNumber;
       uint256_1: BigNumber;
       0: BigNumber;
       1: BigNumber;
     }>;
 
-    view_tuple(
-      overrides?: TransactionOverrides
-    ): Promise<{
+    view_tuple(): Promise<{
       0: BigNumber;
       1: BigNumber;
     }>;
 
-    "view_tuple()"(
-      overrides?: TransactionOverrides
-    ): Promise<{
-      0: BigNumber;
-      1: BigNumber;
-    }>;
-
-    view_uint256(overrides?: TransactionOverrides): Promise<BigNumber>;
-
-    "view_uint256()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+    view_uint256(): Promise<BigNumber>;
 
-    view_uint8(overrides?: TransactionOverrides): Promise<number>;
-
-    "view_uint8()"(overrides?: TransactionOverrides): Promise<number>;
+    view_uint8(): Promise<number>;
   };
 
-  view_address(overrides?: TransactionOverrides): Promise<string>;
-
-  "view_address()"(overrides?: TransactionOverrides): Promise<string>;
-
-  view_bool(overrides?: TransactionOverrides): Promise<boolean>;
-
-  "view_bool()"(overrides?: TransactionOverrides): Promise<boolean>;
-
-  view_bytes(overrides?: TransactionOverrides): Promise<string>;
-
-  "view_bytes()"(overrides?: TransactionOverrides): Promise<string>;
-
-  view_bytes1(overrides?: TransactionOverrides): Promise<string>;
-
-  "view_bytes1()"(overrides?: TransactionOverrides): Promise<string>;
+  view_address(): Promise<string>;
 
-  view_enum(overrides?: TransactionOverrides): Promise<number>;
+  view_bool(): Promise<boolean>;
 
-  "view_enum()"(overrides?: TransactionOverrides): Promise<number>;
+  view_bytes(): Promise<string>;
 
-  view_int256(overrides?: TransactionOverrides): Promise<BigNumber>;
+  view_bytes1(): Promise<string>;
 
-  "view_int256()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+  view_enum(): Promise<number>;
 
-  view_int8(overrides?: TransactionOverrides): Promise<number>;
+  view_int256(): Promise<BigNumber>;
 
-  "view_int8()"(overrides?: TransactionOverrides): Promise<number>;
+  view_int8(): Promise<number>;
 
-  view_named(
-    overrides?: TransactionOverrides
-  ): Promise<{
+  view_named(): Promise<{
     uint256_1: BigNumber;
     uint256_2: BigNumber;
     0: BigNumber;
     1: BigNumber;
   }>;
 
-  "view_named()"(
-    overrides?: TransactionOverrides
-  ): Promise<{
-    uint256_1: BigNumber;
-    uint256_2: BigNumber;
-    0: BigNumber;
-    1: BigNumber;
-  }>;
+  view_stat_array(): Promise<number[]>;
 
-  view_stat_array(overrides?: TransactionOverrides): Promise<number[]>;
+  view_string(): Promise<string>;
 
-  "view_stat_array()"(overrides?: TransactionOverrides): Promise<number[]>;
-
-  view_string(overrides?: TransactionOverrides): Promise<string>;
-
-  "view_string()"(overrides?: TransactionOverrides): Promise<string>;
-
-  view_struct(
-    overrides?: TransactionOverrides
-  ): Promise<{
+  view_struct(): Promise<{
     uint256_0: BigNumber;
     uint256_1: BigNumber;
     0: BigNumber;
     1: BigNumber;
   }>;
 
-  "view_struct()"(
-    overrides?: TransactionOverrides
-  ): Promise<{
-    uint256_0: BigNumber;
-    uint256_1: BigNumber;
-    0: BigNumber;
-    1: BigNumber;
-  }>;
-
-  view_tuple(
-    overrides?: TransactionOverrides
-  ): Promise<{
-    0: BigNumber;
-    1: BigNumber;
-  }>;
-
-  "view_tuple()"(
-    overrides?: TransactionOverrides
-  ): Promise<{
+  view_tuple(): Promise<{
     0: BigNumber;
     1: BigNumber;
   }>;
 
-  view_uint256(overrides?: TransactionOverrides): Promise<BigNumber>;
-
-  "view_uint256()"(overrides?: TransactionOverrides): Promise<BigNumber>;
-
-  view_uint8(overrides?: TransactionOverrides): Promise<number>;
+  view_uint256(): Promise<BigNumber>;
 
-  "view_uint8()"(overrides?: TransactionOverrides): Promise<number>;
+  view_uint8(): Promise<number>;
 
   filters: {};
 
   estimate: {
-    view_address(overrides?: TransactionOverrides): Promise<BigNumber>;
-
-    "view_address()"(overrides?: TransactionOverrides): Promise<BigNumber>;
-
-    view_bool(overrides?: TransactionOverrides): Promise<BigNumber>;
-
-    "view_bool()"(overrides?: TransactionOverrides): Promise<BigNumber>;
-
-    view_bytes(overrides?: TransactionOverrides): Promise<BigNumber>;
-
-    "view_bytes()"(overrides?: TransactionOverrides): Promise<BigNumber>;
-
-    view_bytes1(overrides?: TransactionOverrides): Promise<BigNumber>;
-
-    "view_bytes1()"(overrides?: TransactionOverrides): Promise<BigNumber>;
-
-    view_enum(overrides?: TransactionOverrides): Promise<BigNumber>;
-
-    "view_enum()"(overrides?: TransactionOverrides): Promise<BigNumber>;
-
-    view_int256(overrides?: TransactionOverrides): Promise<BigNumber>;
-
-    "view_int256()"(overrides?: TransactionOverrides): Promise<BigNumber>;
-
-    view_int8(overrides?: TransactionOverrides): Promise<BigNumber>;
-
-    "view_int8()"(overrides?: TransactionOverrides): Promise<BigNumber>;
-
-    view_named(overrides?: TransactionOverrides): Promise<BigNumber>;
+    view_address(): Promise<BigNumber>;
 
-    "view_named()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+    view_bool(): Promise<BigNumber>;
 
-    view_stat_array(overrides?: TransactionOverrides): Promise<BigNumber>;
+    view_bytes(): Promise<BigNumber>;
 
-    "view_stat_array()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+    view_bytes1(): Promise<BigNumber>;
 
-    view_string(overrides?: TransactionOverrides): Promise<BigNumber>;
+    view_enum(): Promise<BigNumber>;
 
-    "view_string()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+    view_int256(): Promise<BigNumber>;
 
-    view_struct(overrides?: TransactionOverrides): Promise<BigNumber>;
+    view_int8(): Promise<BigNumber>;
 
-    "view_struct()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+    view_named(): Promise<BigNumber>;
 
-    view_tuple(overrides?: TransactionOverrides): Promise<BigNumber>;
+    view_stat_array(): Promise<BigNumber>;
 
-    "view_tuple()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+    view_string(): Promise<BigNumber>;
 
-    view_uint256(overrides?: TransactionOverrides): Promise<BigNumber>;
+    view_struct(): Promise<BigNumber>;
 
-    "view_uint256()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+    view_tuple(): Promise<BigNumber>;
 
-    view_uint8(overrides?: TransactionOverrides): Promise<BigNumber>;
+    view_uint256(): Promise<BigNumber>;
 
-    "view_uint8()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+    view_uint8(): Promise<BigNumber>;
   };
 }
diff --git a/packages/target-ethers-v4-test/types/Events.d.ts b/packages/target-ethers-v4-test/types/Events.d.ts
index 67d7469ae..21dd4fd1c 100644
--- a/packages/target-ethers-v4-test/types/Events.d.ts
+++ b/packages/target-ethers-v4-test/types/Events.d.ts
@@ -58,69 +58,29 @@ export class Events extends Contract {
   functions: {
     emit_anon1(overrides?: TransactionOverrides): Promise<ContractTransaction>;
 
-    "emit_anon1()"(
-      overrides?: TransactionOverrides
-    ): Promise<ContractTransaction>;
-
     emit_event1(overrides?: TransactionOverrides): Promise<ContractTransaction>;
 
-    "emit_event1()"(
-      overrides?: TransactionOverrides
-    ): Promise<ContractTransaction>;
-
     emit_event2(overrides?: TransactionOverrides): Promise<ContractTransaction>;
 
-    "emit_event2()"(
-      overrides?: TransactionOverrides
-    ): Promise<ContractTransaction>;
-
     emit_event3(overrides?: TransactionOverrides): Promise<ContractTransaction>;
 
-    "emit_event3()"(
-      overrides?: TransactionOverrides
-    ): Promise<ContractTransaction>;
-
     emit_event3_overloaded(
       overrides?: TransactionOverrides
     ): Promise<ContractTransaction>;
-
-    "emit_event3_overloaded()"(
-      overrides?: TransactionOverrides
-    ): Promise<ContractTransaction>;
   };
 
   emit_anon1(overrides?: TransactionOverrides): Promise<ContractTransaction>;
 
-  "emit_anon1()"(
-    overrides?: TransactionOverrides
-  ): Promise<ContractTransaction>;
-
   emit_event1(overrides?: TransactionOverrides): Promise<ContractTransaction>;
 
-  "emit_event1()"(
-    overrides?: TransactionOverrides
-  ): Promise<ContractTransaction>;
-
   emit_event2(overrides?: TransactionOverrides): Promise<ContractTransaction>;
 
-  "emit_event2()"(
-    overrides?: TransactionOverrides
-  ): Promise<ContractTransaction>;
-
   emit_event3(overrides?: TransactionOverrides): Promise<ContractTransaction>;
 
-  "emit_event3()"(
-    overrides?: TransactionOverrides
-  ): Promise<ContractTransaction>;
-
   emit_event3_overloaded(
     overrides?: TransactionOverrides
   ): Promise<ContractTransaction>;
 
-  "emit_event3_overloaded()"(
-    overrides?: TransactionOverrides
-  ): Promise<ContractTransaction>;
-
   filters: {
     AnonEvent1(value1: BigNumberish | null): EventFilter;
 
@@ -132,28 +92,14 @@ export class Events extends Contract {
   };
 
   estimate: {
-    emit_anon1(overrides?: TransactionOverrides): Promise<BigNumber>;
-
-    "emit_anon1()"(overrides?: TransactionOverrides): Promise<BigNumber>;
-
-    emit_event1(overrides?: TransactionOverrides): Promise<BigNumber>;
-
-    "emit_event1()"(overrides?: TransactionOverrides): Promise<BigNumber>;
-
-    emit_event2(overrides?: TransactionOverrides): Promise<BigNumber>;
+    emit_anon1(): Promise<BigNumber>;
 
-    "emit_event2()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+    emit_event1(): Promise<BigNumber>;
 
-    emit_event3(overrides?: TransactionOverrides): Promise<BigNumber>;
+    emit_event2(): Promise<BigNumber>;
 
-    "emit_event3()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+    emit_event3(): Promise<BigNumber>;
 
-    emit_event3_overloaded(
-      overrides?: TransactionOverrides
-    ): Promise<BigNumber>;
-
-    "emit_event3_overloaded()"(
-      overrides?: TransactionOverrides
-    ): Promise<BigNumber>;
+    emit_event3_overloaded(): Promise<BigNumber>;
   };
 }
diff --git a/packages/target-ethers-v4-test/types/NameMangling.d.ts b/packages/target-ethers-v4-test/types/NameMangling.d.ts
index 6c60de7b8..5edbd9e8e 100644
--- a/packages/target-ethers-v4-test/types/NameMangling.d.ts
+++ b/packages/target-ethers-v4-test/types/NameMangling.d.ts
@@ -35,20 +35,14 @@ export class NameMangling extends Contract {
   interface: NameManglingInterface;
 
   functions: {
-    works(overrides?: TransactionOverrides): Promise<boolean>;
-
-    "works()"(overrides?: TransactionOverrides): Promise<boolean>;
+    works(): Promise<boolean>;
   };
 
-  works(overrides?: TransactionOverrides): Promise<boolean>;
-
-  "works()"(overrides?: TransactionOverrides): Promise<boolean>;
+  works(): Promise<boolean>;
 
   filters: {};
 
   estimate: {
-    works(overrides?: TransactionOverrides): Promise<BigNumber>;
-
-    "works()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+    works(): Promise<BigNumber>;
   };
 }
diff --git a/packages/target-ethers-v4-test/types/Overloads.d.ts b/packages/target-ethers-v4-test/types/Overloads.d.ts
index ecfeecfdc..73ed4f205 100644
--- a/packages/target-ethers-v4-test/types/Overloads.d.ts
+++ b/packages/target-ethers-v4-test/types/Overloads.d.ts
@@ -34,56 +34,24 @@ export class Overloads extends Contract {
   interface: OverloadsInterface;
 
   functions: {
-    overload1(
-      input1: BigNumberish,
-      overrides?: TransactionOverrides
-    ): Promise<BigNumber>;
-
-    "overload1(int256)"(
-      input1: BigNumberish,
-      overrides?: TransactionOverrides
-    ): Promise<BigNumber>;
+    "overload1(int256)"(input1: BigNumberish): Promise<BigNumber>;
 
     "overload1(uint256,uint256)"(
       input1: BigNumberish,
-      input2: BigNumberish,
-      overrides?: TransactionOverrides
+      input2: BigNumberish
     ): Promise<BigNumber>;
   };
 
-  overload1(
-    input1: BigNumberish,
-    overrides?: TransactionOverrides
-  ): Promise<BigNumber>;
-
-  "overload1(int256)"(
-    input1: BigNumberish,
-    overrides?: TransactionOverrides
-  ): Promise<BigNumber>;
+  "overload1(int256)"(input1: BigNumberish): Promise<BigNumber>;
 
   "overload1(uint256,uint256)"(
     input1: BigNumberish,
-    input2: BigNumberish,
-    overrides?: TransactionOverrides
+    input2: BigNumberish
   ): Promise<BigNumber>;
 
   filters: {};
 
   estimate: {
-    overload1(
-      input1: BigNumberish,
-      overrides?: TransactionOverrides
-    ): Promise<BigNumber>;
-
-    "overload1(int256)"(
-      input1: BigNumberish,
-      overrides?: TransactionOverrides
-    ): Promise<BigNumber>;
-
-    "overload1(uint256,uint256)"(
-      input1: BigNumberish,
-      input2: BigNumberish,
-      overrides?: TransactionOverrides
-    ): Promise<BigNumber>;
+    overload1(input1: BigNumberish): Promise<BigNumber>;
   };
 }
diff --git a/packages/target-ethers-v4-test/types/Payable.d.ts b/packages/target-ethers-v4-test/types/Payable.d.ts
index e541f05e5..c36e141ef 100644
--- a/packages/target-ethers-v4-test/types/Payable.d.ts
+++ b/packages/target-ethers-v4-test/types/Payable.d.ts
@@ -38,42 +38,22 @@ export class Payable extends Contract {
       overrides?: TransactionOverrides
     ): Promise<ContractTransaction>;
 
-    "non_payable_func()"(
-      overrides?: TransactionOverrides
-    ): Promise<ContractTransaction>;
-
     payable_func(
       overrides?: TransactionOverrides
     ): Promise<ContractTransaction>;
-
-    "payable_func()"(
-      overrides?: TransactionOverrides
-    ): Promise<ContractTransaction>;
   };
 
   non_payable_func(
     overrides?: TransactionOverrides
   ): Promise<ContractTransaction>;
 
-  "non_payable_func()"(
-    overrides?: TransactionOverrides
-  ): Promise<ContractTransaction>;
-
   payable_func(overrides?: TransactionOverrides): Promise<ContractTransaction>;
 
-  "payable_func()"(
-    overrides?: TransactionOverrides
-  ): Promise<ContractTransaction>;
-
   filters: {};
 
   estimate: {
-    non_payable_func(overrides?: TransactionOverrides): Promise<BigNumber>;
-
-    "non_payable_func()"(overrides?: TransactionOverrides): Promise<BigNumber>;
-
-    payable_func(overrides?: TransactionOverrides): Promise<BigNumber>;
+    non_payable_func(): Promise<BigNumber>;
 
-    "payable_func()"(overrides?: TransactionOverrides): Promise<BigNumber>;
+    payable_func(): Promise<BigNumber>;
   };
 }

From 6905678bf0ab5106012be86bdeec8a072d1cd9a2 Mon Sep 17 00:00:00 2001
From: Braden Napier <brady.napier@dashos.net>
Date: Thu, 9 Jul 2020 05:15:05 -0400
Subject: [PATCH 52/64] fix: remove changes caused by not recompiling types
 manually

---
 .../types/DataTypesInput.d.ts                 | 378 ------------------
 .../types/DataTypesPure.d.ts                  | 245 ------------
 .../types/DataTypesView.d.ts                  | 245 ------------
 .../target-ethers-v5-test/types/Events.d.ts   |  56 ---
 .../types/NameMangling.d.ts                   |  14 -
 .../target-ethers-v5-test/types/Payable.d.ts  |  24 --
 6 files changed, 962 deletions(-)

diff --git a/packages/target-ethers-v5-test/types/DataTypesInput.d.ts b/packages/target-ethers-v5-test/types/DataTypesInput.d.ts
index 75afa3bcf..7c06ff7c9 100644
--- a/packages/target-ethers-v5-test/types/DataTypesInput.d.ts
+++ b/packages/target-ethers-v5-test/types/DataTypesInput.d.ts
@@ -153,13 +153,6 @@ export class DataTypesInput extends Contract {
       0: string;
     }>;
 
-    "input_address(address)"(
-      input1: string,
-      overrides?: CallOverrides
-    ): Promise<{
-      0: string;
-    }>;
-
     input_bool(
       input1: boolean,
       overrides?: CallOverrides
@@ -167,13 +160,6 @@ export class DataTypesInput extends Contract {
       0: boolean;
     }>;
 
-    "input_bool(bool)"(
-      input1: boolean,
-      overrides?: CallOverrides
-    ): Promise<{
-      0: boolean;
-    }>;
-
     input_bytes(
       input1: BytesLike,
       overrides?: CallOverrides
@@ -181,13 +167,6 @@ export class DataTypesInput extends Contract {
       0: string;
     }>;
 
-    "input_bytes(bytes)"(
-      input1: BytesLike,
-      overrides?: CallOverrides
-    ): Promise<{
-      0: string;
-    }>;
-
     input_bytes1(
       input1: BytesLike,
       overrides?: CallOverrides
@@ -195,13 +174,6 @@ export class DataTypesInput extends Contract {
       0: string;
     }>;
 
-    "input_bytes1(bytes1)"(
-      input1: BytesLike,
-      overrides?: CallOverrides
-    ): Promise<{
-      0: string;
-    }>;
-
     input_enum(
       input1: BigNumberish,
       overrides?: CallOverrides
@@ -209,13 +181,6 @@ export class DataTypesInput extends Contract {
       0: number;
     }>;
 
-    "input_enum(uint8)"(
-      input1: BigNumberish,
-      overrides?: CallOverrides
-    ): Promise<{
-      0: number;
-    }>;
-
     input_int256(
       input1: BigNumberish,
       overrides?: CallOverrides
@@ -223,13 +188,6 @@ export class DataTypesInput extends Contract {
       0: BigNumber;
     }>;
 
-    "input_int256(int256)"(
-      input1: BigNumberish,
-      overrides?: CallOverrides
-    ): Promise<{
-      0: BigNumber;
-    }>;
-
     input_int8(
       input1: BigNumberish,
       overrides?: CallOverrides
@@ -237,13 +195,6 @@ export class DataTypesInput extends Contract {
       0: number;
     }>;
 
-    "input_int8(int8)"(
-      input1: BigNumberish,
-      overrides?: CallOverrides
-    ): Promise<{
-      0: number;
-    }>;
-
     input_stat_array(
       input1: BigNumberish[],
       overrides?: CallOverrides
@@ -251,13 +202,6 @@ export class DataTypesInput extends Contract {
       0: number[];
     }>;
 
-    "input_stat_array(uint8[3])"(
-      input1: BigNumberish[],
-      overrides?: CallOverrides
-    ): Promise<{
-      0: number[];
-    }>;
-
     input_string(
       input1: string,
       overrides?: CallOverrides
@@ -265,13 +209,6 @@ export class DataTypesInput extends Contract {
       0: string;
     }>;
 
-    "input_string(string)"(
-      input1: string,
-      overrides?: CallOverrides
-    ): Promise<{
-      0: string;
-    }>;
-
     input_struct(
       input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
       overrides?: CallOverrides
@@ -284,18 +221,6 @@ export class DataTypesInput extends Contract {
       };
     }>;
 
-    "input_struct(tuple)"(
-      input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
-      overrides?: CallOverrides
-    ): Promise<{
-      0: {
-        uint256_0: BigNumber;
-        uint256_1: BigNumber;
-        0: BigNumber;
-        1: BigNumber;
-      };
-    }>;
-
     input_tuple(
       input1: BigNumberish,
       input2: BigNumberish,
@@ -305,15 +230,6 @@ export class DataTypesInput extends Contract {
       1: BigNumber;
     }>;
 
-    "input_tuple(uint256,uint256)"(
-      input1: BigNumberish,
-      input2: BigNumberish,
-      overrides?: CallOverrides
-    ): Promise<{
-      0: BigNumber;
-      1: BigNumber;
-    }>;
-
     input_uint256(
       input1: BigNumberish,
       overrides?: CallOverrides
@@ -321,97 +237,38 @@ export class DataTypesInput extends Contract {
       0: BigNumber;
     }>;
 
-    "input_uint256(uint256)"(
-      input1: BigNumberish,
-      overrides?: CallOverrides
-    ): Promise<{
-      0: BigNumber;
-    }>;
-
     input_uint8(
       input1: BigNumberish,
       overrides?: CallOverrides
     ): Promise<{
       0: number;
     }>;
-
-    "input_uint8(uint8)"(
-      input1: BigNumberish,
-      overrides?: CallOverrides
-    ): Promise<{
-      0: number;
-    }>;
   };
 
   input_address(input1: string, overrides?: CallOverrides): Promise<string>;
 
-  "input_address(address)"(
-    input1: string,
-    overrides?: CallOverrides
-  ): Promise<string>;
-
   input_bool(input1: boolean, overrides?: CallOverrides): Promise<boolean>;
 
-  "input_bool(bool)"(
-    input1: boolean,
-    overrides?: CallOverrides
-  ): Promise<boolean>;
-
   input_bytes(input1: BytesLike, overrides?: CallOverrides): Promise<string>;
 
-  "input_bytes(bytes)"(
-    input1: BytesLike,
-    overrides?: CallOverrides
-  ): Promise<string>;
-
   input_bytes1(input1: BytesLike, overrides?: CallOverrides): Promise<string>;
 
-  "input_bytes1(bytes1)"(
-    input1: BytesLike,
-    overrides?: CallOverrides
-  ): Promise<string>;
-
   input_enum(input1: BigNumberish, overrides?: CallOverrides): Promise<number>;
 
-  "input_enum(uint8)"(
-    input1: BigNumberish,
-    overrides?: CallOverrides
-  ): Promise<number>;
-
   input_int256(
     input1: BigNumberish,
     overrides?: CallOverrides
   ): Promise<BigNumber>;
 
-  "input_int256(int256)"(
-    input1: BigNumberish,
-    overrides?: CallOverrides
-  ): Promise<BigNumber>;
-
   input_int8(input1: BigNumberish, overrides?: CallOverrides): Promise<number>;
 
-  "input_int8(int8)"(
-    input1: BigNumberish,
-    overrides?: CallOverrides
-  ): Promise<number>;
-
   input_stat_array(
     input1: BigNumberish[],
     overrides?: CallOverrides
   ): Promise<number[]>;
 
-  "input_stat_array(uint8[3])"(
-    input1: BigNumberish[],
-    overrides?: CallOverrides
-  ): Promise<number[]>;
-
   input_string(input1: string, overrides?: CallOverrides): Promise<string>;
 
-  "input_string(string)"(
-    input1: string,
-    overrides?: CallOverrides
-  ): Promise<string>;
-
   input_struct(
     input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
     overrides?: CallOverrides
@@ -422,16 +279,6 @@ export class DataTypesInput extends Contract {
     1: BigNumber;
   }>;
 
-  "input_struct(tuple)"(
-    input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
-    overrides?: CallOverrides
-  ): Promise<{
-    uint256_0: BigNumber;
-    uint256_1: BigNumber;
-    0: BigNumber;
-    1: BigNumber;
-  }>;
-
   input_tuple(
     input1: BigNumberish,
     input2: BigNumberish,
@@ -441,108 +288,44 @@ export class DataTypesInput extends Contract {
     1: BigNumber;
   }>;
 
-  "input_tuple(uint256,uint256)"(
-    input1: BigNumberish,
-    input2: BigNumberish,
-    overrides?: CallOverrides
-  ): Promise<{
-    0: BigNumber;
-    1: BigNumber;
-  }>;
-
   input_uint256(
     input1: BigNumberish,
     overrides?: CallOverrides
   ): Promise<BigNumber>;
 
-  "input_uint256(uint256)"(
-    input1: BigNumberish,
-    overrides?: CallOverrides
-  ): Promise<BigNumber>;
-
   input_uint8(input1: BigNumberish, overrides?: CallOverrides): Promise<number>;
 
-  "input_uint8(uint8)"(
-    input1: BigNumberish,
-    overrides?: CallOverrides
-  ): Promise<number>;
-
   callStatic: {
     input_address(input1: string, overrides?: CallOverrides): Promise<string>;
 
-    "input_address(address)"(
-      input1: string,
-      overrides?: CallOverrides
-    ): Promise<string>;
-
     input_bool(input1: boolean, overrides?: CallOverrides): Promise<boolean>;
 
-    "input_bool(bool)"(
-      input1: boolean,
-      overrides?: CallOverrides
-    ): Promise<boolean>;
-
     input_bytes(input1: BytesLike, overrides?: CallOverrides): Promise<string>;
 
-    "input_bytes(bytes)"(
-      input1: BytesLike,
-      overrides?: CallOverrides
-    ): Promise<string>;
-
     input_bytes1(input1: BytesLike, overrides?: CallOverrides): Promise<string>;
 
-    "input_bytes1(bytes1)"(
-      input1: BytesLike,
-      overrides?: CallOverrides
-    ): Promise<string>;
-
     input_enum(
       input1: BigNumberish,
       overrides?: CallOverrides
     ): Promise<number>;
 
-    "input_enum(uint8)"(
-      input1: BigNumberish,
-      overrides?: CallOverrides
-    ): Promise<number>;
-
     input_int256(
       input1: BigNumberish,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    "input_int256(int256)"(
-      input1: BigNumberish,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
     input_int8(
       input1: BigNumberish,
       overrides?: CallOverrides
     ): Promise<number>;
 
-    "input_int8(int8)"(
-      input1: BigNumberish,
-      overrides?: CallOverrides
-    ): Promise<number>;
-
     input_stat_array(
       input1: BigNumberish[],
       overrides?: CallOverrides
     ): Promise<number[]>;
 
-    "input_stat_array(uint8[3])"(
-      input1: BigNumberish[],
-      overrides?: CallOverrides
-    ): Promise<number[]>;
-
     input_string(input1: string, overrides?: CallOverrides): Promise<string>;
 
-    "input_string(string)"(
-      input1: string,
-      overrides?: CallOverrides
-    ): Promise<string>;
-
     input_struct(
       input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
       overrides?: CallOverrides
@@ -553,16 +336,6 @@ export class DataTypesInput extends Contract {
       1: BigNumber;
     }>;
 
-    "input_struct(tuple)"(
-      input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
-      overrides?: CallOverrides
-    ): Promise<{
-      uint256_0: BigNumber;
-      uint256_1: BigNumber;
-      0: BigNumber;
-      1: BigNumber;
-    }>;
-
     input_tuple(
       input1: BigNumberish,
       input2: BigNumberish,
@@ -572,34 +345,15 @@ export class DataTypesInput extends Contract {
       1: BigNumber;
     }>;
 
-    "input_tuple(uint256,uint256)"(
-      input1: BigNumberish,
-      input2: BigNumberish,
-      overrides?: CallOverrides
-    ): Promise<{
-      0: BigNumber;
-      1: BigNumber;
-    }>;
-
     input_uint256(
       input1: BigNumberish,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    "input_uint256(uint256)"(
-      input1: BigNumberish,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
     input_uint8(
       input1: BigNumberish,
       overrides?: CallOverrides
     ): Promise<number>;
-
-    "input_uint8(uint8)"(
-      input1: BigNumberish,
-      overrides?: CallOverrides
-    ): Promise<number>;
   };
 
   filters: {};
@@ -610,126 +364,60 @@ export class DataTypesInput extends Contract {
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    "input_address(address)"(
-      input1: string,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
     input_bool(input1: boolean, overrides?: CallOverrides): Promise<BigNumber>;
 
-    "input_bool(bool)"(
-      input1: boolean,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
     input_bytes(
       input1: BytesLike,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    "input_bytes(bytes)"(
-      input1: BytesLike,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
     input_bytes1(
       input1: BytesLike,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    "input_bytes1(bytes1)"(
-      input1: BytesLike,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
     input_enum(
       input1: BigNumberish,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    "input_enum(uint8)"(
-      input1: BigNumberish,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
     input_int256(
       input1: BigNumberish,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    "input_int256(int256)"(
-      input1: BigNumberish,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
     input_int8(
       input1: BigNumberish,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    "input_int8(int8)"(
-      input1: BigNumberish,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
     input_stat_array(
       input1: BigNumberish[],
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    "input_stat_array(uint8[3])"(
-      input1: BigNumberish[],
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
     input_string(input1: string, overrides?: CallOverrides): Promise<BigNumber>;
 
-    "input_string(string)"(
-      input1: string,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
     input_struct(
       input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    "input_struct(tuple)"(
-      input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
     input_tuple(
       input1: BigNumberish,
       input2: BigNumberish,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    "input_tuple(uint256,uint256)"(
-      input1: BigNumberish,
-      input2: BigNumberish,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
     input_uint256(
       input1: BigNumberish,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
 
-    "input_uint256(uint256)"(
-      input1: BigNumberish,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
-
     input_uint8(
       input1: BigNumberish,
       overrides?: CallOverrides
     ): Promise<BigNumber>;
-
-    "input_uint8(uint8)"(
-      input1: BigNumberish,
-      overrides?: CallOverrides
-    ): Promise<BigNumber>;
   };
 
   populateTransaction: {
@@ -738,131 +426,65 @@ export class DataTypesInput extends Contract {
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    "input_address(address)"(
-      input1: string,
-      overrides?: CallOverrides
-    ): Promise<PopulatedTransaction>;
-
     input_bool(
       input1: boolean,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    "input_bool(bool)"(
-      input1: boolean,
-      overrides?: CallOverrides
-    ): Promise<PopulatedTransaction>;
-
     input_bytes(
       input1: BytesLike,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    "input_bytes(bytes)"(
-      input1: BytesLike,
-      overrides?: CallOverrides
-    ): Promise<PopulatedTransaction>;
-
     input_bytes1(
       input1: BytesLike,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    "input_bytes1(bytes1)"(
-      input1: BytesLike,
-      overrides?: CallOverrides
-    ): Promise<PopulatedTransaction>;
-
     input_enum(
       input1: BigNumberish,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    "input_enum(uint8)"(
-      input1: BigNumberish,
-      overrides?: CallOverrides
-    ): Promise<PopulatedTransaction>;
-
     input_int256(
       input1: BigNumberish,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    "input_int256(int256)"(
-      input1: BigNumberish,
-      overrides?: CallOverrides
-    ): Promise<PopulatedTransaction>;
-
     input_int8(
       input1: BigNumberish,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    "input_int8(int8)"(
-      input1: BigNumberish,
-      overrides?: CallOverrides
-    ): Promise<PopulatedTransaction>;
-
     input_stat_array(
       input1: BigNumberish[],
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    "input_stat_array(uint8[3])"(
-      input1: BigNumberish[],
-      overrides?: CallOverrides
-    ): Promise<PopulatedTransaction>;
-
     input_string(
       input1: string,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    "input_string(string)"(
-      input1: string,
-      overrides?: CallOverrides
-    ): Promise<PopulatedTransaction>;
-
     input_struct(
       input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    "input_struct(tuple)"(
-      input1: { uint256_0: BigNumberish; uint256_1: BigNumberish },
-      overrides?: CallOverrides
-    ): Promise<PopulatedTransaction>;
-
     input_tuple(
       input1: BigNumberish,
       input2: BigNumberish,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    "input_tuple(uint256,uint256)"(
-      input1: BigNumberish,
-      input2: BigNumberish,
-      overrides?: CallOverrides
-    ): Promise<PopulatedTransaction>;
-
     input_uint256(
       input1: BigNumberish,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
 
-    "input_uint256(uint256)"(
-      input1: BigNumberish,
-      overrides?: CallOverrides
-    ): Promise<PopulatedTransaction>;
-
     input_uint8(
       input1: BigNumberish,
       overrides?: CallOverrides
     ): Promise<PopulatedTransaction>;
-
-    "input_uint8(uint8)"(
-      input1: BigNumberish,
-      overrides?: CallOverrides
-    ): Promise<PopulatedTransaction>;
   };
 }
diff --git a/packages/target-ethers-v5-test/types/DataTypesPure.d.ts b/packages/target-ethers-v5-test/types/DataTypesPure.d.ts
index c80486d59..c40b9d313 100644
--- a/packages/target-ethers-v5-test/types/DataTypesPure.d.ts
+++ b/packages/target-ethers-v5-test/types/DataTypesPure.d.ts
@@ -143,84 +143,42 @@ export class DataTypesPure extends Contract {
       0: string;
     }>;
 
-    "pure_address()"(
-      overrides?: CallOverrides
-    ): Promise<{
-      0: string;
-    }>;
-
     pure_bool(
       overrides?: CallOverrides
     ): Promise<{
       0: boolean;
     }>;
 
-    "pure_bool()"(
-      overrides?: CallOverrides
-    ): Promise<{
-      0: boolean;
-    }>;
-
     pure_bytes(
       overrides?: CallOverrides
     ): Promise<{
       0: string;
     }>;
 
-    "pure_bytes()"(
-      overrides?: CallOverrides
-    ): Promise<{
-      0: string;
-    }>;
-
     pure_bytes1(
       overrides?: CallOverrides
     ): Promise<{
       0: string;
     }>;
 
-    "pure_bytes1()"(
-      overrides?: CallOverrides
-    ): Promise<{
-      0: string;
-    }>;
-
     pure_enum(
       overrides?: CallOverrides
     ): Promise<{
       0: number;
     }>;
 
-    "pure_enum()"(
-      overrides?: CallOverrides
-    ): Promise<{
-      0: number;
-    }>;
-
     pure_int256(
       overrides?: CallOverrides
     ): Promise<{
       0: BigNumber;
     }>;
 
-    "pure_int256()"(
-      overrides?: CallOverrides
-    ): Promise<{
-      0: BigNumber;
-    }>;
-
     pure_int8(
       overrides?: CallOverrides
     ): Promise<{
       0: number;
     }>;
 
-    "pure_int8()"(
-      overrides?: CallOverrides
-    ): Promise<{
-      0: number;
-    }>;
-
     pure_named(
       overrides?: CallOverrides
     ): Promise<{
@@ -230,39 +188,18 @@ export class DataTypesPure extends Contract {
       1: BigNumber;
     }>;
 
-    "pure_named()"(
-      overrides?: CallOverrides
-    ): Promise<{
-      uint256_1: BigNumber;
-      uint256_2: BigNumber;
-      0: BigNumber;
-      1: BigNumber;
-    }>;
-
     pure_stat_array(
       overrides?: CallOverrides
     ): Promise<{
       0: number[];
     }>;
 
-    "pure_stat_array()"(
-      overrides?: CallOverrides
-    ): Promise<{
-      0: number[];
-    }>;
-
     pure_string(
       overrides?: CallOverrides
     ): Promise<{
       0: string;
     }>;
 
-    "pure_string()"(
-      overrides?: CallOverrides
-    ): Promise<{
-      0: string;
-    }>;
-
     pure_struct(
       overrides?: CallOverrides
     ): Promise<{
@@ -274,17 +211,6 @@ export class DataTypesPure extends Contract {
       };
     }>;
 
-    "pure_struct()"(
-      overrides?: CallOverrides
-    ): Promise<{
-      0: {
-        uint256_0: BigNumber;
-        uint256_1: BigNumber;
-        0: BigNumber;
-        1: BigNumber;
-      };
-    }>;
-
     pure_tuple(
       overrides?: CallOverrides
     ): Promise<{
@@ -292,66 +218,33 @@ export class DataTypesPure extends Contract {
       1: BigNumber;
     }>;
 
-    "pure_tuple()"(
-      overrides?: CallOverrides
-    ): Promise<{
-      0: BigNumber;
-      1: BigNumber;
-    }>;
-
     pure_uint256(
       overrides?: CallOverrides
     ): Promise<{
       0: BigNumber;
     }>;
 
-    "pure_uint256()"(
-      overrides?: CallOverrides
-    ): Promise<{
-      0: BigNumber;
-    }>;
-
     pure_uint8(
       overrides?: CallOverrides
     ): Promise<{
       0: number;
     }>;
-
-    "pure_uint8()"(
-      overrides?: CallOverrides
-    ): Promise<{
-      0: number;
-    }>;
   };
 
   pure_address(overrides?: CallOverrides): Promise<string>;
 
-  "pure_address()"(overrides?: CallOverrides): Promise<string>;
-
   pure_bool(overrides?: CallOverrides): Promise<boolean>;
 
-  "pure_bool()"(overrides?: CallOverrides): Promise<boolean>;
-
   pure_bytes(overrides?: CallOverrides): Promise<string>;
 
-  "pure_bytes()"(overrides?: CallOverrides): Promise<string>;
-
   pure_bytes1(overrides?: CallOverrides): Promise<string>;
 
-  "pure_bytes1()"(overrides?: CallOverrides): Promise<string>;
-
   pure_enum(overrides?: CallOverrides): Promise<number>;
 
-  "pure_enum()"(overrides?: CallOverrides): Promise<number>;
-
   pure_int256(overrides?: CallOverrides): Promise<BigNumber>;
 
-  "pure_int256()"(overrides?: CallOverrides): Promise<BigNumber>;
-
   pure_int8(overrides?: CallOverrides): Promise<number>;
 
-  "pure_int8()"(overrides?: CallOverrides): Promise<number>;
-
   pure_named(
     overrides?: CallOverrides
   ): Promise<{
@@ -361,23 +254,10 @@ export class DataTypesPure extends Contract {
     1: BigNumber;
   }>;
 
-  "pure_named()"(
-    overrides?: CallOverrides
-  ): Promise<{
-    uint256_1: BigNumber;
-    uint256_2: BigNumber;
-    0: BigNumber;
-    1: BigNumber;
-  }>;
-
   pure_stat_array(overrides?: CallOverrides): Promise<number[]>;
 
-  "pure_stat_array()"(overrides?: CallOverrides): Promise<number[]>;
-
   pure_string(overrides?: CallOverrides): Promise<string>;
 
-  "pure_string()"(overrides?: CallOverrides): Promise<string>;
-
   pure_struct(
     overrides?: CallOverrides
   ): Promise<{
@@ -387,15 +267,6 @@ export class DataTypesPure extends Contract {
     1: BigNumber;
   }>;
 
-  "pure_struct()"(
-    overrides?: CallOverrides
-  ): Promise<{
-    uint256_0: BigNumber;
-    uint256_1: BigNumber;
-    0: BigNumber;
-    1: BigNumber;
-  }>;
-
   pure_tuple(
     overrides?: CallOverrides
   ): Promise<{
@@ -403,50 +274,25 @@ export class DataTypesPure extends Contract {
     1: BigNumber;
   }>;
 
-  "pure_tuple()"(
-    overrides?: CallOverrides
-  ): Promise<{
-    0: BigNumber;
-    1: BigNumber;
-  }>;
-
   pure_uint256(overrides?: CallOverrides): Promise<BigNumber>;
 
-  "pure_uint256()"(overrides?: CallOverrides): Promise<BigNumber>;
-
   pure_uint8(overrides?: CallOverrides): Promise<number>;
 
-  "pure_uint8()"(overrides?: CallOverrides): Promise<number>;
-
   callStatic: {
     pure_address(overrides?: CallOverrides): Promise<string>;
 
-    "pure_address()"(overrides?: CallOverrides): Promise<string>;
-
     pure_bool(overrides?: CallOverrides): Promise<boolean>;
 
-    "pure_bool()"(overrides?: CallOverrides): Promise<boolean>;
-
     pure_bytes(overrides?: CallOverrides): Promise<string>;
 
-    "pure_bytes()"(overrides?: CallOverrides): Promise<string>;
-
     pure_bytes1(overrides?: CallOverrides): Promise<string>;
 
-    "pure_bytes1()"(overrides?: CallOverrides): Promise<string>;
-
     pure_enum(overrides?: CallOverrides): Promise<number>;
 
-    "pure_enum()"(overrides?: CallOverrides): Promise<number>;
-
     pure_int256(overrides?: CallOverrides): Promise<BigNumber>;
 
-    "pure_int256()"(overrides?: CallOverrides): Promise<BigNumber>;
-
     pure_int8(overrides?: CallOverrides): Promise<number>;
 
-    "pure_int8()"(overrides?: CallOverrides): Promise<number>;
-
     pure_named(
       overrides?: CallOverrides
     ): Promise<{
@@ -456,23 +302,10 @@ export class DataTypesPure extends Contract {
       1: BigNumber;
     }>;
 
-    "pure_named()"(
-      overrides?: CallOverrides
-    ): Promise<{
-      uint256_1: BigNumber;
-      uint256_2: BigNumber;
-      0: BigNumber;
-      1: BigNumber;
-    }>;
-
     pure_stat_array(overrides?: CallOverrides): Promise<number[]>;
 
-    "pure_stat_array()"(overrides?: CallOverrides): Promise<number[]>;
-
     pure_string(overrides?: CallOverrides): Promise<string>;
 
-    "pure_string()"(overrides?: CallOverrides): Promise<string>;
-
     pure_struct(
       overrides?: CallOverrides
     ): Promise<{
@@ -482,15 +315,6 @@ export class DataTypesPure extends Contract {
       1: BigNumber;
     }>;
 
-    "pure_struct()"(
-      overrides?: CallOverrides
-    ): Promise<{
-      uint256_0: BigNumber;
-      uint256_1: BigNumber;
-      0: BigNumber;
-      1: BigNumber;
-    }>;
-
     pure_tuple(
       overrides?: CallOverrides
     ): Promise<{
@@ -498,20 +322,9 @@ export class DataTypesPure extends Contract {
       1: BigNumber;
     }>;
 
-    "pure_tuple()"(
-      overrides?: CallOverrides
-    ): Promise<{
-      0: BigNumber;
-      1: BigNumber;
-    }>;
-
     pure_uint256(overrides?: CallOverrides): Promise<BigNumber>;
 
-    "pure_uint256()"(overrides?: CallOverrides): Promise<BigNumber>;
-
     pure_uint8(overrides?: CallOverrides): Promise<number>;
-
-    "pure_uint8()"(overrides?: CallOverrides): Promise<number>;
   };
 
   filters: {};
@@ -519,118 +332,60 @@ export class DataTypesPure extends Contract {
   estimateGas: {
     pure_address(overrides?: CallOverrides): Promise<BigNumber>;
 
-    "pure_address()"(overrides?: CallOverrides): Promise<BigNumber>;
-
     pure_bool(overrides?: CallOverrides): Promise<BigNumber>;
 
-    "pure_bool()"(overrides?: CallOverrides): Promise<BigNumber>;
-
     pure_bytes(overrides?: CallOverrides): Promise<BigNumber>;
 
-    "pure_bytes()"(overrides?: CallOverrides): Promise<BigNumber>;
-
     pure_bytes1(overrides?: CallOverrides): Promise<BigNumber>;
 
-    "pure_bytes1()"(overrides?: CallOverrides): Promise<BigNumber>;
-
     pure_enum(overrides?: CallOverrides): Promise<BigNumber>;
 
-    "pure_enum()"(overrides?: CallOverrides): Promise<BigNumber>;
-
     pure_int256(overrides?: CallOverrides): Promise<BigNumber>;
 
-    "pure_int256()"(overrides?: CallOverrides): Promise<BigNumber>;
-
     pure_int8(overrides?: CallOverrides): Promise<BigNumber>;
 
-    "pure_int8()"(overrides?: CallOverrides): Promise<BigNumber>;
-
     pure_named(overrides?: CallOverrides): Promise<BigNumber>;
 
-    "pure_named()"(overrides?: CallOverrides): Promise<BigNumber>;
-
     pure_stat_array(overrides?: CallOverrides): Promise<BigNumber>;
 
-    "pure_stat_array()"(overrides?: CallOverrides): Promise<BigNumber>;
-
     pure_string(overrides?: CallOverrides): Promise<BigNumber>;
 
-    "pure_string()"(overrides?: CallOverrides): Promise<BigNumber>;
-
     pure_struct(overrides?: CallOverrides): Promise<BigNumber>;
 
-    "pure_struct()"(overrides?: CallOverrides): Promise<BigNumber>;
-
     pure_tuple(overrides?: CallOverrides): Promise<BigNumber>;
 
-    "pure_tuple()"(overrides?: CallOverrides): Promise<BigNumber>;
-
     pure_uint256(overrides?: CallOverrides): Promise<BigNumber>;
 
-    "pure_uint256()"(overrides?: CallOverrides): Promise<BigNumber>;
-
     pure_uint8(overrides?: CallOverrides): Promise<BigNumber>;
-
-    "pure_uint8()"(overrides?: CallOverrides): Promise<BigNumber>;
   };
 
   populateTransaction: {
     pure_address(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
-    "pure_address()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-
     pure_bool(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
-    "pure_bool()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-
     pure_bytes(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
-    "pure_bytes()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-
     pure_bytes1(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
-    "pure_bytes1()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-
     pure_enum(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
-    "pure_enum()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-
     pure_int256(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
-    "pure_int256()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-
     pure_int8(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
-    "pure_int8()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-
     pure_named(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
-    "pure_named()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-
     pure_stat_array(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
-    "pure_stat_array()"(
-      overrides?: CallOverrides
-    ): Promise<PopulatedTransaction>;
-
     pure_string(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
-    "pure_string()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-
     pure_struct(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
-    "pure_struct()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-
     pure_tuple(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
-    "pure_tuple()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-
     pure_uint256(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
-    "pure_uint256()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-
     pure_uint8(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-
-    "pure_uint8()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
   };
 }
diff --git a/packages/target-ethers-v5-test/types/DataTypesView.d.ts b/packages/target-ethers-v5-test/types/DataTypesView.d.ts
index 7b7c7214e..3c72c12eb 100644
--- a/packages/target-ethers-v5-test/types/DataTypesView.d.ts
+++ b/packages/target-ethers-v5-test/types/DataTypesView.d.ts
@@ -143,84 +143,42 @@ export class DataTypesView extends Contract {
       0: string;
     }>;
 
-    "view_address()"(
-      overrides?: CallOverrides
-    ): Promise<{
-      0: string;
-    }>;
-
     view_bool(
       overrides?: CallOverrides
     ): Promise<{
       0: boolean;
     }>;
 
-    "view_bool()"(
-      overrides?: CallOverrides
-    ): Promise<{
-      0: boolean;
-    }>;
-
     view_bytes(
       overrides?: CallOverrides
     ): Promise<{
       0: string;
     }>;
 
-    "view_bytes()"(
-      overrides?: CallOverrides
-    ): Promise<{
-      0: string;
-    }>;
-
     view_bytes1(
       overrides?: CallOverrides
     ): Promise<{
       0: string;
     }>;
 
-    "view_bytes1()"(
-      overrides?: CallOverrides
-    ): Promise<{
-      0: string;
-    }>;
-
     view_enum(
       overrides?: CallOverrides
     ): Promise<{
       0: number;
     }>;
 
-    "view_enum()"(
-      overrides?: CallOverrides
-    ): Promise<{
-      0: number;
-    }>;
-
     view_int256(
       overrides?: CallOverrides
     ): Promise<{
       0: BigNumber;
     }>;
 
-    "view_int256()"(
-      overrides?: CallOverrides
-    ): Promise<{
-      0: BigNumber;
-    }>;
-
     view_int8(
       overrides?: CallOverrides
     ): Promise<{
       0: number;
     }>;
 
-    "view_int8()"(
-      overrides?: CallOverrides
-    ): Promise<{
-      0: number;
-    }>;
-
     view_named(
       overrides?: CallOverrides
     ): Promise<{
@@ -230,39 +188,18 @@ export class DataTypesView extends Contract {
       1: BigNumber;
     }>;
 
-    "view_named()"(
-      overrides?: CallOverrides
-    ): Promise<{
-      uint256_1: BigNumber;
-      uint256_2: BigNumber;
-      0: BigNumber;
-      1: BigNumber;
-    }>;
-
     view_stat_array(
       overrides?: CallOverrides
     ): Promise<{
       0: number[];
     }>;
 
-    "view_stat_array()"(
-      overrides?: CallOverrides
-    ): Promise<{
-      0: number[];
-    }>;
-
     view_string(
       overrides?: CallOverrides
     ): Promise<{
       0: string;
     }>;
 
-    "view_string()"(
-      overrides?: CallOverrides
-    ): Promise<{
-      0: string;
-    }>;
-
     view_struct(
       overrides?: CallOverrides
     ): Promise<{
@@ -274,17 +211,6 @@ export class DataTypesView extends Contract {
       };
     }>;
 
-    "view_struct()"(
-      overrides?: CallOverrides
-    ): Promise<{
-      0: {
-        uint256_0: BigNumber;
-        uint256_1: BigNumber;
-        0: BigNumber;
-        1: BigNumber;
-      };
-    }>;
-
     view_tuple(
       overrides?: CallOverrides
     ): Promise<{
@@ -292,66 +218,33 @@ export class DataTypesView extends Contract {
       1: BigNumber;
     }>;
 
-    "view_tuple()"(
-      overrides?: CallOverrides
-    ): Promise<{
-      0: BigNumber;
-      1: BigNumber;
-    }>;
-
     view_uint256(
       overrides?: CallOverrides
     ): Promise<{
       0: BigNumber;
     }>;
 
-    "view_uint256()"(
-      overrides?: CallOverrides
-    ): Promise<{
-      0: BigNumber;
-    }>;
-
     view_uint8(
       overrides?: CallOverrides
     ): Promise<{
       0: number;
     }>;
-
-    "view_uint8()"(
-      overrides?: CallOverrides
-    ): Promise<{
-      0: number;
-    }>;
   };
 
   view_address(overrides?: CallOverrides): Promise<string>;
 
-  "view_address()"(overrides?: CallOverrides): Promise<string>;
-
   view_bool(overrides?: CallOverrides): Promise<boolean>;
 
-  "view_bool()"(overrides?: CallOverrides): Promise<boolean>;
-
   view_bytes(overrides?: CallOverrides): Promise<string>;
 
-  "view_bytes()"(overrides?: CallOverrides): Promise<string>;
-
   view_bytes1(overrides?: CallOverrides): Promise<string>;
 
-  "view_bytes1()"(overrides?: CallOverrides): Promise<string>;
-
   view_enum(overrides?: CallOverrides): Promise<number>;
 
-  "view_enum()"(overrides?: CallOverrides): Promise<number>;
-
   view_int256(overrides?: CallOverrides): Promise<BigNumber>;
 
-  "view_int256()"(overrides?: CallOverrides): Promise<BigNumber>;
-
   view_int8(overrides?: CallOverrides): Promise<number>;
 
-  "view_int8()"(overrides?: CallOverrides): Promise<number>;
-
   view_named(
     overrides?: CallOverrides
   ): Promise<{
@@ -361,23 +254,10 @@ export class DataTypesView extends Contract {
     1: BigNumber;
   }>;
 
-  "view_named()"(
-    overrides?: CallOverrides
-  ): Promise<{
-    uint256_1: BigNumber;
-    uint256_2: BigNumber;
-    0: BigNumber;
-    1: BigNumber;
-  }>;
-
   view_stat_array(overrides?: CallOverrides): Promise<number[]>;
 
-  "view_stat_array()"(overrides?: CallOverrides): Promise<number[]>;
-
   view_string(overrides?: CallOverrides): Promise<string>;
 
-  "view_string()"(overrides?: CallOverrides): Promise<string>;
-
   view_struct(
     overrides?: CallOverrides
   ): Promise<{
@@ -387,15 +267,6 @@ export class DataTypesView extends Contract {
     1: BigNumber;
   }>;
 
-  "view_struct()"(
-    overrides?: CallOverrides
-  ): Promise<{
-    uint256_0: BigNumber;
-    uint256_1: BigNumber;
-    0: BigNumber;
-    1: BigNumber;
-  }>;
-
   view_tuple(
     overrides?: CallOverrides
   ): Promise<{
@@ -403,50 +274,25 @@ export class DataTypesView extends Contract {
     1: BigNumber;
   }>;
 
-  "view_tuple()"(
-    overrides?: CallOverrides
-  ): Promise<{
-    0: BigNumber;
-    1: BigNumber;
-  }>;
-
   view_uint256(overrides?: CallOverrides): Promise<BigNumber>;
 
-  "view_uint256()"(overrides?: CallOverrides): Promise<BigNumber>;
-
   view_uint8(overrides?: CallOverrides): Promise<number>;
 
-  "view_uint8()"(overrides?: CallOverrides): Promise<number>;
-
   callStatic: {
     view_address(overrides?: CallOverrides): Promise<string>;
 
-    "view_address()"(overrides?: CallOverrides): Promise<string>;
-
     view_bool(overrides?: CallOverrides): Promise<boolean>;
 
-    "view_bool()"(overrides?: CallOverrides): Promise<boolean>;
-
     view_bytes(overrides?: CallOverrides): Promise<string>;
 
-    "view_bytes()"(overrides?: CallOverrides): Promise<string>;
-
     view_bytes1(overrides?: CallOverrides): Promise<string>;
 
-    "view_bytes1()"(overrides?: CallOverrides): Promise<string>;
-
     view_enum(overrides?: CallOverrides): Promise<number>;
 
-    "view_enum()"(overrides?: CallOverrides): Promise<number>;
-
     view_int256(overrides?: CallOverrides): Promise<BigNumber>;
 
-    "view_int256()"(overrides?: CallOverrides): Promise<BigNumber>;
-
     view_int8(overrides?: CallOverrides): Promise<number>;
 
-    "view_int8()"(overrides?: CallOverrides): Promise<number>;
-
     view_named(
       overrides?: CallOverrides
     ): Promise<{
@@ -456,23 +302,10 @@ export class DataTypesView extends Contract {
       1: BigNumber;
     }>;
 
-    "view_named()"(
-      overrides?: CallOverrides
-    ): Promise<{
-      uint256_1: BigNumber;
-      uint256_2: BigNumber;
-      0: BigNumber;
-      1: BigNumber;
-    }>;
-
     view_stat_array(overrides?: CallOverrides): Promise<number[]>;
 
-    "view_stat_array()"(overrides?: CallOverrides): Promise<number[]>;
-
     view_string(overrides?: CallOverrides): Promise<string>;
 
-    "view_string()"(overrides?: CallOverrides): Promise<string>;
-
     view_struct(
       overrides?: CallOverrides
     ): Promise<{
@@ -482,15 +315,6 @@ export class DataTypesView extends Contract {
       1: BigNumber;
     }>;
 
-    "view_struct()"(
-      overrides?: CallOverrides
-    ): Promise<{
-      uint256_0: BigNumber;
-      uint256_1: BigNumber;
-      0: BigNumber;
-      1: BigNumber;
-    }>;
-
     view_tuple(
       overrides?: CallOverrides
     ): Promise<{
@@ -498,20 +322,9 @@ export class DataTypesView extends Contract {
       1: BigNumber;
     }>;
 
-    "view_tuple()"(
-      overrides?: CallOverrides
-    ): Promise<{
-      0: BigNumber;
-      1: BigNumber;
-    }>;
-
     view_uint256(overrides?: CallOverrides): Promise<BigNumber>;
 
-    "view_uint256()"(overrides?: CallOverrides): Promise<BigNumber>;
-
     view_uint8(overrides?: CallOverrides): Promise<number>;
-
-    "view_uint8()"(overrides?: CallOverrides): Promise<number>;
   };
 
   filters: {};
@@ -519,118 +332,60 @@ export class DataTypesView extends Contract {
   estimateGas: {
     view_address(overrides?: CallOverrides): Promise<BigNumber>;
 
-    "view_address()"(overrides?: CallOverrides): Promise<BigNumber>;
-
     view_bool(overrides?: CallOverrides): Promise<BigNumber>;
 
-    "view_bool()"(overrides?: CallOverrides): Promise<BigNumber>;
-
     view_bytes(overrides?: CallOverrides): Promise<BigNumber>;
 
-    "view_bytes()"(overrides?: CallOverrides): Promise<BigNumber>;
-
     view_bytes1(overrides?: CallOverrides): Promise<BigNumber>;
 
-    "view_bytes1()"(overrides?: CallOverrides): Promise<BigNumber>;
-
     view_enum(overrides?: CallOverrides): Promise<BigNumber>;
 
-    "view_enum()"(overrides?: CallOverrides): Promise<BigNumber>;
-
     view_int256(overrides?: CallOverrides): Promise<BigNumber>;
 
-    "view_int256()"(overrides?: CallOverrides): Promise<BigNumber>;
-
     view_int8(overrides?: CallOverrides): Promise<BigNumber>;
 
-    "view_int8()"(overrides?: CallOverrides): Promise<BigNumber>;
-
     view_named(overrides?: CallOverrides): Promise<BigNumber>;
 
-    "view_named()"(overrides?: CallOverrides): Promise<BigNumber>;
-
     view_stat_array(overrides?: CallOverrides): Promise<BigNumber>;
 
-    "view_stat_array()"(overrides?: CallOverrides): Promise<BigNumber>;
-
     view_string(overrides?: CallOverrides): Promise<BigNumber>;
 
-    "view_string()"(overrides?: CallOverrides): Promise<BigNumber>;
-
     view_struct(overrides?: CallOverrides): Promise<BigNumber>;
 
-    "view_struct()"(overrides?: CallOverrides): Promise<BigNumber>;
-
     view_tuple(overrides?: CallOverrides): Promise<BigNumber>;
 
-    "view_tuple()"(overrides?: CallOverrides): Promise<BigNumber>;
-
     view_uint256(overrides?: CallOverrides): Promise<BigNumber>;
 
-    "view_uint256()"(overrides?: CallOverrides): Promise<BigNumber>;
-
     view_uint8(overrides?: CallOverrides): Promise<BigNumber>;
-
-    "view_uint8()"(overrides?: CallOverrides): Promise<BigNumber>;
   };
 
   populateTransaction: {
     view_address(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
-    "view_address()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-
     view_bool(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
-    "view_bool()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-
     view_bytes(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
-    "view_bytes()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-
     view_bytes1(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
-    "view_bytes1()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-
     view_enum(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
-    "view_enum()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-
     view_int256(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
-    "view_int256()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-
     view_int8(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
-    "view_int8()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-
     view_named(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
-    "view_named()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-
     view_stat_array(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
-    "view_stat_array()"(
-      overrides?: CallOverrides
-    ): Promise<PopulatedTransaction>;
-
     view_string(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
-    "view_string()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-
     view_struct(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
-    "view_struct()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-
     view_tuple(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
-    "view_tuple()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-
     view_uint256(overrides?: CallOverrides): Promise<PopulatedTransaction>;
 
-    "view_uint256()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-
     view_uint8(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-
-    "view_uint8()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
   };
 }
diff --git a/packages/target-ethers-v5-test/types/Events.d.ts b/packages/target-ethers-v5-test/types/Events.d.ts
index cbeda2009..a959a2301 100644
--- a/packages/target-ethers-v5-test/types/Events.d.ts
+++ b/packages/target-ethers-v5-test/types/Events.d.ts
@@ -95,69 +95,35 @@ export class Events extends Contract {
   functions: {
     emit_anon1(overrides?: Overrides): Promise<ContractTransaction>;
 
-    "emit_anon1()"(overrides?: Overrides): Promise<ContractTransaction>;
-
     emit_event1(overrides?: Overrides): Promise<ContractTransaction>;
 
-    "emit_event1()"(overrides?: Overrides): Promise<ContractTransaction>;
-
     emit_event2(overrides?: Overrides): Promise<ContractTransaction>;
 
-    "emit_event2()"(overrides?: Overrides): Promise<ContractTransaction>;
-
     emit_event3(overrides?: Overrides): Promise<ContractTransaction>;
 
-    "emit_event3()"(overrides?: Overrides): Promise<ContractTransaction>;
-
     emit_event3_overloaded(overrides?: Overrides): Promise<ContractTransaction>;
-
-    "emit_event3_overloaded()"(
-      overrides?: Overrides
-    ): Promise<ContractTransaction>;
   };
 
   emit_anon1(overrides?: Overrides): Promise<ContractTransaction>;
 
-  "emit_anon1()"(overrides?: Overrides): Promise<ContractTransaction>;
-
   emit_event1(overrides?: Overrides): Promise<ContractTransaction>;
 
-  "emit_event1()"(overrides?: Overrides): Promise<ContractTransaction>;
-
   emit_event2(overrides?: Overrides): Promise<ContractTransaction>;
 
-  "emit_event2()"(overrides?: Overrides): Promise<ContractTransaction>;
-
   emit_event3(overrides?: Overrides): Promise<ContractTransaction>;
 
-  "emit_event3()"(overrides?: Overrides): Promise<ContractTransaction>;
-
   emit_event3_overloaded(overrides?: Overrides): Promise<ContractTransaction>;
 
-  "emit_event3_overloaded()"(
-    overrides?: Overrides
-  ): Promise<ContractTransaction>;
-
   callStatic: {
     emit_anon1(overrides?: Overrides): Promise<void>;
 
-    "emit_anon1()"(overrides?: Overrides): Promise<void>;
-
     emit_event1(overrides?: Overrides): Promise<void>;
 
-    "emit_event1()"(overrides?: Overrides): Promise<void>;
-
     emit_event2(overrides?: Overrides): Promise<void>;
 
-    "emit_event2()"(overrides?: Overrides): Promise<void>;
-
     emit_event3(overrides?: Overrides): Promise<void>;
 
-    "emit_event3()"(overrides?: Overrides): Promise<void>;
-
     emit_event3_overloaded(overrides?: Overrides): Promise<void>;
-
-    "emit_event3_overloaded()"(overrides?: Overrides): Promise<void>;
   };
 
   filters: {
@@ -173,48 +139,26 @@ export class Events extends Contract {
   estimateGas: {
     emit_anon1(overrides?: Overrides): Promise<BigNumber>;
 
-    "emit_anon1()"(overrides?: Overrides): Promise<BigNumber>;
-
     emit_event1(overrides?: Overrides): Promise<BigNumber>;
 
-    "emit_event1()"(overrides?: Overrides): Promise<BigNumber>;
-
     emit_event2(overrides?: Overrides): Promise<BigNumber>;
 
-    "emit_event2()"(overrides?: Overrides): Promise<BigNumber>;
-
     emit_event3(overrides?: Overrides): Promise<BigNumber>;
 
-    "emit_event3()"(overrides?: Overrides): Promise<BigNumber>;
-
     emit_event3_overloaded(overrides?: Overrides): Promise<BigNumber>;
-
-    "emit_event3_overloaded()"(overrides?: Overrides): Promise<BigNumber>;
   };
 
   populateTransaction: {
     emit_anon1(overrides?: Overrides): Promise<PopulatedTransaction>;
 
-    "emit_anon1()"(overrides?: Overrides): Promise<PopulatedTransaction>;
-
     emit_event1(overrides?: Overrides): Promise<PopulatedTransaction>;
 
-    "emit_event1()"(overrides?: Overrides): Promise<PopulatedTransaction>;
-
     emit_event2(overrides?: Overrides): Promise<PopulatedTransaction>;
 
-    "emit_event2()"(overrides?: Overrides): Promise<PopulatedTransaction>;
-
     emit_event3(overrides?: Overrides): Promise<PopulatedTransaction>;
 
-    "emit_event3()"(overrides?: Overrides): Promise<PopulatedTransaction>;
-
     emit_event3_overloaded(
       overrides?: Overrides
     ): Promise<PopulatedTransaction>;
-
-    "emit_event3_overloaded()"(
-      overrides?: Overrides
-    ): Promise<PopulatedTransaction>;
   };
 }
diff --git a/packages/target-ethers-v5-test/types/NameMangling.d.ts b/packages/target-ethers-v5-test/types/NameMangling.d.ts
index ac2abd352..003f60f06 100644
--- a/packages/target-ethers-v5-test/types/NameMangling.d.ts
+++ b/packages/target-ethers-v5-test/types/NameMangling.d.ts
@@ -49,35 +49,21 @@ export class NameMangling extends Contract {
     ): Promise<{
       0: boolean;
     }>;
-
-    "works()"(
-      overrides?: CallOverrides
-    ): Promise<{
-      0: boolean;
-    }>;
   };
 
   works(overrides?: CallOverrides): Promise<boolean>;
 
-  "works()"(overrides?: CallOverrides): Promise<boolean>;
-
   callStatic: {
     works(overrides?: CallOverrides): Promise<boolean>;
-
-    "works()"(overrides?: CallOverrides): Promise<boolean>;
   };
 
   filters: {};
 
   estimateGas: {
     works(overrides?: CallOverrides): Promise<BigNumber>;
-
-    "works()"(overrides?: CallOverrides): Promise<BigNumber>;
   };
 
   populateTransaction: {
     works(overrides?: CallOverrides): Promise<PopulatedTransaction>;
-
-    "works()"(overrides?: CallOverrides): Promise<PopulatedTransaction>;
   };
 }
diff --git a/packages/target-ethers-v5-test/types/Payable.d.ts b/packages/target-ethers-v5-test/types/Payable.d.ts
index 3054174ef..8a36dc317 100644
--- a/packages/target-ethers-v5-test/types/Payable.d.ts
+++ b/packages/target-ethers-v5-test/types/Payable.d.ts
@@ -62,31 +62,17 @@ export class Payable extends Contract {
   functions: {
     non_payable_func(overrides?: Overrides): Promise<ContractTransaction>;
 
-    "non_payable_func()"(overrides?: Overrides): Promise<ContractTransaction>;
-
     payable_func(overrides?: PayableOverrides): Promise<ContractTransaction>;
-
-    "payable_func()"(
-      overrides?: PayableOverrides
-    ): Promise<ContractTransaction>;
   };
 
   non_payable_func(overrides?: Overrides): Promise<ContractTransaction>;
 
-  "non_payable_func()"(overrides?: Overrides): Promise<ContractTransaction>;
-
   payable_func(overrides?: PayableOverrides): Promise<ContractTransaction>;
 
-  "payable_func()"(overrides?: PayableOverrides): Promise<ContractTransaction>;
-
   callStatic: {
     non_payable_func(overrides?: Overrides): Promise<void>;
 
-    "non_payable_func()"(overrides?: Overrides): Promise<void>;
-
     payable_func(overrides?: PayableOverrides): Promise<void>;
-
-    "payable_func()"(overrides?: PayableOverrides): Promise<void>;
   };
 
   filters: {};
@@ -94,22 +80,12 @@ export class Payable extends Contract {
   estimateGas: {
     non_payable_func(overrides?: Overrides): Promise<BigNumber>;
 
-    "non_payable_func()"(overrides?: Overrides): Promise<BigNumber>;
-
     payable_func(overrides?: PayableOverrides): Promise<BigNumber>;
-
-    "payable_func()"(overrides?: PayableOverrides): Promise<BigNumber>;
   };
 
   populateTransaction: {
     non_payable_func(overrides?: Overrides): Promise<PopulatedTransaction>;
 
-    "non_payable_func()"(overrides?: Overrides): Promise<PopulatedTransaction>;
-
     payable_func(overrides?: PayableOverrides): Promise<PopulatedTransaction>;
-
-    "payable_func()"(
-      overrides?: PayableOverrides
-    ): Promise<PopulatedTransaction>;
   };
 }

From 7fc5075cb2e6d5ea1607b347ee13aace3e86a257 Mon Sep 17 00:00:00 2001
From: Braden Napier <brady.napier@dashos.net>
Date: Thu, 9 Jul 2020 05:26:35 -0400
Subject: [PATCH 53/64] chore: rerun build_and_test


From 8645b8db6b203511c9b233fd2ff68a041282d742 Mon Sep 17 00:00:00 2001
From: zemse <sohamzemse143@gmail.com>
Date: Mon, 13 Jul 2020 00:36:26 +0530
Subject: [PATCH 54/64] Fix callStatic overrides for non constant fns

---
 packages/target-ethers-v5/src/codegen/functions.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/target-ethers-v5/src/codegen/functions.ts b/packages/target-ethers-v5/src/codegen/functions.ts
index 8fb00d51b..1dc69d1a9 100644
--- a/packages/target-ethers-v5/src/codegen/functions.ts
+++ b/packages/target-ethers-v5/src/codegen/functions.ts
@@ -26,7 +26,7 @@ function generateFunction(options: GenerateFunctionOptions, fn: FunctionDeclarat
   return `
   ${generateFunctionDocumentation(fn.documentation)}
   ${overloadedName ?? fn.name}(${generateInputTypes(fn.inputs)}${
-    !isConstant(fn) && !isConstantFn(fn)
+    !options.isStaticCall && !isConstant(fn) && !isConstantFn(fn)
       ? `overrides?: ${isPayable(fn) ? 'PayableOverrides' : 'Overrides'}`
       : 'overrides?: CallOverrides'
   }): Promise<${

From ecb6d538864a9a62e44045d30f0d4af5d17340b3 Mon Sep 17 00:00:00 2001
From: Krzysztof Kaczor <krzkaczor@gmail.com>
Date: Thu, 16 Jul 2020 19:25:21 +0200
Subject: [PATCH 55/64] Bump version

---
 packages/target-ethers-v5/package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/target-ethers-v5/package.json b/packages/target-ethers-v5/package.json
index 863bfe4e5..9996b150d 100644
--- a/packages/target-ethers-v5/package.json
+++ b/packages/target-ethers-v5/package.json
@@ -8,7 +8,7 @@
     "TypeChain",
     "TypeScript"
   ],
-  "version": "0.0.2",
+  "version": "0.0.3",
   "license": "MIT",
   "repository": "https://github.com/ethereum-ts/Typechain",
   "main": "./dist/index.js",

From a3957335188751ad624d2a8ecf60271722722945 Mon Sep 17 00:00:00 2001
From: zemse <sohamzemse143@gmail.com>
Date: Fri, 24 Jul 2020 17:22:13 +0530
Subject: [PATCH 56/64] Fix abstract contract filename

---
 packages/target-ethers-v5/src/index.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/target-ethers-v5/src/index.ts b/packages/target-ethers-v5/src/index.ts
index adffd8919..4279085bf 100644
--- a/packages/target-ethers-v5/src/index.ts
+++ b/packages/target-ethers-v5/src/index.ts
@@ -116,7 +116,7 @@ export default class Ethers extends TsGeneratorPlugin {
     const abstractFactoryFiles = Object.keys(this.contractCache).map((contractName) => {
       const { contract, abi } = this.contractCache[contractName]
       return {
-        path: join(this.outDirAbs, `${contract.name}Contract.ts`),
+        path: join(this.outDirAbs, `${contract.name}Factory.ts`),
         contents: codegenAbstractContractFactory(contract, abi),
       }
     })

From cdf65dc0e23b7bc2ad99434dcbcf9c6efecd1a9d Mon Sep 17 00:00:00 2001
From: zemse <sohamzemse143@gmail.com>
Date: Fri, 24 Jul 2020 17:23:12 +0530
Subject: [PATCH 57/64] Regenerate types

---
 .../types/{DataTypesInputContract.ts => DataTypesInputFactory.ts} | 0
 .../types/{DataTypesPureContract.ts => DataTypesPureFactory.ts}   | 0
 .../types/{DataTypesViewContract.ts => DataTypesViewFactory.ts}   | 0
 .../types/{EventsContract.ts => EventsFactory.ts}                 | 0
 .../types/{NameManglingContract.ts => NameManglingFactory.ts}     | 0
 .../types/{OverloadsContract.ts => OverloadsFactory.ts}           | 0
 .../types/{PayableContract.ts => PayableFactory.ts}               | 0
 7 files changed, 0 insertions(+), 0 deletions(-)
 rename packages/target-ethers-v5-test/types/{DataTypesInputContract.ts => DataTypesInputFactory.ts} (100%)
 rename packages/target-ethers-v5-test/types/{DataTypesPureContract.ts => DataTypesPureFactory.ts} (100%)
 rename packages/target-ethers-v5-test/types/{DataTypesViewContract.ts => DataTypesViewFactory.ts} (100%)
 rename packages/target-ethers-v5-test/types/{EventsContract.ts => EventsFactory.ts} (100%)
 rename packages/target-ethers-v5-test/types/{NameManglingContract.ts => NameManglingFactory.ts} (100%)
 rename packages/target-ethers-v5-test/types/{OverloadsContract.ts => OverloadsFactory.ts} (100%)
 rename packages/target-ethers-v5-test/types/{PayableContract.ts => PayableFactory.ts} (100%)

diff --git a/packages/target-ethers-v5-test/types/DataTypesInputContract.ts b/packages/target-ethers-v5-test/types/DataTypesInputFactory.ts
similarity index 100%
rename from packages/target-ethers-v5-test/types/DataTypesInputContract.ts
rename to packages/target-ethers-v5-test/types/DataTypesInputFactory.ts
diff --git a/packages/target-ethers-v5-test/types/DataTypesPureContract.ts b/packages/target-ethers-v5-test/types/DataTypesPureFactory.ts
similarity index 100%
rename from packages/target-ethers-v5-test/types/DataTypesPureContract.ts
rename to packages/target-ethers-v5-test/types/DataTypesPureFactory.ts
diff --git a/packages/target-ethers-v5-test/types/DataTypesViewContract.ts b/packages/target-ethers-v5-test/types/DataTypesViewFactory.ts
similarity index 100%
rename from packages/target-ethers-v5-test/types/DataTypesViewContract.ts
rename to packages/target-ethers-v5-test/types/DataTypesViewFactory.ts
diff --git a/packages/target-ethers-v5-test/types/EventsContract.ts b/packages/target-ethers-v5-test/types/EventsFactory.ts
similarity index 100%
rename from packages/target-ethers-v5-test/types/EventsContract.ts
rename to packages/target-ethers-v5-test/types/EventsFactory.ts
diff --git a/packages/target-ethers-v5-test/types/NameManglingContract.ts b/packages/target-ethers-v5-test/types/NameManglingFactory.ts
similarity index 100%
rename from packages/target-ethers-v5-test/types/NameManglingContract.ts
rename to packages/target-ethers-v5-test/types/NameManglingFactory.ts
diff --git a/packages/target-ethers-v5-test/types/OverloadsContract.ts b/packages/target-ethers-v5-test/types/OverloadsFactory.ts
similarity index 100%
rename from packages/target-ethers-v5-test/types/OverloadsContract.ts
rename to packages/target-ethers-v5-test/types/OverloadsFactory.ts
diff --git a/packages/target-ethers-v5-test/types/PayableContract.ts b/packages/target-ethers-v5-test/types/PayableFactory.ts
similarity index 100%
rename from packages/target-ethers-v5-test/types/PayableContract.ts
rename to packages/target-ethers-v5-test/types/PayableFactory.ts

From 5e6d5203593112c7a20c0d1bba6a8d95f90380e5 Mon Sep 17 00:00:00 2001
From: Krzysztof Kaczor <krzkaczor@gmail.com>
Date: Sun, 26 Jul 2020 20:00:19 +0200
Subject: [PATCH 58/64] Ensure no git changes

---
 .circleci/config.yml | 1 +
 package.json         | 1 +
 2 files changed, 2 insertions(+)

diff --git a/.circleci/config.yml b/.circleci/config.yml
index 19ee24370..02b41a493 100644
--- a/.circleci/config.yml
+++ b/.circleci/config.yml
@@ -29,6 +29,7 @@ jobs:
       - run: yarn test
       - run: yarn format # do it at the very end because test can generate types (which should be formatted)
       - run: yarn check-examples
+      - run: yarn no-git-changes # ensure that committed types are up to date
 
 workflows:
   version: 2
diff --git a/package.json b/package.json
index 16ee66de5..b9ad978f1 100644
--- a/package.json
+++ b/package.json
@@ -18,6 +18,7 @@
     "compile-contracts": "./scripts/compile-contracts/compile-contracts.sh && wsrun -m -c compile-contracts",
     "test": "yarn compile-contracts && wsrun -mse -c test",
     "test:fix": "yarn lint:fix && yarn test && yarn format:fix && yarn typecheck",
+    "no-git-changes": "./scripts/no-git-changes.sh",
     "check-examples": "./scripts/check-examples.sh"
   },
   "workspaces": [

From d3dcb5a00b1ce7dd1892c001dbdd0ef69e23aba6 Mon Sep 17 00:00:00 2001
From: Krzysztof Kaczor <krzkaczor@gmail.com>
Date: Sun, 26 Jul 2020 20:04:29 +0200
Subject: [PATCH 59/64] Add uncommitted files

---
 packages/target-ethers-v5-test/types/Events.d.ts  | 10 +++++-----
 packages/target-ethers-v5-test/types/Payable.d.ts |  4 ++--
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/packages/target-ethers-v5-test/types/Events.d.ts b/packages/target-ethers-v5-test/types/Events.d.ts
index a959a2301..76bb7d447 100644
--- a/packages/target-ethers-v5-test/types/Events.d.ts
+++ b/packages/target-ethers-v5-test/types/Events.d.ts
@@ -115,15 +115,15 @@ export class Events extends Contract {
   emit_event3_overloaded(overrides?: Overrides): Promise<ContractTransaction>;
 
   callStatic: {
-    emit_anon1(overrides?: Overrides): Promise<void>;
+    emit_anon1(overrides?: CallOverrides): Promise<void>;
 
-    emit_event1(overrides?: Overrides): Promise<void>;
+    emit_event1(overrides?: CallOverrides): Promise<void>;
 
-    emit_event2(overrides?: Overrides): Promise<void>;
+    emit_event2(overrides?: CallOverrides): Promise<void>;
 
-    emit_event3(overrides?: Overrides): Promise<void>;
+    emit_event3(overrides?: CallOverrides): Promise<void>;
 
-    emit_event3_overloaded(overrides?: Overrides): Promise<void>;
+    emit_event3_overloaded(overrides?: CallOverrides): Promise<void>;
   };
 
   filters: {
diff --git a/packages/target-ethers-v5-test/types/Payable.d.ts b/packages/target-ethers-v5-test/types/Payable.d.ts
index 8a36dc317..2bd6f86a4 100644
--- a/packages/target-ethers-v5-test/types/Payable.d.ts
+++ b/packages/target-ethers-v5-test/types/Payable.d.ts
@@ -70,9 +70,9 @@ export class Payable extends Contract {
   payable_func(overrides?: PayableOverrides): Promise<ContractTransaction>;
 
   callStatic: {
-    non_payable_func(overrides?: Overrides): Promise<void>;
+    non_payable_func(overrides?: CallOverrides): Promise<void>;
 
-    payable_func(overrides?: PayableOverrides): Promise<void>;
+    payable_func(overrides?: CallOverrides): Promise<void>;
   };
 
   filters: {};

From 3a8727c7e1cc8bde9ea840b498bf608ef1f50117 Mon Sep 17 00:00:00 2001
From: zemse <sohamzemse143@gmail.com>
Date: Sun, 19 Jul 2020 02:03:32 +0530
Subject: [PATCH 60/64] Include callStatic while determining imports

This commit fixes a bug described in:
https://github.com/ethereum-ts/TypeChain/pull/258#issuecomment-660537576
---
 packages/target-ethers-v5/src/codegen/index.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/target-ethers-v5/src/codegen/index.ts b/packages/target-ethers-v5/src/codegen/index.ts
index 06c84fbde..dbc831516 100644
--- a/packages/target-ethers-v5/src/codegen/index.ts
+++ b/packages/target-ethers-v5/src/codegen/index.ts
@@ -13,7 +13,7 @@ import { codegenFunctions } from './functions'
 export function codegenContractTypings(contract: Contract) {
   const contractImports: string[] = ['Contract', 'ContractTransaction']
   const allFunctions = values(contract.functions)
-    .map(codegenFunctions.bind(null, { returnResultObject: true }))
+    .map((fn) => codegenFunctions({ returnResultObject: true }, fn) + codegenFunctions({ isStaticCall: true }, fn))
     .join('')
 
   const optionalContractImports = ['Overrides', 'PayableOverrides', 'CallOverrides']

From 99383915ffe74510e37e4cee275107ca314dfad2 Mon Sep 17 00:00:00 2001
From: zemse <sohamzemse143@gmail.com>
Date: Sun, 19 Jul 2020 02:03:41 +0530
Subject: [PATCH 61/64] Run yarn test

---
 packages/target-ethers-v5-test/types/Events.d.ts  | 3 ++-
 packages/target-ethers-v5-test/types/Payable.d.ts | 3 ++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/packages/target-ethers-v5-test/types/Events.d.ts b/packages/target-ethers-v5-test/types/Events.d.ts
index 76bb7d447..23bd46127 100644
--- a/packages/target-ethers-v5-test/types/Events.d.ts
+++ b/packages/target-ethers-v5-test/types/Events.d.ts
@@ -12,7 +12,8 @@ import {
 import {
   Contract,
   ContractTransaction,
-  Overrides
+  Overrides,
+  CallOverrides
 } from "@ethersproject/contracts";
 import { BytesLike } from "@ethersproject/bytes";
 import { Listener, Provider } from "@ethersproject/providers";
diff --git a/packages/target-ethers-v5-test/types/Payable.d.ts b/packages/target-ethers-v5-test/types/Payable.d.ts
index 2bd6f86a4..fb6351ed0 100644
--- a/packages/target-ethers-v5-test/types/Payable.d.ts
+++ b/packages/target-ethers-v5-test/types/Payable.d.ts
@@ -13,7 +13,8 @@ import {
   Contract,
   ContractTransaction,
   Overrides,
-  PayableOverrides
+  PayableOverrides,
+  CallOverrides
 } from "@ethersproject/contracts";
 import { BytesLike } from "@ethersproject/bytes";
 import { Listener, Provider } from "@ethersproject/providers";

From f410e2b0c731f61138b64e670af9bc4e88fb6eec Mon Sep 17 00:00:00 2001
From: Krzysztof Kaczor <krzkaczor@gmail.com>
Date: Fri, 31 Jul 2020 14:36:40 +0200
Subject: [PATCH 62/64] bump

---
 packages/target-ethers-v5/package.json | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/target-ethers-v5/package.json b/packages/target-ethers-v5/package.json
index 9996b150d..7a63fa68b 100644
--- a/packages/target-ethers-v5/package.json
+++ b/packages/target-ethers-v5/package.json
@@ -8,7 +8,7 @@
     "TypeChain",
     "TypeScript"
   ],
-  "version": "0.0.3",
+  "version": "0.0.4",
   "license": "MIT",
   "repository": "https://github.com/ethereum-ts/Typechain",
   "main": "./dist/index.js",

From db8c531b6586273e3320d4b6d811b6d52446e409 Mon Sep 17 00:00:00 2001
From: Braden Napier <brady.napier@dashos.net>
Date: Sun, 2 Aug 2020 13:42:35 -0400
Subject: [PATCH 63/64] merge fork-v5 and run tests

---
 .../target-ethers-v5-test/types/Events.d.ts    | 18 +++++++++---------
 .../target-ethers-v5-test/types/Payable.d.ts   |  6 +++---
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/packages/target-ethers-v5-test/types/Events.d.ts b/packages/target-ethers-v5-test/types/Events.d.ts
index 0300c00db..22b205906 100644
--- a/packages/target-ethers-v5-test/types/Events.d.ts
+++ b/packages/target-ethers-v5-test/types/Events.d.ts
@@ -142,23 +142,23 @@ export class Events extends Contract {
   callStatic: {
     emit_anon1(overrides?: CallOverrides): Promise<void>;
 
-    "emit_anon1()"(overrides?: Overrides): Promise<void>;
+    "emit_anon1()"(overrides?: CallOverrides): Promise<void>;
 
-    emit_event1(overrides?: Overrides): Promise<void>;
+    emit_event1(overrides?: CallOverrides): Promise<void>;
 
-    "emit_event1()"(overrides?: Overrides): Promise<void>;
+    "emit_event1()"(overrides?: CallOverrides): Promise<void>;
 
-    emit_event2(overrides?: Overrides): Promise<void>;
+    emit_event2(overrides?: CallOverrides): Promise<void>;
 
-    "emit_event2()"(overrides?: Overrides): Promise<void>;
+    "emit_event2()"(overrides?: CallOverrides): Promise<void>;
 
-    emit_event3(overrides?: Overrides): Promise<void>;
+    emit_event3(overrides?: CallOverrides): Promise<void>;
 
-    "emit_event3()"(overrides?: Overrides): Promise<void>;
+    "emit_event3()"(overrides?: CallOverrides): Promise<void>;
 
-    emit_event3_overloaded(overrides?: Overrides): Promise<void>;
+    emit_event3_overloaded(overrides?: CallOverrides): Promise<void>;
 
-    "emit_event3_overloaded()"(overrides?: Overrides): Promise<void>;
+    "emit_event3_overloaded()"(overrides?: CallOverrides): Promise<void>;
   };
 
   filters: {
diff --git a/packages/target-ethers-v5-test/types/Payable.d.ts b/packages/target-ethers-v5-test/types/Payable.d.ts
index 14badf14c..72c502847 100644
--- a/packages/target-ethers-v5-test/types/Payable.d.ts
+++ b/packages/target-ethers-v5-test/types/Payable.d.ts
@@ -83,11 +83,11 @@ export class Payable extends Contract {
   callStatic: {
     non_payable_func(overrides?: CallOverrides): Promise<void>;
 
-    "non_payable_func()"(overrides?: Overrides): Promise<void>;
+    "non_payable_func()"(overrides?: CallOverrides): Promise<void>;
 
-    payable_func(overrides?: PayableOverrides): Promise<void>;
+    payable_func(overrides?: CallOverrides): Promise<void>;
 
-    "payable_func()"(overrides?: PayableOverrides): Promise<void>;
+    "payable_func()"(overrides?: CallOverrides): Promise<void>;
   };
 
   filters: {};

From 353868804a5219ca8fd61d7f0497c0bd5bf08cda Mon Sep 17 00:00:00 2001
From: Krzysztof Kaczor <krzkaczor@gmail.com>
Date: Mon, 3 Aug 2020 22:09:08 +0200
Subject: [PATCH 64/64] Add readme note about ethers v5

---
 README.md | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/README.md b/README.md
index 0b6b2ed80..716bd33e6 100644
--- a/README.md
+++ b/README.md
@@ -42,9 +42,10 @@ You will also need to install a desired target for example `@typechain/ethers-v4
 | Package                                                | Version                                                                                                               | Description           | Examples                         |
 | ------------------------------------------------------ | --------------------------------------------------------------------------------------------------------------------- | --------------------- | -------------------------------- |
 | [`typechain`](/packages/typechain)                     | [![npm](https://img.shields.io/npm/v/typechain.svg)](https://www.npmjs.com/package/typechain)                         | Core package          | -                                |
+| [`@typechain/ethers-v5`](/packages/target-ethers-v5)   | [![npm](https://img.shields.io/npm/v/@typechain/ethers-v5.svg)](https://www.npmjs.com/package/@typechain/ethers-v5)   | Ethers ver 5 support  | [example](./examples/ethers-v5)  |
 | [`@typechain/ethers-v4`](/packages/target-ethers-v4)   | [![npm](https://img.shields.io/npm/v/@typechain/ethers-v4.svg)](https://www.npmjs.com/package/@typechain/ethers-v4)   | Ethers ver 4 support  | [example](./examples/ethers-v4)  |
-| [`@typechain/truffle-v4`](/packages/target-truffle-v4) | [![npm](https://img.shields.io/npm/v/@typechain/truffle-v4.svg)](https://www.npmjs.com/package/@typechain/truffle-v4) | Truffle ver 4 support | [example](./examples/truffle-v4) |
 | [`@typechain/truffle-v5`](/packages/target-truffle-v5) | [![npm](https://img.shields.io/npm/v/@typechain/truffle-v5.svg)](https://www.npmjs.com/package/@typechain/truffle-v5) | Truffle ver 5 support | [example](./examples/truffle-v5) |
+| [`@typechain/truffle-v4`](/packages/target-truffle-v4) | [![npm](https://img.shields.io/npm/v/@typechain/truffle-v4.svg)](https://www.npmjs.com/package/@typechain/truffle-v4) | Truffle ver 4 support | [example](./examples/truffle-v4) |
 | [`@typechain/web3-v1`](/packages/target-web3-v1)       | [![npm](https://img.shields.io/npm/v/@typechain/web3-v1.svg)](https://www.npmjs.com/package/@typechain/web3-v1)       | Web3 ver 1 support    | [example](./examples/web3-v1)    |
 
 ## Usage
@@ -101,11 +102,11 @@ That's it! Now, you can simply import typings, check out our examples for more d
 
 ## Targets 🎯
 
-### Ethers.js v4
+### Ethers.js v4 / v5
 
 Use `ethers-v4` target to generate wrappers for [ethers.js](https://github.com/ethers-io/ethers.js/) lib.
 
-### Truffle v4-v5
+### Truffle v4 / v5
 
 Truffle target is great when you use truffle contracts already. Check out
 [truffle-typechain-example](https://github.com/ethereum-ts/truffle-typechain-example) for more details. It require