## About this tutorial

This tutorial will teach you how to fix a problem that occurs from time to time when using [MetaMask](https://metamask.io/) to transact in Ethereum - when your transaction doesn’t go through or when you need to cancel a transaction for any reason. 

The amount of time needed to confirm an Ethereum transaction is affected by a number of factors - usually, the higher the gas price you pay, the faster your transaction gets mined and approved. If you pay a low gas price, transactions with a higher gas price are prioritized because obviously, there’s more in it for miners. Another factor that affects the time for an Ethereum transaction to complete is how many transactions are being submitted to be approved at the same time. If the Ethereum network is congested, it will take a while for miners to work through the backlog until they reach your spot in the queue. 

Every transaction sent to the Ethereum blockchain has a fee added to it. This fee is called gas. When you submit a transaction, you choose the gas price to be paid (cost of each unit of gas) and the maximum total amount of gas you’re willing to pay (gas limit). Once submitted to the blockchain, your transaction joins the queue of pending transactions. Ethereum miners select transactions from this pool to be grouped into a block of transactions to be processed. 

If your transaction gets stuck, all transactions that you submit after it will be delayed. Ethereum transactions have what is called a nonce value to help identify each transaction submitted by your account. Nonces start at 0 on your account and increase by 1 for each confirmed transaction, which prevents double spending and reduces the number of problems that can come about from that.

Speeding up or cancelling a transaction is done largely the same way - by bypassing the original transaction with another transaction that has a higher gas fee but the same nonce. The higher gas fee transaction will likely go through first and the original transaction will be rejected as it has the same nonce value as the approved transaction. To cancel a transaction, you send another transaction through with the same nonce as the original transaction, but with a higher gas fee and with 0.00 ETH as the value.

## Tutorial
#### MetaMask interface method

MetaMask makes it easy to speed up and cancel cryptocurrency transactions by including a prompt to do so when a transaction has been pending for some time. The feature is built into their interface and easily accessible with a few clicks.

Step 1: Open the MetaMask extension - your transactions will be visible in the transactions queue underneath your account details and the deposit and send buttons<br/><br/>
Step 2: Click the three dots next to your account name and select “Expand View”<br/><br/>
Step 3: Click your transaction to expand its details<br/><br/>
Step 4: If your transaction has been pending for some time, you will have the option to either   speed up or cancel your transaction in a series of buttons next to “Details”<br/><br/>
Step 5: Select “Speed Up” to resubmit your transaction with a higher gas fee, or select “Cancel” to cancel your transaction<br/><br/>
Step 6: If you selected “Speed Up”, MetaMask will ask you to adjust the transaction’s gas fee - using [ETH Gas Station](https://ethgasstation.info/), set the GWEI to be either equal to or higher than the Safe Low volume<br/><br/>
Step 7: If you selected “Cancel”, MetaMask will ask you to confirm the transaction cancellation - a fixed cancellation fee that is lower than your original transaction gas fee will be charged after the cancellation is processed

#### Manual method

This method still uses the MetaMask extension, but it manually overwrites the original pending transaction. The new transaction is processed and the original transaction is cancelled due to the duplicated nonce - some cost is paid through the gas fee.

Step 1: Open the MetaMask extension - this time, hover over your account name at the top of the window and click on it to copy your Ethereum wallet address<br/><br/>
Step 2: Find your transaction using Etherscan by entering your wallet address in the search box<br/><br/>
Step 3: Find your transaction hash - it should be pending and the Ethereum amount should match the sent transaction<br/><br/>
Step 4: Click on the pending transaction to find the nonce labeled “Nonce & {Position}”<br/><br/>
Step 5: Go back to MetaMask and click on the menu icon in the top left corner and select the token to be sent<br/><br/>
Step 6: On the main page, click “Send”<br/><br/>
Step 7: Enter or paste your Ethereum wallet address in the “To” field<br/><br/>
Step 8: Enter the amount of token to be sent in the “Amount” field - enter the same amount as the original transaction if you’re looking to speed up your transaction, and enter 0.00 ETH if you’re looking to cancel your original transaction<br/><br/>
Step 9: Remember to adjust the gas price and gas limit to be slightly higher than your original transaction, that way there is a chance that miners will prioritize your replacement transaction<br/><br/>
Step 10: Type your nonce number from Step 4 into the “Nonce” field - this is important so the network will think the new transaction is the same as the old one<br/><br/>
Step 11: Select “Next” to proceed, check the transaction details for any issues and click “Confirm” to send the transaction<br/><br/>
Step 12: Verify the new transaction with Etherscan - the original transaction should be replaced by the new one

Note that your original transaction has to be pending for these measures to work, and even then there is still a possibility that your original transaction has already been included in a miner’s block. A completed transaction cannot be revoked. It will also be likely that you still have to pay the gas fees for the original transaction. 

## Thanks for reading!

We’d love to hear if you have any thoughts about this article. Let us know what you think in the comments below, or [follow us on Twitter](https://www.twitter.com/defihut). We also have an exciting weekly newsletter with jobs, news and articles delivered directly to your inbox. 


Stuck MetaMask transaction? Follow this guide!

How to cancel or replace pending transactions in MetaMask

# Title

Paragraph text. orem Ipsum is **simply** dummy text of the printing and typesetting industry. Lorem Ipsum has been the industry's standard dummy text ever since the 1500s, when an unknown printer took a galley of type and scrambled it to make a type specimen book. It has survived not only five centuries, but also the leap into electronic typesetting, remaining essentially unchanged. It was popularised in the 1960s with the release of Letraset sheets containing Lorem Ipsum passages, and more recently with desktop publishing software.

## Subtitle

Sometimes even short lists are used such as:

* Implements [GitHub Flavored Markdown](https://github.github.com/gfm/)
* This is how you build a list
* Another list item example

## An image
![Dit is een image](https://live.staticflickr.com/5517/12272940164_5c35d0f180_z.jpg)

## HTML block below

<blockquote>
  Putting text in a blockquote will render it like to
</blockquote>

## How about some code?
```javascript
var React = require('react');
var Markdown = require('react-markdown');
let result = 1 + 1;

console.log("This is some Javascript example code")
```

### Smaller subtitle
#### Even smaller subtitle

Another paragraph text, pretty neat, eh?

## Tables?

| Feature   | Support |
| --------- | ------- |
| tables    | ✔ |
| alignment | ✔ |
| wewt      | ✔ |

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

## More info?

Read usage information and more on [GitHub](//github.com/rexxars/react-markdown)


Every blog needs an example post.

Hello World

## About this tutorial

After completing this tutorial you’ll have a working DApp (Decentralised Application) reacting to Events emitted via a **Solidity Smart Contract** using **Oraclize** to fetch **external API data** from [Coinbase](http://coinbase.com). For science!


We’ll be:
- Writing & deploying a simple **Smart Contract**
- Setting up a local ethereum-bridge for **Oracle communication**
- Fetching external data from the **Coinbase API** using an Oracle
- Creating a custom **front-end** to show the API data
- Doing this in a **local** development environment

![How To Create A Dapp Hero Image](https://media.giphy.com/media/tuMhIOr4UH4Dm/giphy.gif)

> **Note**  
> There’s a screenshot of what we’ll be making at the bottom of the article

### About me

Hi, my name is [Lander](https://twitter.com/WWWillems). I’m a Digital Consultant and product builder from Belgium. When I’m not dabbling in Solidity, I’m working on [Defihut](https://defihut.com), a platform for Decentralised Finance news, tutorials and interviews.

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

## Start
### Prerequisites
1. You’re able to clone a `git` repository & install it’s dependencies via `npm`
2. You have basic knowledge of HTML, JavaScript, [Webpack](https://webpack.js.org/), terminal, …
3. You’re looking to learn more about using **Oraclize** & **Solidity Events**

### What will we be making?

We’ll be writing a Smart Contract that fetches external API Data using a locally running Oracle. We’ll do this by emulating the Oracle using `ethereum-bridge`. The contract fetches the current **Ethereum USD** price from the [Coinbase ETH-USD spot price API](https://api.coinbase.com/v2/prices/ETH-USD/spot).

We’ll be creating a simple **HTML** page that shows our contract’s total ETH balance both in **ETH** and in **USD**. The total USD value of your contract is calculated using the Coinbase API. The values auto-update until the contract runs out of funds.

#### Tools used

- Git, npm
- [Truffle](http://truffleframework.com/), [Truffle webpack box](http://truffleframework.com/boxes/webpack), oraclize-api
- [ethereum-bridge](https://github.com/oraclize/ethereum-bridge)
- Javascript, [Webpack](https://webpack.js.org/)

> “Oracles allow external data, as in non-blockchain data, to be sent to contracts.”

Oracles are trusted data feeds that send information into the Smart Contract, removing the need for Smart Contracts to directly access information outside their network, thus lightening their workload. Oracles are usually supplied by third parties and are authorized by the companies that use them.

The **oracle/oracle network** is the party in charge of connecting you to the data-source. If you’d like to read more about Oracles, [see here](https://blog.oraclize.it/understanding-oracles-99055c9c9f7b).

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

## Let's go
### Install Truffle
First of all, let’s fire up our terminal and install Truffle globally:

```javascript
$ npm install -g truffle
```

We’ll use [Truffle](http://truffleframework.com/) to migrate our contracts, run our development testnet and install [Oraclize](https://oraclize.it/). It’s an essential tool if you’re serious about Solidity development.

### Create a new Truffle project
Create a new folder for our project, called `oraclize-test`:

```javascript
$ mkdir oraclize-test
```

Navigate into the folder and create a new Truffle project.
We’re starting from a [Truffle webpack box](http://truffleframework.com/boxes/webpack), which will make it easier for us to create our DApp’s front-end.

```javascript
$ cd oraclize-test
$ truffle unbox webpack
```

Afterwards, start the Truffle testnet (testrpc):

```javascript
$ truffle develop
```

You should see something like this:
![truffle-develop-image](https://miro.medium.com/max/2000/1*70EHqq9Gh-Gakr83hPnufQ.png)

#### **Notice:**

1. How the second line prints `Truffle Develop started at http://127.0.0.1:9545`
Write down this host:port combination, you’ll need this in order to start `ethereum-bridge`.
2. The amount of accounts created (=10)


Nice, you’ve created a bootstrap Truffle project, and launched the Truffle development testnet. Close the testnet by pressing (ctrl+c) and continue by adding Oraclize to Truffle.

### Add Oraclize to Truffle

Add Oraclize to Truffle and restart the Truffle development testnet

```javascript
$ truffle install oraclize-api
$ truffle develop
```

Notice how, after installing `oraclize-api`, a new folder has been created in our `oraclize-test folder`: `installed_contracts`. In it, you’ll find the Oraclize contract called `usingOraclize.sol` which our Solidity Contract will be inheriting from.

Our `oraclize-test` folder now looks like this

![oraclize-test folder contents](https://miro.medium.com/max/604/1*9tPVIVYmz0MFb7KxJcBs-Q.png)

Keep the testnet active, and open a new terminal window to install `ethereum-bridge`.

### Install ethereum-bridge
Create a new folder (next to `oraclize-test`) called `ethereum-bridge`
Clone the `ethereum-bridge` repository, and install it’s dependencies:

```javascript
$ mkdir ethereum-bridge
$ git clone https://github.com/oraclize/ethereum-bridge ethereum-bridge
$ cd ethereum-bridge
$ npm install
```

> We’re creating the ethereum-bridge folder next to our oraclize-test as we can re-use it in later projects.

You can run `node bridge -a 9` to start `ethereum-bridge`. The `-a 9` argument instructs `ethereum-bridge` to use the last account created by our local Truffle Testnet node to deploy the Oraclize contract. This address should only be used for Oraclize, no other contract is meant to use it.

The Truffle Testnet node creates 10 accounts for you to work with, as their index is 0-based, we’re using the index of 9.

Go on, try it:
```javascript
$ node bridge -a 9
```

Whoops:
![oraclize node bridge error](https://miro.medium.com/max/2000/1*NsMjMlRw4B1WqiAKD7D_TA.png)

As you can see, we’ve ran into an error.
If you read the ERROR line closely, you can see `ethereum-bridge` is trying to connect to the wrong **host:port** combination (http://localhost:8545).

This combination should reflect the combination you wrote down in the previous step. In my case that’s `http://localhost:9545`. Be sure to double-check this as older Truffle versions used to use port 8545.

To resolve this, start ethereum-bridge telling it to use the right host (**-H**) & port (**-p** argument). **Mind the flags, they’re case-sensitive!**

```javascript
$ node bridge -a 9 -H 127.0.0.1 -p 9545 --dev
```

The result should look like this:

![oraclize node bridge result](https://miro.medium.com/max/2000/1*je1DITAAQ7lmdHO2YhyV0Q.png)

Look for the line that looks like:
`OAR = OraclizeAddrResolverI(0x6f485C8BF6fc43eA212E93BBF8ce046C7f1cb475)`

> If you’re using a different mnemonic than the standard Truffle one, the ETH address shown in between the round brackets will be different.

Make sure you write down (copy paste) the complete `OAR` line, so we can use it in the constructor of our contract later. Again, leave your terminal running.

At this point you should have 2 active terminal windows:

- Your Truffle develop testnet
- Your ethereum-bridge

### Write the Solidity Smart Contract
Let’s get started with a sample Smart Contract. Look for the contracts folder in the `oraclize-test` folder and add a new file `OraclizeTest.sol`. This will become the Smart Contract that sends transactions to the Oracle to fetch **API data**. Copy paste the following gist into the file:

**Note:**
Make sure you replace the `OAR = OraclizeAddrResolverI(0x...);` line with the one you wrote down in the previous step.

Don’t forget to remove this `OAR` variable from your constructor before production, **this is just for testing**, in production it will automatically fetch the OAR depending on the chain you’re running it, currently the Mainnet, Ropsten, and browser-solidity VM environment are supported.

<script src="https://gist.github.com/WWWillems/27ce1202e56d0454f27a5a2f1fe81244.js"></script>

Upon contract creation, `theOraclizeTest()` constructor is being run, which sets the owner to the address deploying the contract and initialises the Oracle. Afterwards, it calls the `update()` function once to fetch the current ETH price from the Coinbase API.

The `update()` function checks if the contract holds enough funds to create an URL request, and continues to make the request to Oraclize if it has.

The `__callback()` function is being called by Oraclize as soon as the request has completed, you can use `JSONPATH` to slice the response. See documentation [here](https://docs.oraclize.it/#general-concepts-parsing-helpers).

We can use the first parameter `id` in the `__callback()` function to handle different requests. We’ll be skipping this, as this is only a basic example.

### Compile the code
Look for the contracts folder in `oraclize-test` and delete `ConvertLib.so`l and `MetaCoin.sol`. These are example files, we won’t be needing them.

Copy paste the contract code mentioned above into `OraclizeTest.sol` and compile the code using

```javascript
$ truffle compile
```

If it compiled successfully, you should see a new folder in `oraclize-test` called `build`. This folder contains the compiled version of your Smart Contracts. In it, you’ll find some *,json files that contain the bytecode that will be deployed by **Truffle**

Now, let’s prepare Truffle to deploy our code to our development testnet..

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

### Update Truffle config
Open `truffle.js` in your `oraclize-test` folder and add your development environment:

<script src="https://gist.github.com/WWWillems/f8b755b70c039213101963d7d334b165.js"></script>

Here, we’re defining the development network (=environment), and setting the port number.

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

### Update Truffle migrations
Open `oraclize-test/migrations/2_deploy_contracts.js` and edit it to resemble this snippet:

<script src="https://gist.github.com/WWWillems/95c75ab88714df7d77019000375f10fe.js"></script>

In this gist we’re importing the compiled version of OraclizeTest.sol contract and instructing __Truffle migrations__ how to migrate the contract.

If we wouldn’t do this, Truffle wouldn’t know which files to deploy. It’s pretty standard stuff, look into Truffle migrations if you’re interested.

We’re funding the Smart Contract with **0.5 ETH** (500000000000000000 wei) so we’re able to talk to **Oraclize**. We need ETH to be able to pay for the gas when sending transactions.

Run `truffle migrate --develop --reset` to deploy your contract to the testnet. You should see something resembling this:

![Successful Truffle development testnet migration](https://miro.medium.com/max/1400/1*0OFSeNNuGG9MEEdo4pUFEQ.png)

This will run all migrations located within your project’s `migrations` directory. At their simplest, migrations are simply a set of managed deployment scripts. If your migrations were previously run successfully, truffle migrate will start execution from the last migration that was ran, running only newly created migrations. If no new migrations exists, `truffle migrate` won't perform any action at all. You can use the `--reset` option to run all your migrations from the beginning.

As you can see in the screenshot, Truffle deployed the contract to this address:

```javascript
0x572309f98e9085f9122fbec9de20a00e19a0476a7cde7e7f84b5a7d168a7520e
```

**Note:**
If, like me, you’re seeing gas-related errors when trying to run your Truffle migrations, try to edit the gas amount mentioned in the migration.

If you want to have a better estimation, head to your Truffle Development testnet terminal and enter `eth.getBlock("pending").gasLimit`.
Use the number returned to resolve the issue.

![Truffle development testnet Terminal estimating gasLimit](https://miro.medium.com/max/1400/1*UP3_tfIJifjYGnajcDWUFw.png)

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

### Create a front-end
Open the `app` folder and edit `index.html` to resemble this snippet:

<script src="https://gist.github.com/WWWillems/5dab72c049e091cbe1d52548c10a8e56.js"></script>

No real shocker there, I’m assuming everything is clear regarding the HTML file.

Edit `javascripts/app.js` to look like this:

<script src="https://gist.github.com/WWWillems/000c10d2d38927eeac9cacb3fed407d9.js"></script>

I’ve deliberately kept the JavaScript simple. The comments should be sufficient for a basic understanding of what’s happening.

and edit `stylesheets/app.css` to look like this:

<script src="https://gist.github.com/WWWillems/d9918fff5d56c8a11eeea52acae5d880.js"></script>

Again, Basic stuff. I assume this is pretty clear.

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

### Almost There…
If you’d like to see your DApp, go ahead and spin up the front-end:

```javascript
$ truffle compile
$ truffle migrate --development --reset 
$ npm run dev
```

Your contract needs to be compiled & deployed to your local development testnet. **Make sure to re-compile & re-migrate when you make changes to the Contract**. Truffle-webpack will automatically reload your front-end when it detects changes to the contract. Neat!

Open `http://localhost:8080` and you should see the HTML file showing the Smart Contract balance, and it’s value in USD after a few seconds. The values will update automatically until the Smart Contract runs out of funds. Don’t forget that we need to pay for our Oraclize communication ;).

If everything went smooth, you should see your front-end showing the balance of the Smart Contract in ETH and in USD using Oraclize and Solidity Events:

![DApp Tutorial End Result](https://miro.medium.com/max/1400/1*8NUJr5uoqB24lIR7uF7wFw.png)

Oraclize uses the Coinbase API to fetch the current ETH/USD spot price and return it to the contract. The front-end values will keep updating until the Smart Contract runs out of funds.

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

### Reference Project
I’ve uploaded a reference project to GitHub in case you run into trouble

[https://github.com/WWWillems/medium-02-truffle-oraclize-api](https://github.com/WWWillems/medium-02-truffle-oraclize-api)

### Interesting Links

- [Understanding Oracles](https://blog.oraclize.it/understanding-oracles-99055c9c9f7b) (By Oraclize)
- [Setting up an Oracle machine on Amazon’s AWS](https://bitcointalk.org/index.php?topic=301538.0)
- [How does Oraclize handle the TSLNotary secret?](https://ethereum.stackexchange.com/questions/201/how-does-oraclize-handle-the-tlsnotary-secret)

### Tools

- [ethereum-bridge repository](https://github.com/oraclize/ethereum-bridge)
- [Truffle documentation](http://truffleframework.com/docs)
- [Oraclize documentation](https://docs.oraclize.it/)
- [Solidity documentation](https://solidity.readthedocs.io/en/v0.4.23/)
- [Carbon codesnippets](https://github.com/dawnlabs/carbon)
- [Ganache](http://truffleframework.com/ganache/)
- [Oraclize Remix IDE](https://dapps.oraclize.it/browser-solidity/)

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

### Thanks for reading!
I’d love to hear from you and learn how you feel about my article.
Please let me know if you think anything’s missing.

If you’d like to keep in touch, respond to this post below, [follow me on Twitter](https://twitter.com/WWWillems) or sign up to my newsletter using the form below.








A simple guide on using external API data in a Smart Contract front-end.

How to create a DApp using Truffle, Oraclize, ethereum-bridge and Webpack

### About me
Hi, my name is [Lander](https://twitter.com/WWWillems). I’m a Digital Consultant and product builder from Belgium. When I’m not dabbling in Solidity, I’m working on [Defihut](https://defihut.com), a platform for Decentralised Finance news, tutorials and interviews.

---------------
## About this tutorial

This tutorial is an interpretation of different resources that helped me get up & running setting up my first **private Ethereum testnet blockchain** using Geth and Homebrew. It serves as a future reference for myself and as a help for other crypto enthusiasts. I tried to list most of my resources at the bottom of this article. Please let me know if you feel anything’s missing.

### Private Ethereum testnet blockchain

[Ethereum](https://www.ethereum.org/) software enables a user to set up a “private” or “testnet” Ethereum chain that is separate from the main Ethereum chain. This is useful for testing distributed apps built on Ethereum without having to expose your apps to the real Ethereum network using real Ether. You either pre-generate or mine your own Ether on your private Ethereum chain, so it is a much more cost effective way of trying out Ethereum. Have I said Ethereum enough?

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

> Let’s Geth crackin’

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

## What do you need for this tutorial?

### A few assumptions
- You are using MacOS
- You are a crypto and/or software development enthusiast who’s wanting to make his/her first steps into writing smart contracts.
- You know what Ethereum is and understand it’s basic usage.
- You have a basic understanding of MacOS Terminal usage.

## What will you achieve?
After successfully completing this tutorial, you’ll have a fully functional private Ethereum testnet blockchain running on your local computer.

This private testnet will allow you to develop and test your current **Dapps** (Decentralized Apps) in isolation from the real Ethereum blockchain.

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

## Dictionary

### What is Homebrew?

Homebrew installs the stuff you need that Apple didn’t. I’m not kidding, that’s what their website says. Go & check it out, it’s awesome.

### What is Ethereum?

Ethereum is a cutting edge [blockchain-based](https://en.wikipedia.org/wiki/Blockchain) distributed computing platform, featuring smart contract functionality. It provides a decentralized virtual machine, the Ethereum Virtual Machine (EVM), that can execute peer-to-peer contracts using a crypto-fuel called Ether.

Read the [white paper here](https://github.com/ethereum/wiki/wiki/White-Paper).

### What is Geth?

`geth` is the the command line interface for running a **full ethereum node** implemented in [Go](https://github.com/golang/go). It is the main deliverable of the [Frontier Release](https://github.com/ethereum/go-ethereum/wiki/Frontier).

By [installing and running](https://github.com/ethereum/go-ethereum/wiki/Geth) `geth`, you can take part in the ethereum live network, mine ether on the blockchain, transfer funds between addresses, create contracts and send transactions.

> **WARNING**
> 
> Before you use geth or interact with the ethereum Frontier live network, make sure you read the documentation and fully understand the caveats and risks.

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

## Tutorial
### How to install Homebrew
If you haven’t done so yet, fire up your Terminal and start off by installing [Homebrew](https://brew.sh/):

```javascript
$ /usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"
```

If you’ve already installed Homebrew previously, make sure it’s up to date:

```javascript
$ brew update
$ brew upgrade
```

### How to install Geth
The easiest way to install Geth (go-ethereum) is to use the Homebrew tap

```javascript
$ brew tap ethereum/ethereum 
$ brew install ethereum
```

Test if the installation was successful by running

```javascript
$ geth version
```

This should display your currently installed Geth version:

```javascript
Geth
Version: 1.6.7-stable
Git Commit: ab5646c532292b51e319f290afccf6a44f874372
Architecture: amd64
Protocol Versions: [63 62]
Network Id: 1
Go Version: go1.8.3
Operating System: darwin
GOPATH=
GOROOT=/usr/local/Cellar/go/1.8.3/libexec
```

As you can see, we’re currently running Geth version 1.6.7.
Make sure to check the different options and commands with `geth --help` as well!

---------------
## Let’s get dangerous

![Lets’s Get Dangerous — https://giphy.com/gifs/oadZJB3hwMFjy](https://miro.medium.com/max/450/1*ENKvGRFT9PvsvNAm-t1tCw.gif)

### Connecting to the test net

Let’s start by creating a **genesis block** for your private testnet blockchain. The genesis block is the start of the blockchain — the first block, block 0, and the **only block that does not point to a predecessor block**. The protocol ensures that no other node will agree with your version of the blockchain unless they have the same genesis block, so you can make as many private testnet blockchains as you’d like! (See [documentation](http://ethdocs.org/en/latest/network/test-networks.html))

Create & save a `*.json` file called `CustomGenesis.json` and put these contents in it:

> **SIDENOTE**
>
> There’s a Python tool available to generate your own custom Genesis file. For simplicity’s sake, you can just copy paste this example:

```javascript
{
    "config": {
        "chainId": 15,
        "homesteadBlock": 0,
        "eip155Block": 0,
        "eip158Block": 0
    },
    "difficulty": "0x400",
    "gasLimit": "0x2100000",
    "alloc": {
        "93f932b3b87e08cdaf0877994e44feb4c93e81aa": 
         { "balance": "0x1337000000000000000000" }     
    }
}
```

The file acts as a ‘seed’ for your private testnet.

> **SIDENOTE**
>
> We’ve lowered the difficulty down to 400, so mining new blocks goes faster.

Notice that we added our account address `93f932b3b87e08cdaf0877994e44feb4c93e81aa` to the `"alloc"` object, and that we gave it a balance of **1337000000000000000000 wei** (1337 ETH).

You can use this technique to pre-fund your account. You can define multiple accounts to include in the seed. Note that this step is optional, as you can easily mine the Ether yourself, as you’re in control of the (low) difficulty!

You will reference this file (`CustomGenesis.json`) when initialising your genesis block using the following command:

```javascript
$ geth --identity "MyTestNetNode" --nodiscover --networkid 1999 --datadir /path/to/test-net-blockchain  init /path/to/CustomGenesis.json
```

> **PRO TIP**
>
> I’m using a custom `datadir` flag to separate the testnet blockchain from the real one. I suggest you do as well. This can be any folder you want.

To learn more about the other flags used, please navigate to the [documentation](http://ethdocs.org/en/latest/network/test-networks.html).

### Creating an account on the private tesnet
Create or find a directory where you’d like to store your local private testnet data. For this example, we’ll be using
```javascript
$ /path/to/test-net-blockchain
```
After the previous `geth --version` command ran successfully, run
```javascript
$ geth account new --datadir /path/to/test-net-blockchain
```

This command will ask you for a passphrase (=password). Do not forget this.

> **PRO TIP**
>
> I’m using a custom `datadir` flag to indicate that I’d like to use my personal, local testnet. This keeps it separated from the real testnet.
>
> By default geth will use the same directory for network related files as for the public mainnet. Thus you are advised to set a custom `--datadir` to keep the public network’s chaindata from being reset.

This will create an account on your fresh testnet node, and will return the private testnet address like so:

```javscript
$ Address: {93f932b3b87e08cdaf0877994e44feb4c93e81aa}
```

Save this address **and your password** for later use.

### Pre funding your account
This is an optional step. As the difficulty is so low, it would only take you a few minutes to mine enough Ether to get you going.

Start by removing your previously created blockchain database:
```javascript
$ geth removedb --datadir /path/to/test-net-blockchain
```

Update your `CustomGenesis.json` file:
```javascript
{
    "config": {
        "chainId": 15,
        "homesteadBlock": 0,
        "eip155Block": 0,
        "eip158Block": 0
    },
    "difficulty": "0x400",
    "gasLimit": "0x2100000",
    "alloc": {
        "93f932b3b87e08cdaf0877994e44feb4c93e81aa": 
         { "balance": "0x1337000000000000000000" }     
    }
}
```

Notice that we added our account address `93f932b3b87e08cdaf0877994e44feb4c93e81aa` to the "alloc" object, and that we gave it a balance of 1337000000000000000000 wei (1337 ETH):

You can define multiple accounts to include in the seed.

Run the Genesis block initialisation command again

```javascript
$ geth --identity "MyTestNetNode" --nodiscover --networkid 1999 --datadir /path/to/test-net-blockchain  init /path/to/CustomGenesis.json
```

### If you haven’t done the prefunding
Use this command after starting the JavaScript Console (see next step: ‘Interact with Geth console’):

```javascript
$ geth --identity "MyTestNetNode" --datadir /path/to/test-net-blockchain --nodiscover --networkid 1999 console
```

### Interact with Geth console
To interact with Geth through the console, called the **Geth JavaScript Console** use:
```javascript
$ geth --identity "MyTestNetNode" --datadir /path/to/test-net-blockchain --nodiscover --networkid 1999 console
```
If it ran successfully, you should see a confirmation:
![geth-console-confirmation](https://miro.medium.com/max/680/1*OrKgcpuV_iMhj0daF7tX7Q.png)

If you see this message you can start running Geth JavaScript commands.
Try to use this one to check the balance of your primary account

```javascript
$ web3.fromWei(eth.getBalance(eth.accounts[0]), "ether")
```
> **PRO TIP**
>
> Store these long Geth commands in separate *.sh files so you can re use the configuration (and it’s custom flags) at a later time. You’ll need this every time you’ll want to use your (custom) private testnet.

## Folder Structure
Purely informational, this is what my folder structure looks like:
![ethereum-testnet-folder-structure](https://miro.medium.com/max/662/1*cqFq4BnWfTrroAy2moVI1w.png)

As you can see, I created some `*.sh` script to re-use later on. I’ve [created a repository as a reference](https://github.com/WWWillems/medium-attachments/tree/master/01-private-ethereum-testnet).

---------------
![](https://miro.medium.com/max/500/1*vsYpnPGxe98K_difwpTvrg.gif)

## Congratulations!
You now have a functioning private Ethereum testnet blockchain and an account/wallet running on your personal computer. You can now start mining, send transactions, etc. I’ll be writing some new articles regarding these topics in the near future.

---------------
### Useful commands/tips
1. `geth removedb` 
Deletes/removes your locally synced blockchain data of the public testnet.
2. `geth removedb --datadir /path/to/test-net-blockchain` Deletes/removes your private blockchain testnet data.
3. `geth --fast --cache=1024`
Synchronises the blockchain more quickly. If you choose to use the — fast flag to perform an Ethereum fast sync, you will not retain past transaction data.
4. When using `geth attach` when running a private testnet,
be sure to include the IPC endpoint.
The IPC endpoint is shown when starting your Geth JavaScript console
as such: `IPC endpoint opened: /path/to/endpoint/geth.ipc`
Attach the path to your command so it becomes:
`geth attach /path/to/endpoint/geth.ipc`

### Useful commands/tips
Use these commands once your logged into the Geth console.

1. If you receive an error saying‘`Error: authentication needed: password or unlock`, use this command to unlock your primary account in the Geth JavaScript console:

```javascript
$ personal.unlockAccount(eth.coinbase, 'your account password in quotes', 0)
```

2. To check the balance of your primary account

```javascript
$ web3.fromWei(eth.getBalance(eth.accounts[0]), "ether")
```

3. To see a list of pending transactions
```javascript
$ eth.pendingTransactions
```

### Useful links
- [Ethereum docs](http://ethdocs.org/)
- [Geth JavaScript Console Wiki](https://github.com/ethereum/go-ethereum/wiki/JavaScript-Console)
- [Etherscan](https://etherscan.io/) — An Ethereum Block Explorer and Analytics Platform
- [Ethereum Network stats monitor](https://stats.ethdev.com/)
- [https://github.com/WWWillems/medium-attachments/tree/master/01-private-ethereum-testnet](https://github.com/WWWillems/medium-attachments/tree/master/01-private-ethereum-testnet)

---------------
### Useful commands/tips
People
- [Vitalik Buterin](https://twitter.com/VitalikButerin)
- [Joseph Lubin](https://twitter.com/ethereumjoseph)

Resources
- [Ethereum docs](http://ethdocs.org/)
- [https://github.com/ethereum/go-ethereum/wiki/Installation-Instructions-for-Mac](https://github.com/ethereum/go-ethereum/wiki/Installation-Instructions-for-Mac)

---------------
### Thanks for reading!
I’d love to hear from you and know what you think. Please let me know if you think anything’s missing. If you’d like to keep in touch, respond to this post below, [follow me on Twitter](http://twitter.com/WWWillems) or sign up to the newsletter using the form below.


Defihut Blog

How to cancel or replace pending transactions in MetaMask

Hello World

How to create a DApp using Truffle, Oraclize, ethereum-bridge...

How to set up a private Ethereum testnet blockchain using Geth...

Defi jobs

Support

Company

Legal

Subscribe to our newsletter