KYOTO DEVELOPER DOCUMENTATION
  • 🏗️Build on KYOTO
    • KYOTO Testnet Token
    • Network Details
    • Developer Tools
    • Metamask Wallet
    • Build
      • With Hardhat
      • With Truffle
      • With Remix
      • With thirdweb
    • Transactions
    • Connecting and interacting via Ethers.js
    • How to verify a smart contract?
    • Smart Contract Best Practices
    • KYOTO for Ethereum Developers
Powered by GitBook
On this page
  1. Build on KYOTO

Developer Tools

A guide to available tools, components, patterns, and platforms for developing applications on EVM-compatible chains

PreviousNetwork DetailsNextMetamask Wallet

Last updated 1 year ago

New developers start here
  • - The most popular smart contract language.

  • - Browser extension wallet to interact with Dapps.

  • - Most popular smart contract development, testing, and deployment framework. Install the cli via npm and start here to write your first smart contracts.

  • - Packaged components for the Ethereum ecosystem.

  • - Flexible, extensible and fast Ethereum development environment.

  • - Smart contract development toolchain. Foundry manages your dependencies, compiles your project, runs tests, deploys, and lets you interact with the chain from the command-line.

  • - A Linux image ready to be imported in VirtualBox that includes the development tools mentioned above

  • - Not sure where to start? Use the interactive generator to bootstrap your contract and learn about the components offered in OpenZeppelin Contracts.

  • - Comprehensive crowdsourced overview of Ethereum- its history, governance, future plans and development resources.

  • - Brownie is a Python framework for deploying, testing and interacting with Ethereum smart contracts.

  • - Moralis is a cross-chain Enterprise-grade Web3 API that can be used for efficiently indexing blockchain data, authenticate various web3 wallets, and listen to real-time blockchain events

  • - Post and search questions to help your development life cycle.

  • - Slick blockchain APIs to build world-class applications.

  • - Do gasless transactions in your dapp by enabling meta-transactions using simple to use SDK.

  • — Blockchain events before they happen. Blocknative's portfolio of developers tools make it easy to build with mempool data.

  • — A curated overview of the best and latest resources on Ethereum, blockchain and Web3 development.

  • — An ethereum development client based in Go.

  • — An interactive code school that teaches you to write smart contracts in Solidity.

  • — Learn Solidity and Vyper with challenges.

  • — An introduction to Solidity with simple examples.

  • - Discover Ethereum Layer2 solutions and the risks associated with using them.

Developing Smart Contracts

Test Blockchain Networks
Frontend Ethereum APIs
  • Strictly Typed - Javascript alternatives

Backend Ethereum APIs
Bootstrap/Out-of-Box tools
Ethereum ABI (Application Binary Interface) tools

Patterns & Best Practices

Patterns for Smart Contract Development
    • has solutions for common problems in Ethereum/Solidity, eg.

    • should be consulted before creating own, untested, solutions

    • Likely the most widely-used libraries and smart contracts

    • Similar to Dappsys, more integrated into Truffle framework

    • Upgradeability: Smart contracts can be upgraded to a newer version

    • Permission control: By using the auth and authP modifiers, you can protect functionality so only other apps or entities can access it

    • Forwarders: aragonOS apps can send their intent to perform an action to other apps, so that intent is forwarded if a set of requirements are met

    • Organize contracts so they share the same contract storage and Ethereum address.

    • Solves the 24KB max contract size limit.

    • Upgrade diamonds by adding/replacing/removing any number of functions in a single transaction.

    • Upgrades are transparent by recording them with a standard event.

    • Get information about a diamond with events and/or four standard functions.

Upgradeability

Infrastructure

Ethereum Clients
Storage
Messaging
Testing Tools
Security Tools
Monitoring
Other Miscellaneous Tools

Smart Contract Standards & Libraries

Popular Smart Contract Libraries

-----------------------------------------------------------------------------------------------------

A test network refers to a separate environment that allows developers and users to experiment and test new features, functionalities, and smart contracts without interacting with the main network.

INFO

- Run an Ethereum node (Geth or Parity) for development, as easy as npm i -g ethnode && ethnode.

- App for testing Ethereum blockchain with visual UI and logs

- Use Kaleido for spinning up a consortium blockchain network. Great for PoCs and testing

- Run a private network of Besu nodes in a Docker container

- Component for performing private transactions by PegaSys

- Java implementation of the Ethereum 2.0 Beacon Chain by PegaSys

- Simplifies integration and accepting testing of smart contract applications with docker instances that closely resembles a real blockchain network

- Run a local Raiden network in docker containers for demo and testing purposes

- Out-of-the-box deployment scripts for private PoA networks

- Out-of-the-box deployment scripts for private PoW networks

- Deployment and governance of consortium Ethereum PoA networks

- Build Ethereum network based on Proof of Work

- Ethereum API access to Ethereum networks (Mainnet, Ropsten, Rinkeby, Goerli, Kovan)

- Provides access to the Ethereum network through the Cloudflare instead of running your own node

- Shared and dedicated Ethereum nodes as a service (Mainnet, Ropsten)

- Blockchain Developer Platform, Ethereum API, and Node Service (Mainnet, Ropsten, Rinkeby, Goerli, Kovan)

- JSON-RPC Ethereum API (Mainnet, Rinkeby, Front-running Mainnet)

- Provide simple and reliable API access to Ethereum blockchain

- 100% compatible Ethereum network for cheap and easy development

- Javascript Web3

- Javascript Web3 alternative

- Javascript Web3 alternative, useful utilities and wallet features

- React based framework for rapid DApp development on Ethereum

A high-level reactive JS library optimized for light clients.

- Typescript Web3 alternative

- A collection of utility functions for Ethereum like and

- An easy to use React hooks library for NextJS dapp to index and monitor various blockchain data

- Javascript Web3 wrapper with automatic retries, access to , and robust websocket connections.

and - Modern, zero-configuration, high-level libraries for interacting with smart contracts and making transactions.

- Simple, zero-configuration Ethereum Name Service address resolver.

- A TypeScript port of web3.js. Benefits includes tiny builds and full type safety, including when interacting with contracts.

- Cross-platform Ethereum development framework

- A TypeScript library to use

- Redux library to connect a frontend to a blockchain

- A JavaScript SDK for making native mobile Ethereum dapps using React Native

- a custom React Hook to manage Metamask in Ethereum ĐApp projects

- Open protocol for connecting Wallets to Dapps

- Several useful subproviders to use in conjunction with (including a LedgerSubprovider for adding Ledger hardware wallet support to your dApp)

- ethereum-ready & framework-agnostic redux store configuration.

- Communicate with different blockchains (including Ethereum) using a single interface.

- a Delphi interface to the Ethereum blockchain that allows for development of native dApps for Windows, macOS, iOS, and Android.

- Open-sourced SDK to build dapps with a seamless onboarding UX

- A simple to use SDK to build web3 dApps without extensions or downloads.

- A non-custodial wallet with an SDK that enables easy interaction with DApps without installing anything.

- Create Ethereum-powered front-end apps with one command.

- Beginner friendly forkable github for getting started building smart contracts.

- Deliver real-time notifications to your users. With built-in support for Speed-Ups and Cancels, Blocknative Notify.js helps users transact with confidence. Notify.js is easy to integrate and quick to customize.

- A collection of React hooks and components for Ethereum dApps. Built by Raid Guild.

- RainbowKit is a React library that makes it easy to add wallet connection to your dapp. It's intuitive, responsive and customizable.

- Python Web3

- PHP Web3

- PHP Web3

- Java Web3

- .Net Web3

- Ruby Web3

- Rust Web3

- Haskell Web3

- Kotlin Web3

- NodeJS SDK that integrates with Moralis to index EVM chains

- Python SDK that integrates with Moralis to index EVM chains

- A bridge between Ethereum smart contract events and backend microservices, written in Java by Kauri

- Elixir JSON-RPC client for the Ethereum blockchain

- A gateway that allows you to run multiple Ethereum nodes for redundancy and load-balancing purposes. Can be ran as an alternative to (or on top of) Infura. Written in Golang.

- A set of helper methods to help query ETH smart contracts in Elixir

- Python, JS, and Java SDK for simplifying interactions with Ethereum. Uses relayers to offload transaction costs to relayers.

- provides advanced logging capabilities for Ethereum applications and networks including a query language, query processor, and logging code generation

- Provide simple and reliable API access to Ethereum blockchain

- Fast and modular Golang JSON RPC client with first-class ABI support

- Powerful APIs for accessing human-readable Ethereum data at scale.

- Packaged components for the Ethereum ecosystem

- A full-stack boilerplate to get started building dapp on any EVM chains

- Create Ethereum-powered frontend apps with one command

- Run a private network of Besu nodes in a Docker container

- Pre-configured .NET devchains for fast response (PoA)

- Wasm blockchain explorer (functional sample)

- Run a local Raiden network in docker containers for demo and testing purposes

- Out-of-the-box deployment scripts for private PoA networks

- Step-by-Step tutorial for building a PoA test chain with 2 nodes with Parity authority round consensus

- Out-of-the-box deployment scripts for private PoW networks

- Use Kaleido for spinning up a consortium blockchain network. Great for PoCs and testing

- A local sandbox implementation of the CryptoKitties API and smart contracts, available as a Truffle Box

- aragonCLI is used to create and develop Aragon apps and organizations.

- JavaScript client that provides an API for interacting with the Colony Network smart contracts.

- Library that facilitates javascript application access to the DAOstack Arc ethereum smart contracts.

- JavaScript client that provides an API for interacting with Arkane Network, a wallet provider for building user-friendly dapps.

- Blocknative Onboard is the quick and easy way to add multi-wallet support to your project. With built-in modules for more than 20 unique hardware and software wallets, Onboard saves you time and headaches.

- React framework for building single-page Ethereum dApps

- Free ABI encoder online service that allows you to encode your Solidity contract’s functions and constructor arguments.

- Online Solidity ABI Encoder to encode smart contract arguments, and also perform read and write operations on the blockchain.

- library for decoding data params and events from Ethereum transactions

- Generate Typescript contract wrappers from contract ABI's.

- Auto-generate UI form field definitions and associated validators from an Ethereum contract ABI

- type-safe Contract ABI and Recursive Length Prefix library in Java

- Generate dapps from Truffle artifacts, deploy contracts on public/private networks, offers live customizable public page to interact with contracts.

- Instantly create a dApp at a unique URL using the ABI.

- a development tool that provides a simple HTTP API to find and read from Truffle-generated contract files, for use during local development. Serves fresh contract ABIs over http.

- A MESG Service to interact with any Ethereum contract based on its address and ABI.

- A web based generator which creates a Nethereum based C# Interface and Service based on Solidity Smart Contracts.

- Create shareable contract dashboards and interact with arbitrary EVM-based blockchain functions, with or without an ABI.

- Minimalistic UI tool for interacting with your smart contracts

- Instant access to read from and write to any smart contract directly (on any EVM chain) by simply uploading the ABI. A simple and powerful UX enables rapid execution of smart contract calls locally, on testnets and mainnets. It also comes packed with a host of useful tools for integration testing.

- Debug, test, and grok smart contracts with a visual UI that lets you interact with local or deployed EVM-based smart contracts. Use cases include hot reloading UI for your smart contracts as you code them, easier auditing without writing scripts to hit a function, end-to-end testing your code before deploying it, and more.

- Web IDE allows you to execute methods deployed smart contract and Share with others.

provides building blocks for the or

usage is described in and

- especially section Benefits

- A checklist of common findings, and issues to watch out for when auditing a contract for a mainnet launch.

- an open-source Ethereum client developed under the Apache 2.0 license and written in Java. The project is hosted by Hyperledger.

- Go client

- Rust client, formerly called Parity

- C++ client

- .NET Core client

- A managed service providing Ethereum client standards-compliant APIs

- Python client using

- JS client using

- Seth is an Ethereum client tool—like a "MetaMask for the command line"

- Ethereum Light Client project of Metamask

- Elixir client

- Energy Web Foundation client for the Tobalaba test network

- A permissioned implementation of Ethereum supporting data privacy by

- Ethereum full node implementation written in Elixir.

- A managed service providing elastic and dedicated Geth nodes

- Blockchain developer cloud with API access and node-as-a-service.

- Provide simple and reliable API access to Ethereum blockchain

- Provide access to ETH node (and 48+ more) and Block Explorer. Get free API key to test blockchain-as-a-service solution

- Data and AI managed service, with SQL, API, and Node-as-a-Service.

- Blockchain node service provider, with support for over 60 blockchain protocols.

- Web3 Infrastructure provider with enterprise grade low latency for all. Supports all major EVM chains.

- Decentralised storage and file referencing

- IPFS Storage service with added search capability, formerly IPFS-Store

- Decentralised database on top of IPFS

- A client library for the IPFS HTTP API, implemented in JavaScript

- Upload mutliple files to IPFS easily in any language

- Easy to use API into IPFS and other distributed/decentralised storage protocols

- The Easiest Way to Use IPFS

- Distributed storage platform and content distribution service, a native base layer service of the Ethereum web3 stack

- Decentralized and permanent storage

- Arweave scaling solution with multiple token support

- A managed IPFS API Gateway and pinning service

- An api for user controlled, distributed storage. Built on top of IPFS and Orbitdb.

- an offchain incentivized peer-to-peer cloud project (database, file storage, computing and DID) compatible with Ethereum and IPFS.

- Decentralized Firebase Firestore Alternative.

- Communication protocol for DApps to communicate with each other, a native base layer service of the Ethereum web3 stack

- Peer-to-peer communications between nodes running Ethereum/Whisper

- Python implementation of the RLPx network layer

- API to allow developers to implement IPFS persisted, or in memory peer to peer messaging.

- SNS module for Push Delivery Nodes allows any developer to receive notifications, chats, or any other form of web3 communication directly to the platform they are building with the help of webhooks.

- Zero-Config continuous integration for truffle projects

- Solidity code coverage tool

- Alternative code coverage for Solidity smart-contracts

- Solidity contract function profiler

- Alternative and updated Solidity smart contract profiler

- Speedy, parallelised, hot-reloading solidity test framework

- Tool suite for testing Ethereum applications

- Simplifies integration and accepting testing of smart contract applications with docker instances that closely resembles a real blockchain network

- The hevm project is an implementation of the Ethereum virtual machine (EVM) made specifically for unit testing and debugging smart contracts

- Solidity graphical debugger

- Speed up your development with human readable stack traces

- Solidity linter that provides security, style guide and best practice rules for smart contract validation

- Linter to identify and fix style & security issues in Solidity, formerly Solium

- npm package which parses tx's submitted to a local testrpc node to make them more readable and easier to understand

- An npm package with additional assertions and utilities used in testing Solidity smart contracts with truffle. Most importantly, it adds the ability to assert whether specific events have (not) been emitted.

- Solidity lexical preprocessor with mustache.js-style syntax, macros, conditional compilation and automatic remote dependency inclusion.

- Solidity preprocessor and flattener with a comprehensive directive and expression language, high precision math, and many useful helper functions.

– Decode and publish raw ethereum tx. Similar to

- a library for mocking smart contract dependencies during unit testing.

- A simple lib to test ethereum smart contract that allow to use whatever web3 lib and test runner you choose.

- PyTest plugin for testing smart contracts for Ethereum blockchain.

- Web3-enabled e2e testing tool. A wrapper around Cypress.io with included MetaMask support which allows you to test dapps with ease.

- Security verification platform and tools ecosystem for Ethereum developers

- Open-source EVM bytecode security analysis tool

- Alternative static smart contract security analysis

- Security scanner for Ethereum smart contracts

- Static smart contract security analyzer

- EVM disassembler

- Alternative EVM disassembler

- Framework for cryptoeconomic contract security, decentralised security bounties

- Visualize Solidity control flow for smart contract security analysis

- Symbolic execution tool on Smart Contracts and Binaries

- A Solidity static analysis framework

- The SECBIT static analysis extension to Solidity compiler

- A modular verifier for Solidity smart contracts

- Comprehensive list of known attack vectors and common anti-patterns

- A Collection of Vulnerabilities in ERC20 Smart Contracts With Tokens Affected

- Free smart contract security audits from Callisto Network

- A visual Solidity architecture analyzer

- Web3 Security Scanner Aggregator

- Stream real-time on-chain events to your webhook from multiple EVM blockchains.

- An advanced Ethereum analytics platform that provides live monitoring, insights and anomaly detection, token metrics, smart contract audits, graph visualization and blockchain search. Real-time market information and trading activities across Ethereum's decentralized exchanges can also be explored.

- Provides live monitoring, insights and anomaly detection, token metrics, smart contract audits, graph visualization and blockchain search.

- A tool to monitor a number of smart contracts and transactions

- A live data feed of the activities and event logs of your smart contracts on Ethereum

- A platform that gives users reliable smart contract monitoring and alerting in the form of a web dashboard without requiring users to host or maintain infrastructure

- Explore smart contracts with decoded transaction data, see how the contract is used and search transactions with specific function calls

- A tool for inspecting and analyzing EVM based blockchains. The only full featured blockchain explorer for Ethereum networks.

- A control panel for monitoring dapps. Terminal can be used to monitor your users, dapp, blockchain infrastructure, transactions and more.

- An extensible framework written in Golang for listening to on-chain events and doing something in response.

- Notifications for mined and dropped transactions, gas price changes, and address activity for desired addresses.

— Monitor any contract or wallet address and get streaming mempool events for every lifecycle stage — including drops, confirms, speedups, cancels, and more. Automatically decode confirmed internal transactions. And filter exactly how you want. Receive events in our visual, no-code, interface or associate them with your API key to get events via a webhook. Mempool Explorer helps exchanges, protocols, wallets, and traders monitor and act on transactions in real-time.

- Ethereum block explorer for private chain. Browse transactions, decode function calls, event data or contract variables values on your locally running chain.

- A decentralized monitoring network to detect threats and anomalies on DeFi, NFT, governance, bridges and other Web3 systems in real-time.

- Set up alarms to monitor node status for resource utilization. Incorporate notifications for SMS, Slack, phone calls, and emails.

- An obvservability platform for the decentralized stack. Get the big picture of all your smart contracts at a glance. Browse through logs across chains and across contracts fast. Set Service Level Objectives to see and get notified about anomalies.

- Easy-to-use console app for parsing historical event data without requiring an archive node. Ethereum-datafarm uses the Etherscan API to parse event data from specified contracts and store it in CSV format.

- Debug, test, and grok smart contracts with a visual UI that lets you interact with local or deployed EVM-based smart contracts. Easily monitor and browse local chain transactions, decode function calls, and prepare input payloads so you can test your code.

- a decentralized package manager powered by aragonOS and Ethereum. aragonPM enables decentralized governance over package upgrades, removing centralized points of failure.

- Packaged components for building DApps fast.

- A local sandbox implementation of the CryptoKitties API and smart contracts, available as a Truffle Box

- Solidity compiler

- Project-level Solidity compiler

- Compile solidity-code faster, easier and more reliable

- Combine solidity project to flat file utility. Useful for visualizing imported contracts or for verifying your contract on Etherscan

- Alternative, merges all imports into single file for solidity contracts

- Recursive Length Prefix Encoding in JavaScript

- A collection of CLI tools to help with ethereum learning and development

- Ethereal is a command line tool for managing common tasks in Ethereum

- Cryptographic javascript-functions for Ethereum and tutorials to use them with web3js and solidity

- mobile app allows signing transactions

- Collection of Python tools for the Ethereum ecosystem

- Concats solidity files developed under Truffle with all of their dependencies

- npm package which parses tx's submitted to a local testrpc node to make them more readable and easier to understand

- Typescript bindings for Ethereum smartcontracts

- A Simple Ethereum Address Checksum Tool

- allows indexing blocks or listening to Events in PHP

- JavaScript universal wallet tool for Ethereum-based wallets. Supports software, hardware, and Metamask -- brings all wallets into a consistent and predictable interface for dApp development.

- Connect to MetaMask from node.js

- Documentation generator for Solidity projects

- Export Ethereum blockchain data to CSV or JSON files

- Prettier plugin for formatting Solidity code

- Ethereum and Unity integration demo

- Ethereum and Unity integration demo/sample

- Nethereum business rules engine demo/sample

Unified Modeling Language (UML) class diagram generator for Solidity contracts

- A set of tools to standardize Solidity import and artifact resolution in frameworks.

- A node and browser tool to inspect transactions - decoding where possibe the method, event logs and any revert reasons using ABIs found online.

- A useful library written in Golang to reliably send a transaction — abstracting away some of the tricky low level details such as gas optimization, nonce calculations, synchronization, and retries.

- Seamlessly verify contract source code on Etherscan from the Truffle command line.

— Gas estimation for builders, by builders. Gas Platform harnesses Blocknative's real-time mempool data infrastructure to accurately and consistently estimate Ethereum transaction fees. This provides builders and traders with an up-to-the-moment gas fee API.

- A gas price watcher with email notifications on price change

- Ease unit calculations & utility tools. PWA , so you can install it on your mac/windows/linux or android/iphone

- A platform aggregating all smart contract libraries

- Online tool to convert the different Ethereum denominations (wei, gwei, ether).

- Online tool to convert Solidity Bytes32 into strings, or numbers and vice versa.

- The Ethereum Request for Comment repository
  • Tokens

- Contains tested reusable smart contracts like SafeMath and OpenZeppelin SDK for smart contract upgradeability

- A collection of Solidity libraries for building secure and gas-efficient smart contracts on Ethereum.

- A group of packages built for use on blockchains utilizing the Ethereum Virtual Machine

- A gas-efficient Solidity date and time library

- DAO protocol. Contains with focus on upgradeability and governance

- an operating system for DAOs and the base layer of the DAO stack.

- DEX protocol

- Contains correctness proofs of token contracts wrt. given specifications and high-level properties

- Provides contracts for using the Provable service, allowing for off-chain actions, data-fetching, and computation

- Fixed-point (64.64 bit) and IEEE-754 compliant quad precision (128 bit) floating-point math libraries for Solidity

- A platform aggregating all smart contract libraries

Inspired by:

- Original token contract for fungible assets

- Token standard for non-fungible assets

- An improved token standard for fungible assets

- Mineable Token Standard

- Creates a standard method to publish and detect what interfaces a smart contract implements.

- Proxy contract for key management and execution, to establish a Blockchain identity.

- A standard interface for ownership of contracts

🏗️
ethnode
Ganache
Kaleido
Besu Private Network
Orion
Artemis
Cliquebait
Local Raiden
Private networks deployment scripts
Local Ethereum Network
Ethereum on Azure
Ethereum on Google Cloud
Infura
CloudFlare Distributed Web Gateway
Chainstack
Alchemy
ZMOK
Watchdata
cheapETH
Web3.js
Eth.js
Ethers.js
useDApp
light.js
Web3Wrapper
Ethereumjs
ethereumjs-util
ethereumjs-tx
Moralis NextJS SDK
Alchemy-web3.js
Alchemy's enhanced APIs
flex-contract
flex-ether
ez-ens
web3x
Nethereum
dfuse
dfuse Ethereum API
Drizzle
Tasit SDK
useMetamask
WalletConnect
Subproviders
Web3-provider-engine
ethvtx
docs
elm-ethereum
purescript-web3
ChainAbstractionLayer
Delphereum
Torus
Fortmatic
Portis
create-eth-app
Scaffold-ETH
Notify.js
Quiver
Rainbow
Web3.py
Web3.php
Ethereum-php
Web3j
Nethereum
Ethereum.rb
rust-web3
Web3.hs
KEthereum
Moralis NodeJS SDK
Moralis Python SDK
Eventeum
Ethereumex
Ethereum-jsonrpc-gateway
EthContract
Marmo
Ethereum Logging Framework
Watchdata
w3
Transpose
Truffle boxes
Ethereum Boilerplates
Create Eth App
Besu Private Network
Testchains
Blazor/Blockchain Explorer
Local Raiden
Private networks deployment scripts
Parity Demo-PoA Tutorial
Local Ethereum Network
Kaleido
Cheshire
aragonCLI
ColonyJS
ArcJS
Arkane Connect
Onboard.js
web3-react
Online ABI encoder
Online Solidity ABI Encoder
ABI decoder
ABI-gen
Ethereum ABI UI
headlong
EasyDapper
One Click dApp
Truffle Pig
Ethereum Contract Service
Nethereum-CodeGenerator
EVMConnector
contract-admin
Smart Contract GUI
Sidekik
Web3 Client
Dappsys: Safe, simple, and flexible Ethereum contract building blocks
Whitelisting
Upgradable ERC20-Token
ERC20-Token-Vault
Authentication (RBAC)
...several more...
MakerDAO
The TAO
Dapp-a-day 1-10
Dapp-a-day 11-25
OpenZeppelin Contracts: An open framework of reusable and secure smart contracts in the Solidity language.
Blog about Best Practices with Security Audits
Advanced Workshop with Assembly
Simpler Ethereum Multisig
CryptoFin Solidity Auditing Checklist
aragonOS: A smart contract framework for building DAOs, Dapps and protocols
EIP-2535 Diamond Standard
Clean Contracts - A guide to writing clean code
Blog von Elena Dimitrova, Dev at colony.io
https://blog.colony.io/writing-more-robust-smart-contracts-99ad0a11e948
https://blog.colony.io/writing-upgradeable-contracts-in-solidity-6743f0eecc88
Aragon research blog
Library driven development
Advanced Solidity code deployment techniques
OpenZeppelin on Proxy Libraries
Besu
Geth
OpenEthereum
Aleth
Nethermind
Infura
Trinity
py-evm
Ethereumjs
ethereumjs-vm
Seth
Mustekala
Exthereum
EWF Parity
Quorum
JP Morgan
Mana
Chainstack
QuickNode
Watchdata
NOWNodes
Spice
InfStones
Chainnodes
IPFS
Mahuta
OrbitDB
JS IPFS API
Moralis IPFS API
TEMPORAL
PINATA
Swarm
Arweave
Bundlr
Infura
3Box Storage
Aleph.im
DB3 Network
Whisper
DEVp2p Wire Protocol
Pydevp2p
3Box Threads
EPNS SNS Notifications
Truffle Teams
Solidity code coverage
Solidity coverage
Solidity function profiler
Sol-profiler
Espresso
Eth tester
Cliquebait
Hevm
Ethereum graph debugger
Tenderly CLI
Solhint
Ethlint
Decode
truffle-assertions
Psol
solpp
Decode and Publish
https://live.blockcypher.com/btc-testnet/decodetx/
Doppelgänger
rocketh
pytest-cobra
Synpress
MythX
Mythril
Oyente
Securify
SmartCheck
Ethersplay
Evmdis
Hydra
Solgraph
Manticore
Slither
Adelaide
solc-verify
Solidity security blog
Awesome Buggy ERC20 Tokens
Free Smart Contract Security Audit
Piet
Smack My Contract
Moralis Streams API
Alethio
amberdata.io
Neufund - Smart Contract Watch
Scout
Tenderly
Chainlyt
BlockScout
Terminal
Ethereum-watcher
Alchemy Notify
Blocknatve Mempool Explorer
Ethernal
Forta
InfStones BlockWatch
Blocktorch
Ethereum-datafarm
Sidekik
aragonPM
Truffle boxes
Cheshire
Solc
Sol-compiler
Solidity cli
Solidity flattener
Sol-merger
RLP
eth-cli
Ethereal
Eth crypto
Parity Signer
py-eth
truffle-flattener
Decode
TypeChain
EthSum
PHP based Blockchain indexer
Purser
Node-Metamask
Solidity-docgen
Ethereum ETL
prettier-plugin-solidity
Unity3dSimpleSample
Flappy
Wonka
Sol2UML
Resolver-Engine
eth-reveal
Ethereum-tx-sender
truffle-plugin-verify
Blocknative Gas Platform
ETH Gas.watch
Diverse Eth Calculator
Cookbook
Ethereum Unit Converter
Solidity Bytes32 Converter
ERCs
ERC-20
ERC-721
ERC-777
ERC-918
ERC-165
ERC-725
ERC-173
Zeppelin
library
cryptofin-solidity
Modular Libraries
DateTime Library
Aragon
aragonOS smart contract framework
ARC
0x
Token Libraries with Proofs
Provable API
ABDK Libraries for Solidity
Cookbook
https://github.com/ConsenSys/ethereum-developer-tools-list
Solidity
Metamask
Truffle
Truffle boxes
Hardhat
Foundry
Cryptotux
OpenZeppelin Wizards
EthHub.io
Brownie
Moralis
Ethereum Stack Exchange
dfuse
Biconomy
Blocknative
useWeb3.xyz
Geth
CryptoZombies
Smartcontract challenges
Solidity by Example
L2Beat