TypeChain is a tool for generating TypeScript typings for Ethereum smart contracts. It helps developers interact with smart contracts in a type-safe manner, reducing runtime errors and improving the development experience.
Generating TypeScript typings for smart contracts
This command generates TypeScript typings for smart contracts using the Ethers.js target. The generated typings are placed in the 'src/types' directory, and the input JSON files are located in the 'artifacts' directory.
npx typechain --target ethers-v5 --out-dir src/types './artifacts/**/*.json'Using generated typings in a TypeScript project
This code demonstrates how to use the generated TypeScript typings in a TypeScript project. It imports the typings for a contract named 'MyContract', interacts with the contract using Ethers.js, and logs the result of calling a method on the contract.
import { MyContract } from './types/MyContract';
async function main() {
const myContract: MyContract = await ethers.getContractAt('MyContract', '0x123...');
const value = await myContract.myMethod();
console.log(value);
}Ethers.js is a library for interacting with the Ethereum blockchain and its ecosystem. While it does not generate TypeScript typings for smart contracts, it provides a comprehensive set of tools for interacting with Ethereum, including contract interaction, wallet management, and more. TypeChain can generate typings specifically for use with Ethers.js.
Web3.js is a collection of libraries that allow you to interact with a local or remote Ethereum node using HTTP, IPC, or WebSocket. Similar to Ethers.js, it does not generate TypeScript typings for smart contracts but provides a wide range of functionalities for interacting with the Ethereum blockchain. TypeChain can also generate typings for use with Web3.js.
Truffle is a development environment, testing framework, and asset pipeline for Ethereum. It provides a suite of tools for developing smart contracts, including compilation, deployment, and testing. While Truffle does not generate TypeScript typings, it can be used in conjunction with TypeChain to provide a complete development workflow.
🔌 Typescript bindings for Ethereum smartcontracts
npm install --save-dev typechain
yarn add --dev typechain
Note: TypeChain requires web3 in version: 0.20.x.
typechain [--force] [glob]
glob - pattern that will be used to find ABIs, remember about adding quotes: typechain "**/*.json"--force - force overwrite existing files
Interacting with blockchain in Javascript is a pain. Web3 interface is sluggish and when using it with Typescript it gets even worse. Often, you can't be sure what given method call will actually do without looking at ABI file. TypeChain is here to solve these problems (as long as you use Typescript).
TypeChain is code generator - provide ABI file and you will get Typescript class with flexible interface for interacting with blockchain.
In future we plan to leverage something like tsc plugin system to come up with much more elegant solution. You can keep track of Allow "Compiler Plugins" issue.
Install typechain with yarn add --dev typechain.
Run typechain (you might need to make sure that it's available in your path if you installed it
only locally), it will automatically find all .abi files in your project and generate Typescript
classes based on them. You can specify your glob pattern: typechain "**/*.abi.json".
node_modules are always ignored. Use --force to overwrite already existing files. We recommend
git ignoring these generated files and making typechain part of your build process.
That's it! Now, just import contract bindings as any other file import { MyAwesomeContract } from './contracts/MyAwesomeContract' and start interacting with it. We use named exports because of
this.
Let's take a look at typings generated for simple smartcontract:
import { BigNumber } from "bignumber.js";
import {
TypeChainContract,
promisify,
ITxParams,
IPayableTxParams,
DeferredTransactionWrapper
} from "./typechain-runtime";
export class DumbContract extends TypeChainContract {
public readonly rawWeb3Contract: any;
public constructor(web3: any, address: string) {
const abi = [
// ... ABI
];
super(web3, address, abi);
}
static async createAndValidate(web3: any, address: string): Promise<DumbContract> {
const contract = new DumbContract(web3, address);
const code = await promisify(web3.eth.getCode, [address]);
if (code === "0x0") {
throw new Error(`Contract at ${address} doesn't exist!`);
}
return contract;
}
public get counter(): Promise<BigNumber> {
return promisify(this.rawWeb3Contract.counter, []);
}
public get SOME_VALUE(): Promise<boolean> {
return promisify(this.rawWeb3Contract.SOME_VALUE, []);
}
public counterArray(index: BigNumber | number): Promise<BigNumber> {
return promisify(this.rawWeb3Contract.counterArray, [index]);
}
public returnAll(): Promise<[BigNumber, BigNumber]> {
return promisify(this.rawWeb3Contract.returnAll, []);
}
public counterWithOffset(offset: BigNumber | number): Promise<BigNumber> {
return promisify(this.rawWeb3Contract.counterWithOffset, [offset]);
}
public countupForEtherTx(): DeferredTransactionWrapper<IPayableTxParams> {
return new DeferredTransactionWrapper<IPayableTxParams>(this, "countupForEther", []);
}
public countupTx(offset: BigNumber | number): DeferredTransactionWrapper<ITxParams> {
return new DeferredTransactionWrapper<ITxParams>(this, "countup", [offset]);
}
}
Using it can be as simple as:
const dumbContract = await DumbContract.createAndValidate(web3, contractAddress);
console.log(`Current counter value is: ${await dumbContract.counter}`);
console.log("Lets increase it by 2... This results in state change so we need to create tx.");
await dumbContract.countupTx(2).send({ from: accounts[0], gas: GAS_LIMIT_STANDARD });
console.log(`Current counter value is: ${await dumbContract.counter}`);
console.log("We can also get signed tx data: ");
console.log(await dumbContract.countupTx(2).getData());
console.log("When calling payable txs, TypeChain will make sure that you provide ether value:");
await dumbContract
.countupForEtherTx()
.send({ from: accounts[0], gas: GAS_LIMIT_STANDARD, value: 10 });
console.log(`Current counter value is: ${await dumbContract.counter}`);
which gives following output:
Current counter value is: 0
Lets increase it by 2... This results in state change so we need to create tx.
Current counter value is: 2
We can also get signed tx data:
0x7916df080000000000000000000000000000000000000000000000000000000000000002
When calling payable txs, TypeChain will make sure that you provide ether value:
Current counter value is: 12
A: NO — we believe that no generated files should go to git repository. You should git ignore them
and make typechain run automatically for example in post install hook in package.json:
"postinstall":"typechain"
When you update ABI, just regenerate files with TypeChain and Typescript compiler will find any breaking changes for you.
A: You can create your own class that extends generated one and adds additional methods etc.
Currently we discuss various ideas around extendibility including APIs files (adding semantics to ABIs for covering popular cases like working with dates) or using user-defined templates for generated code.
You need to have solc ^0.4.4 installed on your system. Then just do yarn test.
DEBUG=typechain typechain
Original author:
FAQs
🔌 TypeScript bindings for Ethereum smartcontracts
The npm package typechain receives a total of 35,190 weekly downloads. As such, typechain popularity was classified as popular.
We found that typechain demonstrated a not healthy version release cadence and project activity because the last version was released a year ago. It has 2 open source maintainers collaborating on the project.
Did you know?
Socket for GitHub automatically highlights issues in each pull request and monitors the health of all your open source dependencies. Discover the contents of your packages and block harmful activity before you install or update your dependencies.
Security News
Research
A malicious npm package disguised as a WhatsApp client is exploiting authentication flows with a remote kill switch to exfiltrate data and destroy files.
Security News
PyPI now supports digital attestations, enhancing security and trust by allowing package maintainers to verify the authenticity of Python packages.
Security News
GitHub removed 27 malicious pull requests attempting to inject harmful code across multiple open source repositories, in another round of low-effort attacks.