@typechain/ethers-v4 - npm Package Compare versions

Comparing version 1.0.0-beta1 to 1.0.0

dist/codegen/functions.d.ts

@@ -1,3 +0,3 @@
-import { Dictionary } from 'ts-essentials';
 import { FunctionDeclaration } from 'typechain';
-export declare function codegenForFunctions(fns: Dictionary<FunctionDeclaration[]>): string;
+export declare function codegenFunctions(fns: FunctionDeclaration[]): string;
+export declare function codegenForOverloadedFunctions(fns: FunctionDeclaration[]): string;

dist/codegen/functions.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.codegenForFunctions = void 0;
-const lodash_1 = require("lodash");
+exports.codegenForOverloadedFunctions = exports.codegenFunctions = void 0;
 const typechain_1 = require("typechain");
 const types_1 = require("./types");
-function codegenForFunctions(fns) {
-    return lodash_1.values(fns)
-        .map((fns) => {
-        if (fns.length === 1) {
-            return codegenForSingleFunction(fns[0]);
-        }
-        else {
-            return codegenForOverloadedFunctions(fns);
-        }
-    })
-        .join('\n');
+function codegenFunctions(fns) {
+    if (fns.length === 1) {
+        return generateFunction(fns[0]);
+    }
+    return codegenForOverloadedFunctions(fns);
 }
-exports.codegenForFunctions = codegenForFunctions;
+exports.codegenFunctions = codegenFunctions;
 function codegenForOverloadedFunctions(fns) {
-    return fns.map((f) => codegenForSingleFunction(f, `"${typechain_1.getSignatureForFn(f)}"`)).join('\n');
+    return fns.map((fn) => generateFunction(fn, `"${typechain_1.getSignatureForFn(fn)}"`)).join('\n');
 }
-function codegenForSingleFunction(fn, overloadedName) {
+exports.codegenForOverloadedFunctions = codegenForOverloadedFunctions;
+function generateFunction(fn, overloadedName) {
     return `
-  ${overloadedName !== null && overloadedName !== void 0 ? overloadedName : fn.name}(${types_1.codegenInputTypes(fn.inputs)}): ${getTransactionObject(fn)}<${types_1.codegenOutputTypes(fn.outputs)}>;
+  ${generateFunctionDocumentation(fn.documentation)}
+  ${overloadedName !== null && overloadedName !== void 0 ? overloadedName : fn.name}(${types_1.generateInputTypes(fn.inputs)}${!typechain_1.isConstant(fn) && !typechain_1.isConstantFn(fn) ? 'overrides?: TransactionOverrides' : ''}): Promise<${fn.stateMutability === 'pure' || fn.stateMutability === 'view'
+        ? types_1.generateOutputTypes(fn.outputs)
+        : 'ContractTransaction'}>;
 `;
 }
-function getTransactionObject(fn) {
-    return fn.stateMutability === 'payable' ? 'PayableTransactionObject' : 'NonPayableTransactionObject';
+function generateFunctionDocumentation(doc) {
+    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;
 }
 //# sourceMappingURL=functions.js.map

dist/codegen/index.d.ts

@@ -1,2 +0,4 @@
-import { Contract } from 'typechain';
-export declare function codegen(contract: Contract): string;
+import { BytecodeWithLinkReferences, Contract } from 'typechain';
+export declare function codegenContractTypings(contract: Contract): string;
+export declare function codegenContractFactory(contract: Contract, abi: any, bytecode?: BytecodeWithLinkReferences): string;
+export declare function codegenAbstractContractFactory(contract: Contract, abi: any): string;

dist/codegen/index.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.codegen = void 0;
-const events_1 = require("./events");
+exports.codegenAbstractContractFactory = exports.codegenContractFactory = exports.codegenContractTypings = void 0;
+const lodash_1 = require("lodash");
+const types_1 = require("./types");
 const functions_1 = require("./functions");
-function codegen(contract) {
+function codegenContractTypings(contract) {
     const template = `
-  import BN from "bn.js";
-  import { ContractOptions } from "web3-eth-contract";
-  import { EventLog } from "web3-core";
-  import { EventEmitter } from "events";
-  import { Callback, PayableTransactionObject, NonPayableTransactionObject, BlockType, ContractEventLog, BaseContract } from "./types";
+  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 EventOptions {
-    filter?: object;
-    fromBlock?: BlockType;
-    topics?: string[];
+  interface ${contract.name}Interface extends Interface {
+    functions: {
+      ${lodash_1.values(contract.functions)
+        .map((v) => v[0])
+        .map(generateInterfaceFunctionDescription)
+        .join('\n')}
+    };
+
+    events: {
+      ${lodash_1.values(contract.events)
+        .map((v) => v[0])
+        .map(generateInterfaceEventDescription)
+        .join('\n')}
+    };
   }
 
-  ${events_1.codegenForEventsDeclarations(contract.events)}
+  export class ${contract.name} extends Contract {
+    connect(signerOrProvider: Signer | Provider | string): ${contract.name};
+    attach(addressOrName: string): ${contract.name};
+    deployed(): Promise<${contract.name}>;
 
-  export interface ${contract.name} extends BaseContract {
-    constructor(jsonInterface: any[], address?: string, options?: ContractOptions): ${contract.name};
-    clone(): ${contract.name};
-    methods: {
-      ${functions_1.codegenForFunctions(contract.functions)}
+    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: {
+      ${lodash_1.values(contract.functions).map(functions_1.codegenFunctions).join('\n')}
     };
-    events: {
-      ${events_1.codegenForEvents(contract.events)}
-      allEvents(options?: EventOptions, cb?: Callback<EventLog>): EventEmitter;
+
+    ${lodash_1.values(contract.functions).map(functions_1.codegenFunctions).join('\n')}
+
+    filters: {
+      ${lodash_1.values(contract.events)
+        .map((v) => v[0])
+        .map(generateEvents)
+        .join('\n')}
     };
-    ${events_1.codegenForEventsOnceFns(contract.events)}
+
+    estimate: {
+      ${lodash_1.values(contract.functions)
+        .map((v) => v[0])
+        .map(generateEstimateFunction)
+        .join('\n')}
+    };
+  }`;
+    return template;
+}
+exports.codegenContractTypings = codegenContractTypings;
+function codegenContractFactory(contract, abi, bytecode) {
+    const constructorArgs = (contract.constructor && contract.constructor[0] ? types_1.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 = [];
+    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)}
   `;
-    return template;
 }
-exports.codegen = codegen;
+exports.codegenContractFactory = codegenContractFactory;
+function codegenAbstractContractFactory(contract, abi) {
+    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)};
+  `;
+}
+exports.codegenAbstractContractFactory = codegenAbstractContractFactory;
+function generateFactoryConstructor(contract, bytecode) {
+    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, bytecode) {
+    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) {
+    return `
+  ${fn.name}(${types_1.generateInputTypes(fn.inputs)}): Promise<BigNumber>;
+`;
+}
+function generateInterfaceFunctionDescription(fn) {
+    return `
+  ${fn.name}: TypedFunctionDescription<{ encode(${generateParamArrayNames(fn.inputs)}: ${generateParamArrayTypes(fn.inputs)}): string; }>;
+`;
+}
+function generateParamArrayTypes(params) {
+    return `[${params.map((param) => types_1.generateInputType(param.type)).join(', ')}]`;
+}
+function generateParamNames(params) {
+    return params.map((param) => param.name).join(', ');
+}
+function generateParamArrayNames(params) {
+    return `[${generateParamNames(params)}]`;
+}
+function generateEvents(event) {
+    return `
+  ${event.name}(${generateEventTypes(event.inputs)}): EventFilter;
+`;
+}
+function generateInterfaceEventDescription(event) {
+    return `
+  ${event.name}: TypedEventDescription<{ encodeTopics(${generateParamArrayNames(event.inputs)}: ${generateEventTopicTypes(event.inputs)}): string[]; }>;
+`;
+}
+function generateEventTopicTypes(eventArgs) {
+    return `[${eventArgs.map(generateEventArgType).join(', ')}]`;
+}
+function generateEventTypes(eventArgs) {
+    if (eventArgs.length === 0) {
+        return '';
+    }
+    return (eventArgs
+        .map((arg) => {
+        return `${arg.name}: ${generateEventArgType(arg)}`;
+    })
+        .join(', ') + ', ');
+}
+function generateEventArgType(eventArg) {
+    return eventArg.isIndexed ? `${types_1.generateInputType(eventArg.type)} | null` : 'null';
+}
 //# sourceMappingURL=index.js.map

dist/codegen/types.d.ts

 import { EvmType, EvmOutputType, TupleType, AbiParameter, AbiOutputParameter } from 'typechain';
-export declare function codegenInputTypes(input: AbiParameter[]): string;
-export declare function codegenOutputTypes(outputs: AbiOutputParameter[]): string;
-export declare function codegenInputType(evmType: EvmType): string;
-export declare function codegenOutputType(evmType: EvmOutputType): string;
-export declare function codegenTupleType(tuple: TupleType, generator: (evmType: EvmType) => string): string;
+export declare function generateInputTypes(input: Array<AbiParameter>): string;
+export declare function generateOutputTypes(outputs: Array<AbiOutputParameter>): string;
+export declare function generateInputType(evmType: EvmType): string;
+export declare function generateOutputType(evmType: EvmOutputType): string;
+export declare function generateTupleType(tuple: TupleType, generator: (evmType: EvmType) => string): string;
+export declare function generateOutputTupleType(tuple: TupleType): string;

dist/codegen/types.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.codegenTupleType = exports.codegenOutputType = exports.codegenInputType = exports.codegenOutputTypes = exports.codegenInputTypes = void 0;
-function codegenInputTypes(input) {
+exports.generateOutputTupleType = exports.generateTupleType = exports.generateOutputType = exports.generateInputType = exports.generateOutputTypes = exports.generateInputTypes = void 0;
+function generateInputTypes(input) {
     if (input.length === 0) {
         return '';
     }
-    return (input.map((input, index) => `${input.name || `arg${index}`}: ${codegenInputType(input.type)}`).join(', ') + ', ');
+    return (input.map((input, index) => `${input.name || `arg${index}`}: ${generateInputType(input.type)}`).join(', ') + ', ');
 }
-exports.codegenInputTypes = codegenInputTypes;
-function codegenOutputTypes(outputs) {
+exports.generateInputTypes = generateInputTypes;
+function generateOutputTypes(outputs) {
     if (outputs.length === 1) {
-        return codegenOutputType(outputs[0].type);
+        return generateOutputType(outputs[0].type);
     }
     else {
         return `{
-      ${outputs.map((t) => t.name && `${t.name}: ${codegenOutputType(t.type)}, `).join('')}
-      ${outputs.map((t, i) => `${i}: ${codegenOutputType(t.type)}`).join(', ')}
-    }`;
+      ${outputs.map((t) => t.name && `${t.name}: ${generateOutputType(t.type)}, `).join('')}
+      ${outputs.map((t, i) => `${i}: ${generateOutputType(t.type)}`).join(', ')}
+      }`;
     }
 }
-exports.codegenOutputTypes = codegenOutputTypes;
-function codegenInputType(evmType) {
+exports.generateOutputTypes = generateOutputTypes;
+// https://docs.ethers.io/ethers.js/html/api-contract.html#types
+function generateInputType(evmType) {
     switch (evmType.type) {
         case 'integer':
+            return 'BigNumberish';
         case 'uinteger':
-            return 'number | string';
+            return 'BigNumberish';
         case 'address':
@@ -32,5 +34,5 @@ return 'string';
         case 'dynamic-bytes':
-            return 'string | number[]';
+            return 'Arrayish';
         case 'array':
-            return `(${codegenInputType(evmType.itemType)})[]`;
+            return `(${generateInputType(evmType.itemType)})[]`;
         case 'boolean':
@@ -41,12 +43,11 @@ return 'boolean';
         case 'tuple':
-            return codegenTupleType(evmType, codegenInputType);
+            return generateTupleType(evmType, generateInputType);
     }
 }
-exports.codegenInputType = codegenInputType;
-function codegenOutputType(evmType) {
+exports.generateInputType = generateInputType;
+function generateOutputType(evmType) {
     switch (evmType.type) {
         case 'integer':
-            return 'string';
         case 'uinteger':
-            return 'string';
+            return evmType.bits <= 48 ? 'number' : 'BigNumber';
         case 'address':
@@ -60,3 +61,3 @@ return 'string';
         case 'array':
-            return `(${codegenOutputType(evmType.itemType)})[]`;
+            return `(${generateOutputType(evmType.itemType)})[]`;
         case 'boolean':
@@ -67,10 +68,17 @@ return 'boolean';
         case 'tuple':
-            return codegenTupleType(evmType, codegenOutputType);
+            return generateOutputTupleType(evmType);
     }
 }
-exports.codegenOutputType = codegenOutputType;
-function codegenTupleType(tuple, generator) {
-    return '[' + tuple.components.map((component) => generator(component.type)).join(', ') + ']';
+exports.generateOutputType = generateOutputType;
+function generateTupleType(tuple, generator) {
+    return '{' + tuple.components.map((component) => `${component.name}: ${generator(component.type)}`).join(',') + '}';
 }
-exports.codegenTupleType = codegenTupleType;
+exports.generateTupleType = generateTupleType;
+function generateOutputTupleType(tuple) {
+    return ('{' +
+        tuple.components.map((component) => `${component.name}: ${generateOutputType(component.type)} ,`).join('\n') +
+        tuple.components.map((component, index) => `${index}: ${generateOutputType(component.type)}`).join(', ') +
+        '}');
+}
+exports.generateOutputTupleType = generateOutputTupleType;
 //# sourceMappingURL=types.js.map

dist/index.js

@@ -7,3 +7,3 @@ "use strict";
 const typechain_1 = require("typechain");
-const generation_1 = require("./generation");
+const codegen_1 = require("./codegen");
 const DEFAULT_OUT_PATH = './types/ethers-contracts/';
@@ -67,3 +67,3 @@ class Ethers extends ts_generator_1.TsGeneratorPlugin {
             path: path_1.join(this.outDirAbs, `${contract.name}.d.ts`),
-            contents: generation_1.codegenContractTypings(contract),
+            contents: codegen_1.codegenContractTypings(contract),
         };
@@ -74,3 +74,3 @@ }
             path: path_1.join(this.outDirAbs, `${contract.name}Factory.ts`),
-            contents: generation_1.codegenContractFactory(contract, abi, bytecode),
+            contents: codegen_1.codegenContractFactory(contract, abi, bytecode),
         };
@@ -85,3 +85,3 @@ }
                 path: path_1.join(this.outDirAbs, `${contract.name}Factory.ts`),
-                contents: generation_1.codegenAbstractContractFactory(contract, abi),
+                contents: codegen_1.codegenAbstractContractFactory(contract, abi),
             };
@@ -88,0 +88,0 @@ });

package.json

@@ -11,3 +11,3 @@ {
   ],
-  "version": "1.0.0-beta1",
+  "version": "1.0.0",
   "license": "MIT",
@@ -64,5 +64,5 @@ "repository": "https://github.com/ethereum-ts/Typechain",
     "typescript": "3.9.0-beta",
-    "typechain": "2.0.0-beta1",
+    "typechain": "^2.0.0",
     "test-utils": "1.0.0"
   }
 }

New alerts

Major refactor

Supply chain risk

Package has recently undergone a major refactor. It may be unstable or indicate significant internal changes. Use caution when updating to versions that include significant changes.

Found 1 instance in 1 package

Fixed alerts

No v1

Quality

Package is not semver >=1. This means it is not stable and does not support ^ ranges.

Found 1 instance in 1 package

Improved metrics

Number of low quality alerts

1

decreased by-50%

Worsened metrics

Total package byte prevSize

37085

decreased by-25.37%

Number of package files

16

decreased by-36%

Lines of code

467

decreased by-28.81%

Number of medium supply chain risk alerts

1

increased byInfinity%

No dependency changes