diff --git a/docs/developer/contractkit/usage.md b/docs/developer/contractkit/usage.md
index 9a6fce6ac0..f3d10d51eb 100644
--- a/docs/developer/contractkit/usage.md
+++ b/docs/developer/contractkit/usage.md
@@ -87,7 +87,7 @@ const receipt = await tx.waitReceipt();
 
 ## Interacting with Custom contracts
 
-You can use ContractKit to interact with any deployed smart contract, provided you have the contract address and the [ABI](https://docs.soliditylang.org/en/latest/abi-spec.html). To do so, you will initialize a new `web3` Contract instance. Then you can call functions on the contract instance to read state or send transactions to update the contract. You can see some code snippets below. For a more comprehensive example, see the [Interacting with Custom Contracts](/developer/walkthrough/hello-contract-remote-node#interacting-with-custom-contracts) section of the Deploy a Contract code example.
+You can use ContractKit to interact with any deployed smart contract, provided you have the contract address and the [ABI](https://docs.soliditylang.org/en/latest/abi-spec.html). To do so, you will initialize a new `web3` Contract instance. Then you can call functions on the contract instance to read state or send transactions to update the contract. You can see some code snippets below.
 
 ```ts
 let cUSDcontract = await kit.contracts.getStableToken();
diff --git a/docs/developer/evm-tools.md b/docs/developer/evm-tools.md
index 0c166ea492..0abead572d 100644
--- a/docs/developer/evm-tools.md
+++ b/docs/developer/evm-tools.md
@@ -14,11 +14,9 @@ A guide to available tools, components, patterns, and platforms for developing a
 - [Solidity](https://soliditylang.org/) - The most popular smart contract language.
 - [Metamask](https://metamask.io/) - Browser extension wallet to interact with Dapps.
 - [thirdweb](https://thirdweb.com) - SDKs in every language, smart contracts, tools, and infrastructure for web3 development.
-- [Truffle](https://trufflesuite.com/) - Most popular smart contract development, testing, and deployment framework. Install the cli via npm and start here to write your first smart contracts.
-- [Truffle boxes](https://trufflesuite.com/boxes) - Packaged components for the Ethereum ecosystem.
 - [Hardhat](https://hardhat.org/) - Flexible, extensible and fast Ethereum development environment.
 - [Cryptotux](https://cryptotux.org/) - A Linux image ready to be imported in VirtualBox that includes the development tools mentionned above
-- [OpenZeppelin Starter Kits](https://openzeppelin.com/starter-kits/) - An all-in-one starter box for developers to jumpstart their smart contract backed applications. Includes Truffle, OpenZeppelin SDK, the OpenZeppelin/contracts-ethereum-package EVM package of audited smart contract, a react-app and rimble for easy styling.
+- [OpenZeppelin Starter Kits](https://openzeppelin.com/starter-kits/) - An all-in-one starter box for developers to jumpstart their smart contract backed applications. Includes OpenZeppelin SDK, the OpenZeppelin/contracts-ethereum-package EVM package of audited smart contract, a react-app and rimble for easy styling.
 - [EthHub.io](https://docs.ethhub.io/) - Comprehensive crowdsourced overview of Ethereum- its history, governance, future plans and development resources.
 - [EthereumDev.io](https://ethereumdev.io) - The definitive guide for getting started with Ethereum smart contract programming.
 - [Brownie](https://github.com/iamdefinitelyahuman/brownie) - Brownie is a Python framework for deploying, testing and interacting with Ethereum smart contracts.
@@ -38,11 +36,9 @@ A guide to available tools, components, patterns, and platforms for developing a
 ### Frameworks
 
 - [thirdweb](https://portal.thirdweb.com/solidity) - Provides the tools needed to build custom smart contracts efficiently by offering a set of prebuilt base contracts and a set of reusable components, or extensions, that can be integrated into your own smart contracts.
-- [Truffle](https://trufflesuite.com/) - Most popular smart contract development, testing, and deployment framework. The Truffle suite includes Truffle, [Ganache](https://github.com/trufflesuite/ganache), and [Drizzle](https://github.com/truffle-box/drizzle-box). [Deep dive on Truffle here](https://media.consensys.net/truffle-deep-dive-what-you-need-to-know-when-developing-on-ethereum-e548d4df6e9)
 - [Hardhat](https://hardhat.org/) - Flexible, extensible and fast Ethereum development environment.
 - [Brownie](https://github.com/iamdefinitelyahuman/brownie) - Brownie is a Python framework for deploying, testing and interacting with Ethereum smart contracts.
 - [Embark](https://github.com/embark-framework/embark) - Framework for DApp development
-- [Waffle](https://getwaffle.io/) - Framework for advanced smart contract development and testing, small, flexible, fast (based on ethers.js)
 - [Dapp](https://dapp.tools/dapp/) - Framework for DApp development, successor to DApple
 - [Etherlime](https://github.com/LimeChain/etherlime) - ethers.js based framework for Dapp deployment
 - [Parasol](https://github.com/Lamarkaz/parasol) - Agile smart contract development environment with testing, INFURA deployment, automatic contract documentation and more. It features a flexible and unopinionated design with unlimited customizability
@@ -72,7 +68,6 @@ A guide to available tools, components, patterns, and platforms for developing a
 ## Test Blockchain Networks
 
 - [ethnode](https://github.com/vrde/ethnode) - Run an Ethereum node (Geth or Parity) for development, as easy as `npm i -g ethnode && ethnode`.
-- [Ganache](https://github.com/trufflesuite/ganache) - App for test Ethereum blockchain with visual UI and logs
 - [Kaleido](https://kaleido.io/) - Use Kaleido for spinning up a consortium blockchain network. Great for PoCs and testing
 - [Besu Private Network](https://besu.hyperledger.org/en/stable/Tutorials/Quickstarts/Azure-Private-Network-Quickstart/) - Run a private network of Besu nodes in a Docker container
   **[Orion](https://github.com/PegaSysEng/orion) - Component for performing private transactions by PegaSys
@@ -122,7 +117,6 @@ A guide to available tools, components, patterns, and platforms for developing a
 - [web3x](https://github.com/xf00f/web3x) - A TypeScript port of web3.js. Benefits includes tiny builds and full type safety, including when interacting with contracts.
 - [Nethereum](https://github.com/Nethereum/) - Cross-platform Ethereum development framework
 - [dfuse](https://github.com/dfuse-io/client-js) - A TypeScript library to use [dfuse Ethereum API](https://dfuse.io)
-- [Drizzle](https://github.com/truffle-box/drizzle-box) - Redux library to connect a frontend to a blockchain
 - [Tasit SDK](https://github.com/tasitlabs/tasitsdk) - A JavaScript SDK for making native mobile Ethereum dapps using React Native
 - [useMetamask](https://github.com/mdtanrikulu/use-metamask) - a custom React Hook to manage Metamask in Ethereum ĐApp projects
 - [WalletConnect](https://walletconnect.org/) - Open protocol for connecting Wallets to Dapps
@@ -163,7 +157,6 @@ A guide to available tools, components, patterns, and platforms for developing a
 
 ### Bootstrap/Out-of-Box tools
 
-- [Truffle boxes](https://trufflesuite.com/boxes) - Packaged components for the Ethereum ecosystem
 - [Create Eth App](https://github.com/paulrberg/create-eth-app) - Create Ethereum-powered frontend apps with one command
 - [Besu Private Network](https://besu.hyperledger.org/en/stable/Tutorials/Quickstarts/Azure-Private-Network-Quickstart/) - Run a private network of Besu nodes in a Docker container
 - [Testchains](https://github.com/Nethereum/TestChains) - Pre-configured .NET devchains for fast response (PoA)
@@ -173,7 +166,6 @@ A guide to available tools, components, patterns, and platforms for developing a
 - [Parity Demo-PoA Tutorial](https://wiki.parity.io/Demo-PoA-tutorial.html) - Step-by-Step tutorial for building a PoA test chain with 2 nodes with Parity authority round consensus
 - [Local Ethereum Network](https://github.com/ConsenSys/local_ethereum_network) - Out-of-the-box deployment scripts for private PoW networks
 - [Kaleido](https://kaleido.io/) - Use Kaleido for spinning up a consortium blockchain network. Great for PoCs and testing
-- [Cheshire](https://github.com/endless-nameless-inc/cheshire) - A local sandbox implementation of the CryptoKitties API and smart contracts, available as a Truffle Box
 - [aragonCLI](https://github.com/aragon/aragon-cli) - aragonCLI is used to create and develop Aragon apps and organizations.
 - [ColonyJS](https://github.com/JoinColony/colonyJS) - JavaScript client that provides an API for interacting with the Colony Network smart contracts.
 - [ArcJS](https://github.com/daostack/arc.js) - Library that facilitates javascript application access to the DAOstack Arc ethereum smart contracts.
@@ -188,9 +180,7 @@ A guide to available tools, components, patterns, and platforms for developing a
 - [ABI-gen](https://github.com/0xProject/0x-monorepo/tree/development/packages/abi-gen) - Generate Typescript contract wrappers from contract ABI's.
 - [Ethereum ABI UI](https://github.com/hiddentao/ethereum-abi-ui) - Auto-generate UI form field definitions and associated validators from an Ethereum contract ABI
 - [headlong](https://github.com/esaulpaugh/headlong/) - type-safe Contract ABI and Recursive Length Prefix library in Java
-- [EasyDapper](https://www.easydapper.com) - Generate dapps from Truffle artifacts, deploy contracts on public/private networks, offers live customizable public page to interact with contracts.
 - [One Click dApp](https://oneclickdapp.com) - Instantly create a dApp at a unique URL using the ABI.
-- [Truffle Pig](https://npmjs.com/package/trufflepig) - 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.
 - [Ethereum Contract Service](https://github.com/mesg-foundation/service-ethereum-contract) - A MESG Service to interact with any Ethereum contract based on its address and ABI.
 - [Nethereum-CodeGenerator](https://github.com/StefH/Nethereum-CodeGenerator) - A web based generator which creates a Nethereum based C# Interface and Service based on Solidity Smart Contracts.
 - [EVMConnector](https://evmconnector.dev) - Create shareable contract dashboards and interact with arbitrary EVM-based blockchain functions, with or without an ABI.
@@ -211,7 +201,6 @@ A guide to available tools, components, patterns, and platforms for developing a
   - usage is described in [Dapp-a-day 1-10](https://steemit.com/@nikolai) and [Dapp-a-day 11-25](https://steemit.com/@nexusdev)
 - [OpenZeppelin Contracts: An open framework of reusable and secure smart contracts in the Solidity language.](https://github.com/OpenZeppelin/openzeppelin-contracts)
   - Likely the most widely-used libraries and smart contracts
-  - Similar to Dappsys, more integrated into Truffle framework
   - [Blog about Best Practices with Security Audits](https://blog.openzeppelin.com/)
 - [Advanced Workshop with Assembly](https://github.com/androlo/solidity-workshop)
 - [Simpler Ethereum Multisig](https://medium.com/@ChrisLundkvist/exploring-simpler-ethereum-multisig-contracts-b71020c19037) - especially section _Benefits_
@@ -282,7 +271,6 @@ A guide to available tools, components, patterns, and platforms for developing a
 
 ## Testing Tools
 
-- [Truffle Teams](https://trufflesuite.com/teams) - Zero-Config continuous integration for truffle projects
 - [Solidity code coverage](https://github.com/0xProject/0x-monorepo/tree/development/packages/sol-coverage) - Solidity code coverage tool
 - [Solidity coverage](https://github.com/sc-forks/solidity-coverage) - Alternative code coverage for Solidity smart-contracts
 - [Solidity function profiler](https://github.com/EricR/sol-function-profiler) - Solidity contract function profiler
@@ -296,7 +284,6 @@ A guide to available tools, components, patterns, and platforms for developing a
 - [Solhint](https://github.com/protofire/solhint) - Solidity linter that provides security, style guide and best practice rules for smart contract validation
 - [Ethlint](https://github.com/duaraghav8/Ethlint) - Linter to identify and fix style & security issues in Solidity, formerly Solium
 - [Decode](https://github.com/hacker-DOM/decode) - npm package which parses tx's submitted to a local testrpc node to make them more readable and easier to understand
-- [truffle-assertions](https://github.com/rkalis/truffle-assertions) - 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.
 - [Psol](https://github.com/Lamarkaz/psol) - Solidity lexical preprocessor with mustache.js-style syntax, macros, conditional compilation and automatic remote dependency inclusion.
 - [solpp](https://github.com/merklejerk/solpp) - Solidity preprocessor and flattener with a comprehensive directive and expression language, high precision math, and many useful helper functions.
 - [Decode and Publish](https://flightwallet.github.io/decode-eth-tx/) – Decode and publish raw ethereum tx. Similar to https://live.blockcypher.com/btc-testnet/decodetx/
@@ -342,8 +329,6 @@ A guide to available tools, components, patterns, and platforms for developing a
 ## Other Miscellaneous Tools
 
 - [aragonPM](https://hack.aragon.org/docs/apm-intro.html) - a decentralized package manager powered by aragonOS and Ethereum. aragonPM enables decentralized governance over package upgrades, removing centralized points of failure.
-- [Truffle boxes](https://www.trufflesuite.com/boxes) - Packaged components for building DApps fast.
-  - [Cheshire](https://github.com/endless-nameless-inc/cheshire) - A local sandbox implementation of the CryptoKitties API and smart contracts, available as a Truffle Box
 - [Solc](https://docs.soliditylang.org/en/latest/using-the-compiler.html) - Solidity compiler
 - [Sol-compiler](https://sol-compiler.com/) - Project-level Solidity compiler
 - [Solidity cli](https://github.com/pubkey/solidity-cli) - Compile solidity-code faster, easier and more reliable
@@ -355,7 +340,6 @@ A guide to available tools, components, patterns, and platforms for developing a
 - [Eth crypto](https://github.com/pubkey/eth-crypto) - Cryptographic javascript-functions for Ethereum and tutorials to use them with web3js and solidity
 - [Parity Signer](https://github.com/paritytech/parity-signer) - mobile app allows signing transactions
 - [py-eth](http://py-eth.com) - Collection of Python tools for the Ethereum ecosystem
-- [truffle-flattener](https://github.com/nomiclabs/truffle-flattener) - Concats solidity files developed under Truffle with all of their dependencies
 - [Decode](https://github.com/hacker-DOM/decode) - npm package which parses tx's submitted to a local testrpc node to make them more readable and easier to understand
 - [TypeChain](https://github.com/ethereum-ts/TypeChain) - Typescript bindings for Ethereum smartcontracts
 - [EthSum](https://ethsum.netlify.com) - A Simple Ethereum Address Checksum Tool
@@ -371,7 +355,6 @@ A guide to available tools, components, patterns, and platforms for developing a
 - [Resolver-Engine](https://github.com/Crypto-Punkers/resolver-engine) - A set of tools to standarize Solidity import and artifact resolution in frameworks.
 - [eth-reveal](https://github.com/justinjmoses/eth-reveal) - A node and browser tool to inspect transactions - decoding where possible the method, event logs and any revert reasons using ABIs found online.
 - [Ethereum-tx-sender](https://github.com/HydroProtocol/ethereum-tx-sender) - 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.
-- [truffle-plugin-verify](https://github.com/rkalis/truffle-plugin-verify) - Seamlessly verify contract source code on Etherscan from the Truffle command line.
 - [Blocknative Gas Platform](https://www.blocknative.com/gas) — 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.
 - [ETH Gas.watch](https://ethgas.watch/) - A gas price watcher with email notifications on price change
 
diff --git a/docs/developer/migrate/from-ethereum.md b/docs/developer/migrate/from-ethereum.md
index 158e9f5ee1..9ac5cab156 100644
--- a/docs/developer/migrate/from-ethereum.md
+++ b/docs/developer/migrate/from-ethereum.md
@@ -22,7 +22,7 @@ While the Celo client originated as a fork of Ethereum Go language client, [go-e
 
 In terms of programmability, Celo is similar to Ethereum. Both networks run the Ethereum Virtual Machine (EVM) to support smart contract functionality.
 This means that all programming languages, developer tooling and standards that target the EVM are relevant for both Celo and Ethereum.
-Developers building on Celo can write smart contracts in [Solidity](https://solidity.readthedocs.io/en/latest/), use [Truffle](https://www.trufflesuite.com/) for smart contract management and
+Developers building on Celo can write smart contracts in [Solidity](https://solidity.readthedocs.io/en/latest/), and
 take advantage of smart contract standards that have already been developed for Ethereum.
 
 ## The ERC-20 Token Standard
@@ -97,7 +97,7 @@ You can [view the implementation here.](https://explorer.celo.org/address/0xaa93
 
 ## Deploying Ethereum Contracts to Celo
 
-Celo runs the EVM which means that smart contracts written for Ethereum can easily be deployed to Celo, the main difference being that you just need to connect to a Celo node instead of an Ethereum node. You can connect to your own Celo node or to a Celo node service provider like [Figment Datahub](https://figment.io/datahub/celo/).
+Celo runs the EVM which means that smart contracts written for Ethereum can easily be deployed to Celo, the main difference being that you just need to connect to a Celo node instead of an Ethereum node. You can connect to your own Celo node or to a Celo node service provider like [Quicknode](https://www.quicknode.com/chains/celo).
 
 ## Protocol Differences
 
diff --git a/docs/developer/tools.md b/docs/developer/tools.md
index 85d760072c..9f482fa7c9 100644
--- a/docs/developer/tools.md
+++ b/docs/developer/tools.md
@@ -130,11 +130,6 @@ Featuring open access to a Public RPC API layer, Ankr Protocol provides reliable
 
 <PageRef url="https://www.ankr.com/rpc/celo/" pageName="Ankr" />
 
-### Figment Datahub
-
-[Figment datahub](https://figment.io/datahub/celo/) is a service similar to Forno. They have some additional features that allow you to track how people are using your application in terms of the type and number of requests coming through the endpoints. They have a free tier with the option to pay for the service to increase limits to support more popular projects.
-
-<PageRef url="https://figment.io/datahub/celo/" pageName="Figment Datahub" />
 
 ### Quicknode
 
diff --git a/docs/developer/verify/remix.md b/docs/developer/verify/remix.md
index 8b523fed65..4134b9d672 100644
--- a/docs/developer/verify/remix.md
+++ b/docs/developer/verify/remix.md
@@ -13,7 +13,7 @@ description: How to verify a Smart Contract on Celo using Remix
 
 :::tip
 
-The source code of the contract that you are verifying will need to be in Remix. Contracts deployed with Truffle, Hardhat, and other tools can also be verified using the Remix Sourcify plugin, but you will need to copy your contract source code into Remix first.
+The source code of the contract that you are verifying will need to be in Remix. Contracts deployed with Hardhat, and other tools can also be verified using the Remix Sourcify plugin, but you will need to copy your contract source code into Remix first.
 
 :::
 
diff --git a/docs/developer/walkthrough/hello-contract-remote-node.md b/docs/developer/walkthrough/hello-contract-remote-node.md
deleted file mode 100644
index d8445fab7a..0000000000
--- a/docs/developer/walkthrough/hello-contract-remote-node.md
+++ /dev/null
@@ -1,320 +0,0 @@
----
-title: Deploy and Interact with Contracts (Remotely)
-description: How to deploy and interact your own smart contracts using a remote node.
----
-
-import PageRef from '@components/PageRef'
-
-# Hello Contract \(Truffle + Remote Node\)
-
-How to deploy and interact your own smart contracts using a remote node.
-
----
-
-:::tip
-
-As Celo is fully EVM compatible, we inherit the rich developer ecosystem and tooling of the Ethereum community. You will be deploying a typical hello world smart contract onto the Alfajores testnet with the common Ethereum tool, Truffle.
-
-:::
-
-:::note
-
-This page is similar to the Hello Contracts page, but this one will connect to a remote node (Forno) and do key management in the Truffle project.
-
-:::
-
-## Setup
-
-This guide assumes that you have a basic Node/[NPM](https://www.npmjs.com/get-npm) setup.
-
-:::info
-
-[Learn more about the Truffle development framework here.](https://www.trufflesuite.com/docs/truffle/overview)
-
-:::
-
-As you may know, Truffle is built for Ethereum developers. Because Celo has a similar network architecture and runs the Ethereum Virtual Machine, Celo developers are able to leverage many Ethereum developer tools. But it is important to keep in mind the differences. If you haven't already, please review the Celo overview.
-
-<PageRef url="/general" pageName="Celo Overview"/>
-
-[Clone this Truffle project from GitHub to get started](https://github.com/critesjosh/hello_contract-truffle).
-
-```
-git clone https://github.com/critesjosh/hello_contract-truffle.git
-```
-
-This is a basic truffle project, with some additional files to help us with account management and deploying to a remote Celo test net node. Run `npm install` to install of the project dependencies.
-
-## Hello World!
-
-Add a contract with the command
-
-```text
-truffle create contract HelloWorld
-```
-
-We will not go into the details of how to write Solidity in this exercise, but you can learn more at the [Solidity documentation page](https://solidity.readthedocs.io/en/latest/).
-
-The contract will just store a name for now:
-
-```solidity title="contracts/HelloWorld.sol"
-
-pragma solidity >=0.5.0 <0.8.0;
-
-contract HelloWorld {
-  string name = 'Celo';
-
-  function getName() public view returns (string memory) {
-    return name;
-  }
-
-  function setName(string calldata newName) external {
-    name = newName;
-  }
-}
-```
-
-## Prepare Deployment
-
-### Compile the contract
-
-Before you deploy the contract, you need to compile the Solidity code into Ethereum bytecode. The following truffle command will look in the `./contracts` directory and compile any new or updated Solidity (`.sol`) contracts.
-
-```
-truffle compile
-```
-
-After compiling the contract, you need to create a migration to deploy the contract. For that, create a file in the `./migrations/` folder named `2_deploy_helloworld.js`:
-
-:::info
-
-[Learn more about Truffle migrations here.](https://www.trufflesuite.com/docs/truffle/getting-started/running-migrations)
-
-:::
-
-```javascript title="migrations/2_deploy_helloworld.js"
-var HelloWorld = artifacts.require("HelloWorld");
-
-module.exports = function (deployer) {
-  deployer.deploy(HelloWorld);
-};
-```
-
-:::info
-
-You can [learn more about Truffle configuration options here.](https://www.trufflesuite.com/docs/truffle/reference/configuration)
-
-:::
-
-## Deploy to Alfajores \(Remotely\)
-
-When you deploy contracts to the Celo network with a remote node, you have to sign the contract deployment transaction locally before sending it to the remote node to be broadcast to the network. This presents some unique challenges when using Ethereum development tools \(like Truffle\) because Celo transaction objects are slightly different than Ethereum transaction objects.
-
-When you are ready to deploy your contract to Alfajores, you'll need a Celo client connected to the testnet. In this exercise you will connect to a remote node to read and write to the public testnet (Alfajores), but you could also run a testnet node locally to perform the same actions.
-
-Here are the steps to go through to deploy the contract to the Alfajores testnet.
-
-1. Connect to Forno \(a remote Celo node service provider\)
-2. Get personal account information \(generate a private key if required, stored in `./.env`\)
-3. Get your personal account address and fund it via the [faucet](https://faucet.celo.org)
-4. Get the compiled contract bytecode
-5. Create and sign the contract deployment transaction
-6. Send transaction to the network
-
-Make sure the dependencies are installed with:
-
-```text
-yarn install
-```
-
-Run the createAccount.js script with:
-
-```text
-node createAccount.js
-```
-
-```javascript title="createAccount.js"
-const Web3 = require("web3");
-const web3 = new Web3("http://localhost:8545");
-
-console.log(web3.eth.accounts.create());
-```
-
-The provided code will print a private key / account pair in the terminal. Copy and paste the printed `priavteKey` into a `PRIVATE_KEY` variable in a file called `.env`, similar to what is shown in the `.envexample` file. The `address` that is printed with the private key is the account that we will fund with the faucet.
-
-If you go to the [Alfajores Faucet Page](https://faucet.celo.org), you can faucet your account some CELO and see your balance increase.
-
-### Deploy the contract
-
-#### Truffle Deployment
-
-Before you can use truffle for the migration, you need to set up the proper configuration in `./truffle-config.js`. At the top of `./truffle-config.js`, set up the `kit` by connecting to the test network and adding the account you just funded.
-
-```javascript title="truffle.config.js"
-const ContractKit = require("@celo/contractkit");
-const Web3 = require("web3");
-require("dotenv").config();
-
-const web3 = new Web3("https://alfajores-forno.celo-testnet.org");
-const kit = ContractKit.newKitFromWeb3(web3);
-
-kit.connection.addAccount(process.env.PRIVATE_KEY);
-```
-
-Then, in the `networks` object, you can add the initialized `kit`provider to an `alfajores` property.
-
-```javascript title="truffle.config.js"
-  networks: {
-    test: {
-      host: "127.0.0.1",
-      port: 7545,
-      network_id: "*"
-    },
-    alfajores: {
-      provider: kit.connection.web3.currentProvider, // CeloProvider
-      network_id: 44787,                             // Alfajores network id
-      gas: 4000000,            // You need to include the gas limit
-    }
-  }
-```
-
-:::info
-
-Truffle doesn't estimate the gas properly, so you need to specify a gas limit in `truffle.config.js`.
-
-:::
-
-Now, deploy the contracts to Alfajores with this command:
-
-```javascript
-truffle migrate --network alfajores
-```
-
-#### Custom Node.js Deployment
-
-In this section, you will deploy a contract using a simple Node.js script to show how you can do it without using Truffle.
-
-You need to compile the `HelloWorld.sol` contract using \(if it isn't already\):
-
-```javascript
-truffle compile
-```
-
-This command will generate a `HelloWorld.json` file in the `./build/contracts/` directory. `HelloWorld.json` contains a lot of data about the contract, compiler and low level details. Import this file into the deployment script `celo_deploy.js` with:
-
-```javascript
-const HelloWorld = require("./build/contracts/HelloWorld.json");
-```
-
-You are finally ready to deploy the contract. Use the `kit`to create a custom transaction that includes the contract bytecode.
-
-```javascript title="celo_deploy.js"
-let tx = await kit.connection.sendTransaction({
-  from: address,
-  data: HelloWorld.bytecode, // from ./build/contracts/HelloWorld.json
-});
-```
-
-:::info
-
-To deploy a contract on Celo, use the `kit.connection.sendTransaction()` function with no `to:` field and the contract bytecode in the `data` field. The account that you are sending the transaction from must have enough CELO to pay the transaction fee, unless you specify another currency as the `feeCurrency`, then you need enough of that currency to pay the transaction fee.
-
-:::
-
-The entire deployment script is about 20 lines of code.
-
-```javascript title="celo_deploy.js"
-const Web3 = require("web3");
-const ContractKit = require("@celo/contractkit");
-const web3 = new Web3("https://alfajores-forno.celo-testnet.org");
-const privateKeyToAddress =
-  require("@celo/utils/lib/address").privateKeyToAddress;
-const kit = ContractKit.newKitFromWeb3(web3);
-require("dotenv").config();
-const HelloWorld = require("./build/contracts/HelloWorld.json");
-
-async function awaitWrapper() {
-  kit.connection.addAccount(process.env.PRIVATE_KEY); // this account must have a CELO balance to pay transaction fees
-
-  // This account must have a CELO balance to pay tx fees
-  // get some testnet funds at https://faucet.celo.org
-  const address = privateKeyToAddress(process.env.PRIVATE_KEY);
-  console.log(address);
-
-  let tx = await kit.connection.sendTransaction({
-    from: address,
-    data: HelloWorld.bytecode,
-  });
-
-  const receipt = await tx.waitReceipt();
-  console.log(receipt);
-}
-
-awaitWrapper();
-```
-
-Congratulations! You have deployed your first contract onto Celo! You can verify your contract deployment on [Blockscout](https://alfajores-blockscout.celo-testnet.org/). You can get the transaction hash from the receipt and look it up on the block explorer.
-
-### Interacting with Custom Contracts
-
-Now HelloWorld.sol is deployed onto the Alfajores testnet. How can you interact with the deployed contract using ContractKit? `helloWorld.js` includes some example code that shows how you can do this.
-
-There are 3 functions defined in `helloWorld.js` that accomplish this.
-
-The first function, `initContract()`, reads the deployed contract information from the Truffle artifact at `HelloWorld.json`. With this information, you can create a new web3.js Contract instance:
-
-```javascript title="helloWorld.js"
-async function initContract() {
-  // Check the Celo network ID
-  const networkId = await web3.eth.net.getId();
-
-  // Get the contract associated with the current network
-  const deployedNetwork = HelloWorld.networks[networkId];
-
-  // Create a new contract instance with the HelloWorld contract info
-  let instance = new kit.web3.eth.Contract(
-    HelloWorld.abi,
-    deployedNetwork && deployedNetwork.address
-  );
-
-  getName(instance);
-  setName(instance, "hello world!");
-}
-```
-
-After creating the contract instance, the `initContract()` function calls `getName()` and `setName()`.
-
-The `getName()` function will call, return and print the `getName()` function of the provided instance of the HelloWorld contract.
-
-```javascript title="helloWorld.js"
-async function getName(instance) {
-  let name = await instance.methods.getName().call();
-  console.log(name);
-}
-```
-
-The `setName()` function is a bit more involved. First, it gets the account key from the provided `./secret` file, just like in `celo_deploy.js`. Then it creates a `txObject` that encodes a smart contract transaction call to `setName()` with the provided `newName` to the provided instance of the HelloWorld contract. Then the function sends the encoded transaction object to the network, waits for a reciept and prints it to the console.
-
-```javascript title="helloWorld.js"
-async function setName(instance, newName) {
-  // Add your account to ContractKit to sign transactions
-  // This account must have a CELO balance to pay tx fees, get some https://faucet.celo.org
-  kit.connection.addAccount(process.env.PRIVATE_KEY);
-  const address = privateKeyToAddress(process.env.PRIVATE_KEY);
-
-  // Encode the transaction to HelloWorld.sol according to the ABI
-  let txObject = await instance.methods.setName(newName);
-
-  // Send the transaction
-  let tx = await kit.sendTransactionObject(txObject, { from: address });
-
-  let receipt = await tx.waitReceipt();
-  console.log(receipt);
-}
-```
-
-The above method shows a more detail about how to create custom deployment transactions and scripts than the previous method.
-
-As you can see, all the goodies from Ethereum apply to Celo, so virtually all tutorials and other content should be easily translatable to Celo.
-
-Check out [https://celo.org/developers](https://celo.org/developers) for more resources!
diff --git a/docs/developer/walkthrough/hello-contracts.md b/docs/developer/walkthrough/hello-contracts.md
deleted file mode 100644
index beac025026..0000000000
--- a/docs/developer/walkthrough/hello-contracts.md
+++ /dev/null
@@ -1,210 +0,0 @@
----
-title: "Deploy a Contract on Celo (local node)"
-description: How to deploy your own smart contracts onto Celo from a local node.
----
-
-# Deploy a Contract (Local Node)
-
-How to deploy your own smart contracts onto a Celo local node.
-
----
-
-:::tip
-
-As Celo is fully EVM compliant, we inherit the rich developer ecosystem and tooling of the Ethereum community. We will be deploying a typical hello world smart contract onto the Alfajores testnet with typical Ethereum tools like Truffle and Ganache.
-
-:::
-
-## Setup
-
-This guide assumes that you have a basic Node/[NPM](https://www.npmjs.com/get-npm) setup (Node.js v12.x). If so, you can install truffle with:
-
-```
-npm install -g truffle
-```
-
-In your desired project folder, intiialize a new truffle project:
-
-```
-truffle init
-```
-
-## Hello World!
-
-Let's add a contract with
-
-```
-truffle create contract HelloWorld
-```
-
-Our contract will just store a name for now:
-
-```solidity
-pragma solidity >=0.5.0 <0.7.0;
-
-contract HelloWorld {
-  string name = 'Celo';
-
-  function getName() public view returns (string memory) {
-    return name;
-  }
-
-  function setName(string calldata newName) external {
-    name = newName;
-  }
-}
-```
-
-## Deploy locally
-
-Let's create a migration to deploy the contract. For that, we need to create a file in the `migrations` folder named `2_deploy_helloworld.js`:
-
-```javascript
-var HelloWorld = artifacts.require("HelloWorld");
-
-module.exports = function (deployer) {
-  deployer.deploy(HelloWorld);
-};
-```
-
-To be able to actually deploy it though, we need a blockchain. For local development and testing, you can use our fork of ganache:
-
-```
-npm install -g @celo/ganache-cli
-```
-
-And then start ganache with:
-
-```
-ganache-cli --port 7545
-```
-
-In your `truffle-config.js`, you'll want to add your local test network under networks:
-
-```
-  networks: {
-    test: {
-      host: "127.0.0.1",
-      port: 7545,
-      network_id: "*"
-    }
-  }
-```
-
-Then you can deploy your contract to your local network first:
-
-```
-truffle migrate --network test
-```
-
-You can interact with your contract by running the truffle console:
-
-```
-truffle console --network test
-truffle(test)> contract = await HelloWorld.deployed()
-undefined
-truffle(test)> contract.getName()
-'Celo'
-truffle(test)> contract.setName('MyName')
-{ tx:
-...
-truffle(test)> contract.getName()
-'MyName'
-```
-
-## Deploy to Alfajores
-
-When you are ready to deploy your contract to Alfajores, you'll need a Celo client connected to the testnet. We'll run a node somewhat similarly to the [Instructions of running a full node on Baklava](/network/baklava/run-full-node):
-
-```bash
-export CELO_IMAGE=us.gcr.io/celo-org/geth:alfajores
-```
-
-### Pull the Celo Docker image
-
-We're going to use a Docker image containing the Celo node software in this tutorial.
-
-If you are re-running these instructions, the Celo Docker image may have been updated, and it's important to get the latest version.
-
-```bash
-docker pull $CELO_IMAGE
-```
-
-### Set up a data directory
-
-First, create the directory that will store your node's configuration and its copy of the blockchain. This directory can be named anything you'd like, but here's a default you can use. The commands below create a directory and then navigate into it. The rest of the steps assume you are running the commands from inside this directory.
-
-```bash
-mkdir celo-data-dir
-cd celo-data-dir
-```
-
-### Create an account and get its address
-
-In this step, you'll create an account on the network. If you've already done this and have an account address, you can skip this and move on to configuring your node.
-
-Run the command to create a new account:
-
-```bash
-docker run -v $PWD:/root/.celo --rm -it $CELO_IMAGE account new
-```
-
-It will prompt you for a passphrase, ask you to confirm it, and then will output your account address: `Address: {<YOUR-ACCOUNT-ADDRESS>`
-
-Save this address to an environment variables, so that you can reference it below (don't include the braces):
-
-```bash
-export CELO_ACCOUNT_ADDRESS=<YOUR-ACCOUNT-ADDRESS>
-```
-
-_Note: this environment variable will only persist while you have this terminal window open. If you want this environment variable to be available in the future, you can add it to your `~/.bash_profile_
-
-### Start the node
-
-This command specifies the settings needed to run the node, and gets it started.
-
-```bash
-docker run --name celo-ultralight-node -d --restart unless-stopped -p 127.0.0.1:8545:8545 -v $PWD:/root/.celo $CELO_IMAGE --verbosity 3  --syncmode lightest --http --http.addr 0.0.0.0 --http.api eth,net,web3,debug,admin,personal --etherbase $CELO_ACCOUNT_ADDRESS --alfajores --datadir=/root/.celo --allow-insecure-unlock
-```
-
-You can follow the logs with
-
-```bash
-docker logs -f celo-ultralight-node
-```
-
-After a few seconds of syncing (with [Celo's ultralight sync](/protocol/consensus/ultralight-sync)), you should be able to query the balance of your account:
-
-```bash
-docker exec celo-ultralight-node geth attach --exec 'eth.getBalance("<YOUR-ACCOUNT-ADDRESS>")'
-```
-
-If you go to our [Alfajores Faucet Page](https://faucet.celo.org), you should be able to faucet your account some CELO and see your balance increase with the above command.
-
-### Deploy the contract
-
-We are finally ready to deploy the contract. First let's unlock the account:
-
-```bash
-docker exec celo-ultralight-node geth attach --exec 'personal.unlockAccount("<YOUR-ACCOUNT-ADDRESS>", "<YOUR-ACCOUNT-PASSWORD>")'
-```
-
-In your `truffle-config.js` reference your node:
-
-```
-alfajores: {
-  host: "127.0.0.1",
-  port: 8545,
-  network_id: 44787
-}
-```
-
-Then you should be able to deploy your contract with:
-
-```
-truffle migrate --network alfajores
-```
-
-You can verify your contract deployment on [Blockscout](https://alfajores-blockscout.celo-testnet.org/), as well as interact with your new contract with the `truffle console --network alfajores`. Congratulations!
-
-As you can see, all the goodies from Ethereum apply to Celo, so virtually all tutorials and other content should be easily translatable to Celo. Check out [https://celo.org/developers](https://celo.org/developers) for more resources!
diff --git a/docs/learn/celo-resources.md b/docs/learn/celo-resources.md
index 36901229b1..27128d3867 100644
--- a/docs/learn/celo-resources.md
+++ b/docs/learn/celo-resources.md
@@ -148,14 +148,6 @@ Curated collection of Celo resources for developers, designers, dreamers, and do
 - [Plumo Ceremony](https://www.youtube.com/watch?v=VsAH4N92Au0&list=PLsQbsop73cfFjAB66fE2oCQFLRVfqa2V9&index=7)
 - [Celo Bounties at #ETHDenver](https://www.youtube.com/watch?v=WhY0fKXgKsg&list=PLsQbsop73cfFjAB66fE2oCQFLRVfqa2V9&index=8)
 
-## Celo Tutorials (Figment Pathway)
-
-- [Learn how connect to Celo node with DataHub](https://www.youtube.com/watch?v=bz76yk-Bww4&list=PLsQbsop73cfGd9sYPqvX3mkTHbfLXpS1X)
-- [Create your First Celo Account](https://www.youtube.com/watch?v=3VJyk669O-k&list=PLsQbsop73cfGd9sYPqvX3mkTHbfLXpS1X&index=2)
-- [Query the Celo Network](https://www.youtube.com/watch?v=u0lC1g966oo&list=PLsQbsop73cfGd9sYPqvX3mkTHbfLXpS1X&index=3)
-- [Submit your first transactions](https://www.youtube.com/watch?v=ljt-_dxpqLU&list=PLsQbsop73cfGd9sYPqvX3mkTHbfLXpS1X&index=4)
-- [Write and deploy your first Celo smart contract](https://www.youtube.com/watch?v=pQvrl4yOi10&list=PLsQbsop73cfGd9sYPqvX3mkTHbfLXpS1X&index=5)
-
 ## #MakeitMobile Hackathon
 
 - [Everything You Need to #MakeItMobile​ on Celo](https://www.youtube.com/watch?v=8Z7__lqu3Yk&list=PLsQbsop73cfFx53_9VGaH7Gw8ddDcAzDm)
diff --git a/docs/learn/evm-compatible-tooling.md b/docs/learn/evm-compatible-tooling.md
deleted file mode 100644
index 8aa69509aa..0000000000
--- a/docs/learn/evm-compatible-tooling.md
+++ /dev/null
@@ -1,458 +0,0 @@
----
-title: Celo EVM Compatible Tooling
-description: Overview of Celo EVM compatible tools and the value they provide to developers.
----
-
-# Developer Tools
-
-A guide to available tools, components, patterns, and platforms for developing applications on EVM-compatible chains.
-
----
-
-## New developers start here
-
-- [Solidity](https://soliditylang.org/) - The most popular smart contract language.
-- [Metamask](https://metamask.io/) - Browser extension wallet to interact with Dapps.
-- [Truffle](https://trufflesuite.com/) - Most popular smart contract development, testing, and deployment framework. Install the cli via npm and start here to write your first smart contracts.
-- [Truffle boxes](https://trufflesuite.com/boxes) - Packaged components for the Ethereum ecosystem.
-- [Hardhat](https://hardhat.org/) - Flexible, extensible and fast Ethereum development environment.
-- [Cryptotux](https://cryptotux.org/) - A Linux image ready to be imported in VirtualBox that includes the development tools mentionned above
-- [OpenZeppelin Starter Kits](https://openzeppelin.com/starter-kits/) - An all-in-one starter box for developers to jumpstart their smart contract backed applications. Includes Truffle, OpenZeppelin SDK, the OpenZeppelin/contracts-ethereum-package EVM package of audited smart contract, a react-app and rimble for easy styling.
-- [EthHub.io](https://docs.ethhub.io/) - Comprehensive crowdsourced overview of Ethereum- its history, governance, future plans and development resources.
-- [EthereumDev.io](https://ethereumdev.io) - The definitive guide for getting started with Ethereum smart contract programming.
-- [Brownie](https://github.com/iamdefinitelyahuman/brownie) - Brownie is a Python framework for deploying, testing and interacting with Ethereum smart contracts.
-- [Ethereum Stack Exchange](https://ethereum.stackexchange.com/) - Post and search questions to help your development life cycle.
-- [dfuse](https://dfuse.io) - Slick blockchain APIs to build world-class applications.
-- [Biconomy](https://biconomy.io) - Do gasless transactions in your dapp by enabling meta-transactions using simple to use SDK.
-- [Blocknative](https://blocknative.com) — Blockchain events before they happen. Blocknative's portfolio of developers tools make it easy to build with mempool data.
-- [useWeb3.xyz](https://useweb3.xyz/) — A curated overview of the best and latest resources on Ethereum, blockchain and Web3 development.
-
-## Developing Smart Contracts
-
-### Smart Contract Languages
-
-- [Solidity](https://docs.soliditylang.org/en/latest/) - Ethereum smart contracting language
-- [Vyper](https://vyper.readthedocs.io/en/latest/) - New experimental pythonic programming language
-
-### Frameworks
-
-- [Truffle](https://trufflesuite.com/) - Most popular smart contract development, testing, and deployment framework. The Truffle suite includes Truffle, [Ganache](https://github.com/trufflesuite/ganache), and [Drizzle](https://github.com/truffle-box/drizzle-box). [Deep dive on Truffle here](https://media.consensys.net/truffle-deep-dive-what-you-need-to-know-when-developing-on-ethereum-e548d4df6e9)
-- [Hardhat](https://hardhat.org/) - Flexible, extensible and fast Ethereum development environment.
-- [Brownie](https://github.com/iamdefinitelyahuman/brownie) - Brownie is a Python framework for deploying, testing and interacting with Ethereum smart contracts.
-- [Embark](https://github.com/embark-framework/embark) - Framework for DApp development
-- [Waffle](https://getwaffle.io/) - Framework for advanced smart contract development and testing, small, flexible, fast (based on ethers.js)
-- [Dapp](https://dapp.tools/dapp/) - Framework for DApp development, successor to DApple
-- [Etherlime](https://github.com/LimeChain/etherlime) - ethers.js based framework for Dapp deployment
-- [Parasol](https://github.com/Lamarkaz/parasol) - Agile smart contract development environment with testing, INFURA deployment, automatic contract documentation and more. It features a flexible and unopinionated design with unlimited customizability
-- [0xcert](https://github.com/0xcert/framework/) - JavaScript framework for building decentralized applications
-- [OpenZeppelin SDK](https://openzeppelin.com/sdk/) - OpenZeppelin SDK: A suite of tools to help you develop, compile, upgrade, deploy and interact with smart contracts.
-- [sbt-ethereum](https://sbt-ethereum.io/) - A tab-completey, text-based console for smart-contract interaction and development, including wallet and ABI management, ENS support, and advanced Scala integration.
-- [Cobra](https://github.com/cobraframework/cobra) - A fast, flexible and simple development environment framework for Ethereum smart contract, testing and deployment on Ethereum virtual machine(EVM).
-- [Epirus](https://docs.epirus.io/sdk/) - Java framework for building smart contracts.
-
-### IDEs
-
-- [Remix](https://remix.ethereum.org/) - Web IDE with built in static analysis, test blockchain VM.
-- [Ethereum Studio](https://studio.ethereum.org/) - Web IDE. Built in browser blockchain VM, Metamask integration (one click deployments to Testnet/Mainnet), transaction logger and live code your WebApp among many other features.
-- [Atom](https://atom.io/) - Atom editor with [Atom Solidity Linter](https://atom.io/packages/atom-solidity-linter), [Etheratom](https://atom.io/packages/etheratom), [autocomplete-solidity](https://atom.io/packages/autocomplete-solidity), and [language-solidity](https://atom.io/packages/language-solidity) packages
-- [Vim solidity](https://github.com/tomlion/vim-solidity) - Vim syntax file for solidity
-- [Visual Studio Code](https://marketplace.visualstudio.com/items?itemName=JuanBlanco.solidity) - Visual Studio Code extension that adds support for Solidity
-- [Ethcode](https://marketplace.visualstudio.com/items?itemName=quantanetwork.ethcode) - Visual Studio Code extension to compile, execute & debug Solidity & Vyper programs
-- [Intellij Solidity Plugin](https://github.com/intellij-solidity/intellij-solidity/wiki) - Open-source plug-in for [JetBrains IntelliJ Idea IDE](https://jetbrains.com/idea/) (free/commercial) with syntax highlighting, formatting, code completion etc.
-- [YAKINDU Solidity Tools](https://github.com/Yakindu/solidity-ide) - Eclipse based IDE. Features context sensitive code completion and help, code navigation, syntax coloring, build in compiler, quick fixes and templates.
-- [Eth Fiddle](https://ethfiddle.com/) - IDE developed by [The Loom Network](https://loomx.io/) that allows you to write, compile and debug your smart contract. Easy to share and find code snippets.
-
-## Other tools
-
-- [Atra Blockchain Services](https://console.atra.io) - Atra provides web services to help you build, deploy, and maintain decentralized applications on the Ethereum blockchain.
-- [Azure Blockchain Dev Kit for Ethereum for VSCode](https://marketplace.visualstudio.com/items?itemName=AzBlockchain.azure-blockchain) - VSCode extension that allows for creating smart contracts and deploying them inside of Visual Studio Code
-
-## Test Blockchain Networks
-
-- [ethnode](https://github.com/vrde/ethnode) - Run an Ethereum node (Geth or Parity) for development, as easy as `npm i -g ethnode && ethnode`.
-- [Ganache](https://github.com/trufflesuite/ganache) - App for test Ethereum blockchain with visual UI and logs
-- [Kaleido](https://kaleido.io/) - Use Kaleido for spinning up a consortium blockchain network. Great for PoCs and testing
-- [Besu Private Network](https://besu.hyperledger.org/en/stable/Tutorials/Quickstarts/Azure-Private-Network-Quickstart/) - Run a private network of Besu nodes in a Docker container
-  **[Orion](https://github.com/PegaSysEng/orion) - Component for performing private transactions by PegaSys
-  ** [Artemis](https://github.com/PegaSysEng/artemis) - Java implementation of the Ethereum 2.0 Beacon Chain by PegaSys
-- [Cliquebait](https://github.com/f-o-a-m/cliquebait) - Simplifies integration and accepting testing of smart contract applications with docker instances that closely resembles a real blockchain network
-- [Local Raiden](https://github.com/ConsenSys/Local-Raiden) - Run a local Raiden network in docker containers for demo and testing purposes
-- [Private networks deployment scripts](https://github.com/ConsenSys/private-networks-deployment-scripts) - Out-of-the-box deployment scripts for private PoA networks
-- [Local Ethereum Network](https://github.com/ConsenSys/local_ethereum_network) - Out-of-the-box deployment scripts for private PoW networks
-- [Ethereum on Azure](https://docs.microsoft.com/en-us/azure/blockchain/templates/ethereum-poa-deployment) - Deployment and governance of consortium Ethereum PoA networks
-- [Ethereum on Google Cloud](https://console.cloud.google.com/marketplace/details/click-to-deploy-images/ethereum?filter=category:developer-tools) - Build Ethereum network based on Proof of Work
-- [Infura](https://infura.io/) - Ethereum API access to Ethereum networks (Mainnet, Ropsten, Rinkeby, Goerli, Kovan)
-- [CloudFlare Distributed Web Gateway](https://cloudflare.com/distributed-web-gateway/) - Provides access to the Ethereum network through the Cloudflare instead of running your own node
-- [Chainstack](https://chainstack.com/) - Shared and dedicated Ethereum nodes as a service (Mainnet, Ropsten)
-- [Alchemy](https://alchemyapi.io/) - Blockchain Developer Platform, Ethereum API, and Node Service (Mainnet, Ropsten, Rinkeby, Goerli, Kovan)
-- [ZMOK](https://zmok.io/) - JSON-RPC Ethereum API (Mainnet, Rinkeby, Front-running Mainnet)
-- [Watchdata](https://watchdata.io) - Provide simple and reliable API access to Ethereum blockchain
-
-### Test Ether Faucets
-
-- [Rinkeby faucet](https://faucet.rinkeby.io/)
-- [Kovan faucet](https://github.com/kovan-testnet/faucet)
-- [Ropsten faucet (MetaMask)](https://faucet.metamask.io/)
-- [Ropsten faucet (rpanic)](https://faucet.rpanic.com)
-- [Goerli faucet](https://goerli-faucet.slock.it/)
-- [Universal faucet](https://faucets.blockxlabs.com/)
-- [Nethereum.Faucet](https://github.com/Nethereum/Nethereum.Faucet) - A C#/.NET faucet
-
-## Communicating with Ethereum
-
-### Frontend Ethereum APIs
-
-- [Web3.js](https://github.com/ethereum/web3.js/) - Javascript Web3
-- [Eth.js](https://github.com/ethjs) - Javascript Web3 alternative
-- [Ethers.js](https://github.com/ethers-io/ethers.js/) - Javascript Web3 alternative, useful utilities and wallet features
-- [useDApp](https://usedapp.io) - React based framework for rapid DApp development on Ethereum
-- [light.js](https://github.com/paritytech/js-libs/tree/master/packages/light.js) A high-level reactive JS library optimized for light clients.
-- [Web3Wrapper](https://github.com/0xProject/0x-monorepo/tree/development/packages/web3-wrapper) - Typescript Web3 alternative
-- [Ethereumjs](https://github.com/ethereumjs/) - A collection of utility functions for Ethereum like [ethereumjs-util](https://github.com/ethereumjs/ethereumjs-util) and [ethereumjs-tx](https://github.com/ethereumjs/ethereumjs-tx)
-- [Alchemy-web3.js](https://github.com/alchemyplatform/alchemy-web3) - Javascript Web3 wrapper with automatic retries, access to [Alchemy's enhanced APIs](https://docs.alchemyapi.io/documentation/alchemy-web3/enhanced-web3-api), and robust websocket connections.
-- [flex-contract](https://github.com/merklejerk/flex-contract) and [flex-ether](https://github.com/merklejerk/flex-ether) - Modern, zero-configuration, high-level libraries for interacting with smart contracts and making transactions.
-- [ez-ens](https://github.com/merklejerk/ez-ens) - Simple, zero-configuration Ethereum Name Service address resolver.
-- [web3x](https://github.com/xf00f/web3x) - A TypeScript port of web3.js. Benefits includes tiny builds and full type safety, including when interacting with contracts.
-- [Nethereum](https://github.com/Nethereum/) - Cross-platform Ethereum development framework
-- [dfuse](https://github.com/dfuse-io/client-js) - A TypeScript library to use [dfuse Ethereum API](https://dfuse.io)
-- [Drizzle](https://github.com/truffle-box/drizzle-box) - Redux library to connect a frontend to a blockchain
-- [Tasit SDK](https://github.com/tasitlabs/tasitsdk) - A JavaScript SDK for making native mobile Ethereum dapps using React Native
-- [useMetamask](https://github.com/mdtanrikulu/use-metamask) - a custom React Hook to manage Metamask in Ethereum ĐApp projects
-- [WalletConnect](https://walletconnect.org/) - Open protocol for connecting Wallets to Dapps
-- [Subproviders](https://0x.org/docs/tools/subproviders) - Several useful subproviders to use in conjunction with [Web3-provider-engine](https://github.com/MetaMask/web3-provider-engine) (including a LedgerSubprovider for adding Ledger hardware wallet support to your dApp)
-- Strictly Typed - Javascript alternatives
-  - [elm-ethereum](https://github.com/cmditch/elm-ethereum)
-  - [purescript-web3](https://github.com/f-o-a-m/purescript-web3)
-- [ChainAbstractionLayer](https://github.com/liquality/chainabstractionlayer) - Communicate with different blockchains (including Ethereum) using a single interface.
-- [Delphereum](https://github.com/svanas/delphereum) - a Delphi interface to the Ethereum blockchain that allows for development of native dApps for Windows, macOS, iOS, and Android.
-- [Torus](https://tor.us/) - Open-sourced SDK to build dapps with a seamless onboarding UX
-- [Fortmatic](https://fortmatic.com/) - A simple to use SDK to build web3 dApps without extensions or downloads.
-- [Portis](https://portis.io/) - A non-custodial wallet with an SDK that enables easy interaction with DApps without installing anything.
-- [create-eth-app](https://github.com/paulrberg/create-eth-app) - Create Ethereum-powered front-end apps with one command.
-- [Scaffold-ETH](https://github.com/austintgriffith/scaffold-eth) - Beginner friendly forkable github for getting started building smart contracts.
-- [Notify.js](https://blocknative.com/notify) - 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.
-
-### Backend Ethereum APIs
-
-- [Web3.py](https://github.com/ethereum/web3.py) - Python Web3
-- [Web3.php](https://github.com/sc0Vu/web3.php) - PHP Web3
-- [Ethereum-php](https://github.com/digitaldonkey/ethereum-php) - PHP Web3
-- [Web3j](https://github.com/web3j/web3j) - Java Web3
-- [Nethereum](https://nethereum.com/) - .Net Web3
-- [Ethereum.rb](https://github.com/EthWorks/ethereum.rb) - Ruby Web3
-- [rust-web3](https://github.com/tomusdrw/rust-web3) - Rust Web3
-- [Web3.hs](https://hackage.haskell.org/package/web3) - Haskell Web3
-- [KEthereum](https://github.com/komputing/KEthereum) - Kotlin Web3
-- [Eventeum](https://github.com/ConsenSys/eventeum) - A bridge between Ethereum smart contract events and backend microservices, written in Java by Kauri
-- [Ethereumex](https://github.com/mana-ethereum/ethereumex) - Elixir JSON-RPC client for the Ethereum blockchain
-- [Ethereum-jsonrpc-gateway](https://github.com/HydroProtocol/ethereum-jsonrpc-gateway) - 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.
-- [EthContract](https://github.com/AgileAlpha/eth_contract) - A set of helper methods to help query ETH smart contracts in Elixir
-- [Ethereum Contract Service](https://github.com/mesg-foundation/service-ethereum-contract) - A MESG Service to interact with any Ethereum contract based on its address and ABI.
-- [Ethereum Service](https://github.com/mesg-foundation/service-ethereum) - A MESG Service to interact with events from Ethereum and interact with it.
-- [Marmo](https://marmo.io/) - Python, JS, and Java SDK for simplifying interactions with Ethereum. Uses relayers to offload transaction costs to relayers.
-- [Ethereum Logging Framework](https://bitbucket.csiro.au/users/kli039/repos/ethereum-logging-framework/browse) - provides advanced logging capabilities for Ethereum applications and networks including a query language, query processor, and logging code generation
-- [Watchdata](https://watchdata.io) - Provide simple and reliable API access to Ethereum blockchain
-
-### Bootstrap/Out-of-Box tools
-
-- [Truffle boxes](https://trufflesuite.com/boxes) - Packaged components for the Ethereum ecosystem
-- [Create Eth App](https://github.com/paulrberg/create-eth-app) - Create Ethereum-powered frontend apps with one command
-- [Besu Private Network](https://besu.hyperledger.org/en/stable/Tutorials/Quickstarts/Azure-Private-Network-Quickstart/) - Run a private network of Besu nodes in a Docker container
-- [Testchains](https://github.com/Nethereum/TestChains) - Pre-configured .NET devchains for fast response (PoA)
-  \*\* [Blazor/Blockchain Explorer](https://github.com/Nethereum/NethereumBlazor) - Wasm blockchain explorer (functional sample)
-- [Local Raiden](https://github.com/ConsenSys/Local-Raiden) - Run a local Raiden network in docker containers for demo and testing purposes
-- [Private networks deployment scripts](https://github.com/ConsenSys/private-networks-deployment-scripts) - Out-of-the-box deployment scripts for private PoA networks
-- [Parity Demo-PoA Tutorial](https://wiki.parity.io/Demo-PoA-tutorial.html) - Step-by-Step tutorial for building a PoA test chain with 2 nodes with Parity authority round consensus
-- [Local Ethereum Network](https://github.com/ConsenSys/local_ethereum_network) - Out-of-the-box deployment scripts for private PoW networks
-- [Kaleido](https://kaleido.io/) - Use Kaleido for spinning up a consortium blockchain network. Great for PoCs and testing
-- [Cheshire](https://github.com/endless-nameless-inc/cheshire) - A local sandbox implementation of the CryptoKitties API and smart contracts, available as a Truffle Box
-- [aragonCLI](https://github.com/aragon/aragon-cli) - aragonCLI is used to create and develop Aragon apps and organizations.
-- [ColonyJS](https://github.com/JoinColony/colonyJS) - JavaScript client that provides an API for interacting with the Colony Network smart contracts.
-- [ArcJS](https://github.com/daostack/arc.js) - Library that facilitates javascript application access to the DAOstack Arc ethereum smart contracts.
-- [Arkane Connect](https://docs.arkane.network/pages/connect-js.html) - JavaScript client that provides an API for interacting with Arkane Network, a wallet provider for building user-friendly dapps.
-- [Onboard.js](https://blocknative.com/onboard) - 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.
-- [web3-react](https://github.com/NoahZinsmeister/web3-react) - React framework for building single-page Ethereum dApps
-
-### Ethereum ABI (Application Binary Interface) tools
-
-- [Online ABI encoder](https://github.com/HashEx/abiencoder) - Free ABI encoder online service that allows you to encode your Solidity contract’s functions and constructor arguments.
-- [ABI decoder](https://github.com/ConsenSys/abi-decoder) - library for decoding data params and events from Ethereum transactions
-- [ABI-gen](https://github.com/0xProject/0x-monorepo/tree/development/packages/abi-gen) - Generate Typescript contract wrappers from contract ABI's.
-- [Ethereum ABI UI](https://github.com/hiddentao/ethereum-abi-ui) - Auto-generate UI form field definitions and associated validators from an Ethereum contract ABI
-- [headlong](https://github.com/esaulpaugh/headlong/) - type-safe Contract ABI and Recursive Length Prefix library in Java
-- [EasyDapper](https://www.easydapper.com) - Generate dapps from Truffle artifacts, deploy contracts on public/private networks, offers live customizable public page to interact with contracts.
-- [One Click dApp](https://oneclickdapp.com) - Instantly create a dApp at a unique URL using the ABI.
-- [Truffle Pig](https://npmjs.com/package/trufflepig) - 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.
-- [Ethereum Contract Service](https://github.com/mesg-foundation/service-ethereum-contract) - A MESG Service to interact with any Ethereum contract based on its address and ABI.
-- [Nethereum-CodeGenerator](https://github.com/StefH/Nethereum-CodeGenerator) - A web based generator which creates a Nethereum based C# Interface and Service based on Solidity Smart Contracts.
-- [EVMConnector](https://evmconnector.dev) - Create shareable contract dashboards and interact with arbitrary EVM-based blockchain functions, with or without an ABI.
-
-### Patterns & Best Practices
-
-#### Patterns for Smart Contract Development
-
-- [Dappsys: Safe, simple, and flexible Ethereum contract building blocks](https://github.com/dapphub/dappsys)
-  - has solutions for common problems in Ethereum/Solidity, eg.
-    - [Whitelisting](https://steemit.com/ethereum/@nexusdev/dapp-a-day-11-whitelist-boring)
-    - [Upgradable ERC20-Token](https://steemit.com/ethereum/@nikolai/dapp-a-day-6-upgradeable-tokens)
-    - [ERC20-Token-Vault](https://steemit.com/ethereum/@nexusdev/dapp-a-day-18-erc20-token-vault)
-    - [Authentication (RBAC)](https://steemit.com/ethereum/@nikolai/dapp-a-day-4-access-control-via-auth)
-    - [...several more...](https://github.com/dapphub/dappsys)
-  - provides building blocks for the [MakerDAO](https://github.com/makerdao/maker-otc) or [The TAO](https://github.com/ryepdx/the-tao)
-  - should be consulted before creating own, untested, solutions
-  - usage is described in [Dapp-a-day 1-10](https://steemit.com/@nikolai) and [Dapp-a-day 11-25](https://steemit.com/@nexusdev)
-- [OpenZeppelin Contracts: An open framework of reusable and secure smart contracts in the Solidity language.](https://github.com/OpenZeppelin/openzeppelin-contracts)
-  - Likely the most widely-used libraries and smart contracts
-  - Similar to Dappsys, more integrated into Truffle framework
-  - [Blog about Best Practices with Security Audits](https://blog.openzeppelin.com/)
-- [Advanced Workshop with Assembly](https://github.com/androlo/solidity-workshop)
-- [Simpler Ethereum Multisig](https://medium.com/@ChrisLundkvist/exploring-simpler-ethereum-multisig-contracts-b71020c19037) - especially section _Benefits_
-- [CryptoFin Solidity Auditing Checklist](https://github.com/cryptofinlabs/audit-checklist) - A checklist of common findings, and issues to watch out for when auditing a contract for a mainnet launch.
-- [aragonOS: A smart contract framework for building DAOs, Dapps and protocols](https://hack.aragon.org/docs/aragonos-intro.html)
-  - 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
-- [EIP-2535 Diamond Standard](https://eips.ethereum.org/EIPS/eip-2535)
-  - 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.
-- [Clean Contracts - A guide to writing clean code](https://www.wslyvh.com/clean-contracts/)
-
-#### Upgradeability
-
-- [Blog von Elena Dimitrova, Dev at colony.io](https://blog.colony.io/author/elena/)
-  - https://blog.colony.io/writing-more-robust-smart-contracts-99ad0a11e948
-  - https://blog.colony.io/writing-upgradeable-contracts-in-solidity-6743f0eecc88
-- [Aragon research blog](https://blog.aragon.org/tag/research/)
-  - [Library driven development](https://blog.aragon.org/library-driven-development-in-solidity-2bebcaf88736)
-  - [Advanced Solidity code deployment techniques](https://blog.aragon.org/advanced-solidity-code-deployment-techniques-dc032665f434/)
-- [OpenZeppelin on Proxy Libraries](https://blog.openzeppelin.com/proxy-libraries-in-solidity-79fbe4b970fd/)
-
-## Infrastructure
-
-### Ethereum Clients
-
-- [Besu](https://besu.hyperledger.org/en/latest/) - an open-source Ethereum client developed under the Apache 2.0 license and written in Java. The project is hosted by Hyperledger.
-- [Geth](https://geth.ethereum.org/docs/) - Go client
-- [OpenEthereum](https://github.com/openethereum/openethereum) - Rust client, formerly called Parity
-- [Aleth](https://github.com/ethereum/aleth) - C++ client
-- [Nethermind](https://github.com/NethermindEth/nethermind) - .NET Core client
-- [Infura](https://infura.io/) - A managed service providing Ethereum client standards-compliant APIs
-- [Trinity](https://trinity.ethereum.org/) - Python client using [py-evm](https://github.com/ethereum/py-evm)
-- [Ethereumjs](https://github.com/ethereumjs/ethereumjs-client) - JS client using [ethereumjs-vm](https://github.com/ethereumjs/ethereumjs-vm)
-- [Seth](https://github.com/dapphub/dapptools/tree/master/src/seth) - Seth is an Ethereum client tool—like a "MetaMask for the command line"
-- [Mustekala](https://github.com/musteka-la/mustekala) - Ethereum Light Client project of Metamask
-- [Exthereum](https://github.com/exthereum/blockchain) - Elixir client
-- [EWF Parity](https://github.com/energywebfoundation/energyweb-ui) - Energy Web Foundation client for the Tobalaba test network
-- [Quorum](https://github.com/jpmorganchase/quorum) - A permissioned implementation of Ethereum supporting data privacy by [JP Morgan](https://jpmorgan.com/quorum)
-- [Mana](https://github.com/mana-ethereum/mana) - Ethereum full node implementation written in Elixir.
-- [Chainstack](https://chainstack.com/) - A managed service providing shared and dedicated Geth nodes
-- [QuickNode](https://quicknode.com/) - Blockchain developer cloud with API access and node-as-a-service.
-- [Watchdata](https://watchdata.io) - Provide simple and reliable API access to Ethereum blockchain
-
-### Storage
-
-- [IPFS](https://ipfs.io/) - Decentralised storage and file referencing
-  - [Mahuta](https://github.com/ConsenSys/Mahuta) - IPFS Storage service with added search capability, formerly IPFS-Store
-  - [OrbitDB](https://github.com/orbitdb/orbit-db) - Decentralised database on top of IPFS
-  - [JS IPFS API](https://github.com/ipfs/js-ipfs-http-client) - A client library for the IPFS HTTP API, implemented in JavaScript
-  - [TEMPORAL](https://github.com/RTradeLtd/Temporal) - Easy to use API into IPFS and other distributed/decentralised storage protocols
-  - [PINATA](https://pinata.cloud) - The Easiest Way to Use IPFS
-- [Swarm](https://swarm-gateways.net/) - Distributed storage platform and content distribution service, a native base layer service of the Ethereum web3 stack
-- [Infura](https://infura.io/) - A managed IPFS API Gateway and pinning service
-- [3Box Storage](https://docs.3box.io/api/storage) - An api for user controlled, distrubuted storage. Built on top of IPFS and Orbitdb.
-- [Aleph.im](https://aleph.im/) - an offchain incentivized peer-to-peer cloud project (database, file storage, computing and DID) compatible with Ethereum and IPFS.
-
-### Messaging
-
-- [Whisper](https://github.com/ethereum/wiki/wiki/Whisper) - Communication protocol for DApps to communicate with each other, a native base layer service of the Ethereum web3 stack
-- [DEVp2p Wire Protocol](https://github.com/ethereum/devp2p/blob/master/rlpx.md) - Peer-to-peer communications between nodes running Ethereum/Whisper
-- [Pydevp2p](https://github.com/ethereum/pydevp2p) - Python implementation of the RLPx network layer
-- [3Box Threads](https://docs.3box.io/api/messaging) - API to allow developers to implement IPFS persisted, or in memory peer to peer messaging.
-
-## Testing Tools
-
-- [Truffle Teams](https://trufflesuite.com/teams) - Zero-Config continuous integration for truffle projects
-- [Solidity code coverage](https://github.com/0xProject/0x-monorepo/tree/development/packages/sol-coverage) - Solidity code coverage tool
-- [Solidity coverage](https://github.com/sc-forks/solidity-coverage) - Alternative code coverage for Solidity smart-contracts
-- [Solidity function profiler](https://github.com/EricR/sol-function-profiler) - Solidity contract function profiler
-- [Sol-profiler](https://github.com/Aniket-Engg/sol-profiler) - Alternative and updated Solidity smart contract profiler
-- [Espresso](https://github.com/hillstreetlabs/espresso) - Speedy, parallelised, hot-reloading solidity test framework
-- [Eth tester](https://github.com/ethereum/eth-tester) - Tool suite for testing Ethereum applications
-- [Cliquebait](https://github.com/f-o-a-m/cliquebait) - Simplifies integration and accepting testing of smart contract applications with docker instances that closely resembles a real blockchain network
-- [Hevm](https://github.com/dapphub/dapptools/tree/master/src/hevm) - The hevm project is an implementation of the Ethereum virtual machine (EVM) made specifically for unit testing and debugging smart contracts
-- [Ethereum graph debugger](https://github.com/fergarrui/ethereum-graph-debugger) - Solidity graphical debugger
-- [Tenderly CLI](https://github.com/Tenderly/tenderly-cli) - Speed up your development with human readable stack traces
-- [Solhint](https://github.com/protofire/solhint) - Solidity linter that provides security, style guide and best practice rules for smart contract validation
-- [Ethlint](https://github.com/duaraghav8/Ethlint) - Linter to identify and fix style & security issues in Solidity, formerly Solium
-- [Decode](https://github.com/hacker-DOM/decode) - npm package which parses tx's submitted to a local testrpc node to make them more readable and easier to understand
-- [truffle-assertions](https://github.com/rkalis/truffle-assertions) - 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.
-- [Psol](https://github.com/Lamarkaz/psol) - Solidity lexical preprocessor with mustache.js-style syntax, macros, conditional compilation and automatic remote dependency inclusion.
-- [solpp](https://github.com/merklejerk/solpp) - Solidity preprocessor and flattener with a comprehensive directive and expression language, high precision math, and many useful helper functions.
-- [Decode and Publish](https://flightwallet.github.io/decode-eth-tx/) – Decode and publish raw ethereum tx. Similar to https://live.blockcypher.com/btc-testnet/decodetx/
-- [Doppelgänger](https://github.com/EthWorks/Doppelganger) - a library for mocking smart contract dependencies during unit testing.
-- [rocketh](https://github.com/wighawag/rocketh) - A simple lib to test ethereum smart contract that allow to use whatever web3 lib and test runner you choose.
-- [pytest-cobra](https://github.com/cobraframework/pytest-cobra) - PyTest plugin for testing smart contracts for Ethereum blockchain.
-
-## Security Tools
-
-- [MythX](https://mythx.io/) - Security verification platform and tools ecosystem for Ethereum developers
-- [Mythril](https://github.com/ConsenSys/mythril) - Open-source EVM bytecode security analysis tool
-- [Oyente](https://github.com/melonproject/oyente) - Alternative static smart contract security analysis
-- [Securify](https://securify.chainsecurity.com/) - Security scanner for Ethereum smart contracts
-- [SmartCheck](https://tool.smartdec.net/) - Static smart contract security analyzer
-- [Ethersplay](https://github.com/crytic/ethersplay) - EVM disassembler
-- [Evmdis](https://github.com/Arachnid/evmdis) - Alternative EVM disassembler
-- [Hydra](https://github.com/IC3Hydra/Hydra) - Framework for cryptoeconomic contract security, decentralised security bounties
-- [Solgraph](https://github.com/raineorshine/solgraph) - Visualise Solidity control flow for smart contract security analysis
-- [Manticore](https://github.com/trailofbits/manticore) - Symbolic execution tool on Smart Contracts and Binaries
-- [Slither](https://github.com/crytic/slither) - A Solidity static analysis framework
-- [Adelaide](https://github.com/sec-bit/adelaide) - The SECBIT static analysis extension to Solidity compiler
-- [solc-verify](https://github.com/SRI-CSL/solidity/) - A modular verifier for Solidity smart contracts
-- [Solidity security blog](https://github.com/sigp/solidity-security-blog) - Comprehensive list of known attack vectors and common anti-patterns
-- [Awesome Buggy ERC20 Tokens](https://github.com/sec-bit/awesome-buggy-erc20-tokens) - A Collection of Vulnerabilities in ERC20 Smart Contracts With Tokens Affected
-- [Free Smart Contract Security Audit](https://callisto.network/smart-contract-audit/) - Free smart contract security audits from Callisto Network
-- [Piet](https://piet.slock.it) - A visual Solidity architecture analyzer
-
-## Monitoring
-
-- [Alethio](https://aleth.io/) - 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.
-- [amberdata.io](https://amberdata.io) - Provides live monitoring, insights and anomaly detection, token metrics, smart contract audits, graph visualization and blockchain search.
-- [Neufund - Smart Contract Watch](https://github.com/Neufund/smart-contract-watch) - A tool to monitor a number of smart contracts and transactions
-- [Scout](https://scout.cool/) - A live data feed of the activities and event logs of your smart contracts on Ethereum
-- [Tenderly](https://tenderly.co/) - 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
-- [Chainlyt](https://www.chainlyt.io/main/dashboard/contract) - Explore smart contracts with decoded transaction data, see how the contract is used and search transactions with specific function calls
-- [BlockScout](https://github.com/poanetwork/blockscout) - A tool for inspecting and analyzing EVM based blockchains. The only full featured blockchain explorer for Ethereum networks.
-- [Terminal](https://terminal.co/) - A control panel for monitoring dapps. Terminal can be used to monitor your users, dapp, blockchain infrastructure, transactions and more.
-- [Ethereum-watcher](https://github.com/HydroProtocol/ethereum-watcher) - An extensible framework written in Golang for listening to on-chain events and doing something in response.
-- [Alchemy Notify](https://docs.alchemyapi.io/guides/alchemy-notify) - Notifications for mined and dropped transactions, gas price changes, and address activity for desired addresses.
-- [Blocknatve Mempool Explorer](https://www.blocknative.com/explorer) — 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. Recieve 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.
-- [Ethernal](https://www.tryethernal.com) - Ethereum block explorer for private chain. Browse transactions, decode function calls, event data or contract variables values on your locally running chain.
-
-## Other Miscellaneous Tools
-
-- [aragonPM](https://hack.aragon.org/docs/apm-intro.html) - a decentralized package manager powered by aragonOS and Ethereum. aragonPM enables decentralized governance over package upgrades, removing centralized points of failure.
-- [Truffle boxes](https://www.trufflesuite.com/boxes) - Packaged components for building DApps fast.
-  - [Cheshire](https://github.com/endless-nameless-inc/cheshire) - A local sandbox implementation of the CryptoKitties API and smart contracts, available as a Truffle Box
-- [Solc](https://docs.soliditylang.org/en/latest/using-the-compiler.html) - Solidity compiler
-- [Sol-compiler](https://sol-compiler.com/) - Project-level Solidity compiler
-- [Solidity cli](https://github.com/pubkey/solidity-cli) - Compile solidity-code faster, easier and more reliable
-- [Solidity flattener](https://github.com/poanetwork/solidity-flattener) - Combine solidity project to flat file utility. Useful for visualizing imported contracts or for verifying your contract on Etherscan
-- [Sol-merger](https://github.com/RyuuGan/sol-merger) - Alternative, merges all imports into single file for solidity contracts
-- [RLP](https://github.com/ethereumjs/rlp) - Recursive Length Prefix Encoding in JavaScript
-- [eth-cli](https://github.com/protofire/eth-cli) - A collection of CLI tools to help with ethereum learning and development
-- [Ethereal](https://github.com/wealdtech/ethereal) - Ethereal is a command line tool for managing common tasks in Ethereum
-- [Eth crypto](https://github.com/pubkey/eth-crypto) - Cryptographic javascript-functions for Ethereum and tutorials to use them with web3js and solidity
-- [Parity Signer](https://github.com/paritytech/parity-signer) - mobile app allows signing transactions
-- [py-eth](http://py-eth.com) - Collection of Python tools for the Ethereum ecosystem
-- [truffle-flattener](https://github.com/nomiclabs/truffle-flattener) - Concats solidity files developed under Truffle with all of their dependencies
-- [Decode](https://github.com/hacker-DOM/decode) - npm package which parses tx's submitted to a local testrpc node to make them more readable and easier to understand
-- [TypeChain](https://github.com/ethereum-ts/TypeChain) - Typescript bindings for Ethereum smartcontracts
-- [EthSum](https://ethsum.netlify.com) - A Simple Ethereum Address Checksum Tool
-- [PHP based Blockchain indexer](https://github.com/digitaldonkey/ethereum-php-eventlistener) - allows indexing blocks or listening to Events in PHP
-- [Purser](https://github.com/JoinColony/purser) - 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.
-- [Node-Metamask](https://github.com/JoinColony/node-metamask) - Connect to MetaMask from node.js
-- [Solidity-docgen](https://github.com/OpenZeppelin/solidity-docgen) - Documentation generator for Solidity projects
-- [Ethereum ETL](https://github.com/blockchain-etl/ethereum-etl) - Export Ethereum blockchain data to CSV or JSON files
-- [prettier-plugin-solidity](https://github.com/prettier-solidity/prettier-plugin-solidity) - Prettier plugin for formatting Solidity code
-- [Unity3dSimpleSample](https://github.com/Nethereum/Unity3dSimpleSample) - Ethereum and Unity integration demo
-- [Flappy](https://github.com/Nethereum/Nethereum.Flappy) - Ethereum and Unity integration demo/sample
-- [Wonka](https://github.com/Nethereum/Wonka) - Nethereum business rules engine demo/sample
-- [Resolver-Engine](https://github.com/Crypto-Punkers/resolver-engine) - A set of tools to standarize Solidity import and artifact resolution in frameworks.
-- [eth-reveal](https://github.com/justinjmoses/eth-reveal) - A node and browser tool to inspect transactions - decoding where possible the method, event logs and any revert reasons using ABIs found online.
-- [Ethereum-tx-sender](https://github.com/HydroProtocol/ethereum-tx-sender) - 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.
-- [truffle-plugin-verify](https://github.com/rkalis/truffle-plugin-verify) - Seamlessly verify contract source code on Etherscan from the Truffle command line.
-- [Blocknative Gas Platform](https://www.blocknative.com/gas) — 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.
-- [ETH Gas.watch](https://ethgas.watch/) - A gas price watcher with email notifications on price change
-
-## Smart Contract Standards & Libraries
-
-### [ERCs](https://eips.ethereum.org/erc) - The Ethereum Request for Comment repository
-
-- Tokens
-  - [ERC-20](https://eips.ethereum.org/EIPS/eip-20) - Original token contract for fungible assets
-  - [ERC-721](https://eips.ethereum.org/EIPS/eip-721) - Token standard for non-fungible assets
-  - [ERC-777](https://eips.ethereum.org/EIPS/eip-777) - An improved token standard for fungible assets
-  - [ERC-918](https://eips.ethereum.org/EIPS/eip-918) - Mineable Token Standard
-- [ERC-165](https://eips.ethereum.org/EIPS/eip-165) - Creates a standard method to publish and detect what interfaces a smart contract implements.
-- [ERC-725](https://eips.ethereum.org/EIPS/eip-725) - Proxy contract for key management and execution, to establish a Blockchain identity.
-- [ERC-173](https://eips.ethereum.org/EIPS/eip-173) - A standard interface for ownership of contracts
-
-### Popular Smart Contract Libraries
-
-- [Zeppelin](https://github.com/OpenZeppelin/openzeppelin-contracts) - Contains tested reusable smart contracts like SafeMath and OpenZeppelin SDK [library](https://github.com/OpenZeppelin/openzeppelin-sdk) for smart contract upgradeability
-- [cryptofin-solidity](https://github.com/cryptofinlabs/cryptofin-solidity) - A collection of Solidity libraries for building secure and gas-efficient smart contracts on Ethereum.
-- [Modular Libraries](https://github.com/Modular-Network/ethereum-libraries) - A group of packages built for use on blockchains utilising the Ethereum Virtual Machine
-- [DateTime Library](https://github.com/bokkypoobah/BokkyPooBahsDateTimeLibrary) - A gas-efficient Solidity date and time library
-- [Aragon](https://github.com/aragon/aragon) - DAO protocol. Contains [aragonOS smart contract framework](https://github.com/aragon/aragonOS) with focus on upgradeability and governance
-- [ARC](https://github.com/daostack/arc) - an operating system for DAOs and the base layer of the DAO stack.
-- [0x](https://github.com/0xProject) - DEX protocol
-- [Token Libraries with Proofs](https://github.com/sec-bit/tokenlibs-with-proofs) - Contains correctness proofs of token contracts wrt. given specifications and high-level properties
-- [Provable API](https://github.com/provable-things/ethereum-api) - Provides contracts for using the Provable service, allowing for off-chain actions, data-fetching, and computation
-- [ABDK Libraries for Solidity](https://github.com/abdk-consulting/abdk-libraries-solidity) - Fixed-point (64.64 bit) and IEEE-754 compliant quad precision (128 bit) floating-point math libraries for Solidity
-
-## Developer Guides for 2nd Layer Infrastructure
-
-### Scalability
-
-### Payment/State Channels
-
-- [Ethereum Payment Channel](https://medium.com/@matthewdif/ethereum-payment-channel-in-50-lines-of-code-a94fad2704bc) - Ethereum Payment Channel in 50 lines of code
-- [µRaiden Documentation](https://microraiden.readthedocs.io) - Guides and Samples for µRaiden Sender/Receiver Use Cases
-
-### Plasma
-
-- [Learn Plasma](https://github.com/ethsociety/learn-plasma) - Website as Node application that was started at the 2018 IC3-Ethereum Crypto Boot Camp at Cornell University, covering all Plasma variants (MVP/Cash/Debit)
-- [Plasma MVP](https://github.com/omisego/plasma-contracts) - OmiseGO's research implementation of Minimal Viable Plasma
-- [Plasma MVP Golang](https://github.com/kyokan/plasma) - Golang implementation and extension of the Minimum Viable Plasma specification
-- [Plasma Guard](https://github.com/mesg-foundation/plasma-guard) - Automatically watch and challenge or exit from Omisego Plasma Network when needed.
-- [Plasma OmiseGo Watcher](https://github.com/mesg-foundation/service-plasma-omisego-watcher) - Interact with Plasma OmiseGo network and notifies for any byzantine events.
-
-### Side-Chains
-
-- [POA Network](https://www.poa.network/)
-  - [POA Bridge](https://bridge.poa.net/)
-  - [POA Bridge UI](https://github.com/poanetwork/bridge-ui)
-  - [POA Bridge Contracts](https://github.com/poanetwork/poa-bridge-contracts)
-- [Loom Network](https://github.com/loomnetwork)
-- [Matic Network](https://docs.matic.network/)
-
-### Privacy / Confidentiality
-
-#### ZK-SNARKs
-
-- [ZoKrates](https://github.com/Zokrates/ZoKrates) - A toolbox for zkSNARKS on Ethereum
-- [The AZTEC Protocol](https://github.com/AztecProtocol/AZTEC) - Confidential transactions on the Ethereum network, implementation is live on the Ethereum main-net
-- [Nightfall](https://github.com/EYBlockchain/nightfall) - Make any ERC-20 / ERC-721 token private - open source tools & microservices
-- Proxy Re-encryption (PRE)
-  **[NuCypher Network](https://github.com/nucypher/nucypher) - A proxy re-encryption network to empower data privacy in decentralized systems
-  ** [pyUmbral](https://github.com/nucypher/pyumbral) - Threshold proxy re-encryption cryptographic library
-- Fully Homomorphic Encryption (FHE)
-  \*\* [NuFHE](https://github.com/nucypher/nufhe) - GPU accelerated FHE library
-
-### Scalability + Privacy
-
-### ZK-STARKs
-
-- [StarkWare](https://github.com/starkware-industries) and [StarkWare Resources](https://github.com/starkware-libs) - StarkEx scalability engine storing state transitions on-chain
-
-### Prebuilt UI Components
-
-- [aragonUI](https://ui.aragon.org) - A React library including Dapp components
-- [components.bounties.network](https://components.bounties.network) - A React library including Dapp components
-- [ui.decentraland.org](https://github.com/decentraland/ui) - A React library including Dapp components
-- [dapparatus](https://github.com/austintgriffith/dapparatus) - Reusable React Dapp components
-- [Metamask ui](https://github.com/MetaMask/metamask-extension/tree/develop/ui/app/components) - Metamask React Components
-- [DappHybrid](https://github.com/Nethereum/Nethereum.DappHybrid) - A cross-platform hybrid hosting mechanism for web based decentralised applications
-- [Nethereum.UI.Desktop](https://github.com/Nethereum/Nethereum.UI.Desktop) - Cross-platform desktop wallet sample
-- [eth-button](https://eth-button.github.io/eth-button/) - Minimalist donation button
-- [Rimble Design System](https://rimble.consensys.design/) - Adaptable components and design standards for decentralized applications.
-- [3Box Plugins](https://docs.3box.io/build/plugins) - Drop in react components for social functionality. Including comments, profiles and messaging.
-
-:::info
-
-Inspired by: https://github.com/ConsenSys/ethereum-developer-tools-list
-
-:::
diff --git a/docs/network/node/forno.md b/docs/network/node/forno.md
index a8873cfeb8..bb15e09af5 100644
--- a/docs/network/node/forno.md
+++ b/docs/network/node/forno.md
@@ -15,7 +15,7 @@ Forno is a cLabs hosted node service for interacting with the Celo network. This
 
 :::tip
 
-Forno does not offer a terms of service and there are no guarantees about service uptime. For production applications, consider using [Figment Datahub](/developer/tools#figment-datahub) or [Quicknode](/developer/tools#quicknode).
+Forno does not offer a terms of service and there are no guarantees about service uptime. For production applications, consider using or [Quicknode](/developer/tools#quicknode).
 
 :::
 
diff --git a/sidebars.js b/sidebars.js
index 55f7ef0ac9..07a43762c1 100644
--- a/sidebars.js
+++ b/sidebars.js
@@ -71,7 +71,6 @@ const sidebars = {
             },
           ],
         },
-
         {
           type: "category",
           label: "Ledger Wallet",
@@ -302,11 +301,6 @@ const sidebars = {
               label: "Core Contracts Registry",
               id: "developer/contractkit/contracts-wrappers-registry",
             },
-            {
-              type: "doc",
-              label: "Interact with Contracts",
-              id: "developer/walkthrough/hello-contract-remote-node",
-            },
             {
               type: "doc",
               label: "Query On-Chain Identifiers with ODIS",
@@ -487,11 +481,6 @@ const sidebars = {
           label: "Celo Blog",
           href: "https://medium.com/celoorg",
         },
-        {
-          type: "link",
-          label: "Figment",
-          href: "https://learn.figment.io/protocols/celo",
-        },
         {
           type: "link",
           label: "Dacade",
diff --git a/static/_redirects b/static/_redirects
index f325b64a67..bcf4e9b698 100644
--- a/static/_redirects
+++ b/static/_redirects
@@ -491,10 +491,6 @@
 /developer-guide/celo-dapp-gallery /general/gallery
 /developer-resources/walkthroughs/development-chain /developer/setup/development-chain
 /developer-guide/development-chain /developer/setup/development-chain
-/developer-resources/walkthroughs/hello-contract-remote-node /developer/walkthrough/hello-contract-remote-node
-/developer-guide/start/hello-contract-remote-node /developer/walkthrough/hello-contract-remote-node
-/developer-resources/walkthroughs/hellocontracts /developer/walkthrough/hello-contracts
-/developer-guide/start/hellocontracts /developer/walkthrough/hello-contracts
 /developer-resources/walkthroughs/no-code-erc20 /developer/walkthrough/no-code-erc20
 /developer-resources/walkthroughs/no-code-erc721 /developer/walkthrough/no-code-erc721
 /developer-resources/networks/alfajores-testnet /network/alfajores/