This article is based on a [recently published](https://eprint.iacr.org/2021/623.pdf) article by IOHK. For an additional resource, please see the following [video.](https://www.youtube.com/watch?v=s05ypkSC7gk)



## Introduction



Whether it is Ergo, Bitcoin, or another PoW consensus model, miners are needed to constantly maintain the blockchain. In addition to using computational resources, miners also use storage resources that maintain all blockchain data from the genesis block.



## Problem



A new miner's problem: Is downloading all the data from the genesis block strictly necessary? Why is it not possible to download only the most relevant blocks to maintain the network?



## Solution



The block headers of the blockchain should be enough to access the necessary data. [NIPoPoWs](https://nipopows.com/) (Non-Interactive Proofs of Proof of Work) can be integrated to form interlinked block header sets that will reduce historical data storage.



When needing to access key blocks in the blockchain, miners should be able to efficiently do this from the headers of the old blocks. That is because each new block must indicate all of the current network. As new blocks are created, a set of new block headers can be enough to check for the current UTXO set. Since the new blocks contain the data of old stringed block header sets, it enables light mining by eliminating the need to download all the blockchain data.



What are we trying to optimize by stringing old PoW history and compiling it into a snapshot?



If we say C=old blocks and K=new blocks, then included blocks in the snapshot can be growing when K=new blocks are constant and C=old blocks are linear. But it can also be shrinking depending on the smart contract applications. The problem of maintaining heavy loads of data by the miners can be solved by bootstrapping through NIPoPoWs. 



## NIPoPoW Implementation



Instead of accessing all of the blocks, super blocks (or light-clients) are enough to verify all of the blocks. This is accomplished by maintaining the historical data of the blockchain through smart contracts. The introduction of these superblock clients on NIPoPoWs can be done by velvet soft forks, and thereafter “light” miners can bootstrap through “online” mining.



NIPoPoWs enable smart contracts to maintain historical data so that new “light” miners will be able to work in a so called “online” fashion. This is the main idea of Logarithmic Space Mining, where instead of saving all the blockchain data locally on nodes, the unnecessary part of it can be compiled into the blockchain itself. New miners do not need to carry the historical data and as they continue to mine, new "light" miners will help other "light" miners to bootstrap. There will be no need to carry old historical data and old miners can abandon historical data for lighter mining. This is how the whole miner population can abandon old blocks and make the system much more efficient.

Mining in Logarithmic Space: NIPoPoW Power and Ergo

SRBMiner-MULTI CPU & AMD GPU Miner 0.6.6 Win64 & Linux

Lots of improvements and fixes for AMD GPU & CPU miner for Autolykos v2

Added Autolykos algorithm support for Ergo coin. Fee is 5%. Needs at least 3 GB GPU. Suppports Nvidia and AMD

Nanominer v3.2.0 / release 05.02.21

Join Nanopool

"You can mine ERGO coin with us after "The Hardening" protocol upgrade at block 417,792 around 16:00 February 2th"


_We have three great new developments to announce to the Ergo community, all of which will boost our user base and decentralisation!_

We have not just one but three outstanding developments for the Ergo ecosystem to announce! Together, these will make it easier than ever before to acquire, trade, store and spend ERG – and will open up a huge new potential community of users, developers and hodlers.

## Coinsbit listing and airdrop

Firstly, ERG has been listed on [Coinsbit](https://coinsbit.io/): a major trading platform that enables fiat deposits and withdrawals via debit and credit card. Ergo will be listed in three pairs:

* ERG/BTC
* ERG/USDT
* ERG/USD

We anticipate this will bring new traders and liquidity to the currency. The Coinsbit Telegram group has around 120,000 members, so this is a great opportunity to welcome new people to the community.

To celebrate this landmark development and promote Ergo to new traders, we are holding a joint airdrop. The conditions are as follows:

* Join Ergo’s Telegram chat: [https://t.me/ergoplatform](https://t.me/ergoplatform)
* Register on Coinsbit and complete KYC
* Send your Coinsbit username to @Coinsbit on Telegram
* Receive your 5 ERG airdrop!

The airdrop will run for just 10 days and is limited to the first 5,000 participants, so don’t delay!

## Cypra wallet

The second major development is that Ergo will be integrated with the [Cypra wallet](https://cypra.io/). This is a fantastic multi-currency desktop and mobile wallet. It’s secure, open-source and non-custodial – making it super easy and convenient to deal with your coins!

Cypra is designed to address the worst shortcomings of conventional wallets, exchanges and payment services. It enables users to spend their crypto on real-world purchases with minimal friction and the lowest crypto-to-fiat conversion fees. 

You can find out more in [Cypra’s one-page summary](https://cypra.io/static/cypra-onepager.pdf). Check it out, keep your ERG safe and user them in a variety of cool ways!

## Ergo mining pool

Lastly, we will have Ergo’s first censorhip resistant mining pool with collaterals!

This is a really interesting development, since Ergo includes protection against ordinary pools by design. This is a feature implemented to improve decentralisation and accessibility for smaller, regular miners.

Jason, the pool owner, has created a decentralised pool using a smart contract that ensures miners who connect to the pool get paid. This is an intriguing example of smart contracts being used to bypass or change the consensus of a platform. It’s DeFi and community participation in action.

There are plans to implement the Stratum protocol and efficient mining software after the pool launches.

If you’d like to find out more about the theory behind pool mining on Ergo, we have an [academic paper](https://eprint.iacr.org/2020/044) that was presented at Financial Cryptography 2020. 

That’s all for now – but stay tuned, because we have more developments on the way!


Ergo update, 14 May 2020: New exchange, wallet and first mining pool with collaterals!


__We’ve designed Ergo with long-term economic sustainability in mind, and storage rent is one of the ways we’re ensuring miners stay profitable well into the future. One community member, Robert, describes this function as ‘on-chain garbage collection’ that reduces the problem of blockchain bloat – and even makes it profitable.__

The 2020 block reward reduction will probably be the most important halving Bitcoin ever experiences. This is the point where the narrative of programmatic scarcity and digital gold will truly be proven, in the context of the sharpest economic downturn in living memory. In previous halvings, Bitcoin has still been in its infancy, a niche experiment. Future halvings will confirm the principle. But this one is the watershed.

Looking ahead, though, what happens in 20 or 30 years, when block rewards have fallen so far that miners have to rely on tx fees and potentially other sources of revenue? Will Bitcoin be sustainable? What will be the impact on the ecosystem?

The simple answer is that we don’t know.

Mining rewards are a key feature in maintaining the security of proof-of-work blockchains like Bitcoin and Ergo. And so, while we have deliberately kept many of Bitcoin’s tried and tested features, we have updated this one to give miners a boost when block rewards have fallen to zero.

## Lost coins

Digital scarcity is an important feature of Ergo. Like Bitcoin, ERG are designed to be a finite resource and long-term store of value. We do not agree with the principle of infinite inflation.

And yet, this has to be balanced against the needs to pay miners to secure the blockchain and process transactions. Without adequate compensation for miners, there is no viable blockchain at all. Ergo approaches this by slowly recycling lost coins, in a feature we call ‘Storage rent’. 

Studies suggest that as many as [4 million BTC may have been lost forever](https://bitcoinist.com/estimated-4-million-bitcoin-lost-forever-by-users-forgetfulness/). These are coins that were mined in the early days of Bitcoin and stored on hard drives that were subsequently thrown away or destroyed because the owners forgot about them or thought they were worthless, as well as coins in addresses for which the private keys have been lost. (And, of course, there’s Satoshi’s estimated holdings of 1 million BTC, which may never move.)

Where coins have genuinely been permanently taken out of circulation in this way, it makes sense to have a mechanism to recover them and put them back into the blockchain economy. That way, we can preserve digital scarcity without unnecessarily accelerating it. In other words, by attempting to stick to the intended algorithmic supply for any given point in time.

Ergo’s halving schedule is faster than Bitcoin’s. Block rewards start at 75 ERG, and decrease steadily after the first two years. There is no ‘long tail’ of emission, and after eight years block rewards will fall to zero. After that, total supply will be fixed. The number of ERG in existence will never be more than 97,739,925.

## Storage fees

From that point, however, miners will need further incentives to secure the network. Miners have ongoing costs in terms of bandwidth and storage, and in cases where coins are simply left for years, there is typically no charge for reflecting the value of securing them. The tx fee that is paid up-front in Bitcoin is the only charge ever made for storing those coins.

In Ergo, in addition to transaction fees, miners will also be able to collect storage rent fees on UTXOs that have not been moved for four years or more. 

Fees will be deducted slowly, over time – the unmoved UTXOs will not simply be appropriated by miners. Anyone who wants to avoid this simply needs to move their balances once every four years, which is not an onerous requirement for helping incentivise miners and avoiding the deflationary consequences of lost coins. You can read more about how fees will be levied in [this paper](https://fc18.ifca.ai/bitcoin/papers/bitcoin18-final18.pdf).

In this way, Ergo seeks to ensure a balance between maintaining digital scarcity, on the one hand, and giving miners long-term incentives to secure the blockchain, on the other – long past the point where new coins have ceased to be released.


Building Ergo: Storage rent


# Ergo GPU Mining

This article will help you start mining Ergo using a GPU. 

Ergo mining is based on [Autolykos](https://ergoplatform.org/docs/ErgoPow.pdf), a Proof-of-Work algorithm designed to be ASIC and pool resistant. Miners have to perform memory-hard computations~(at least 4 GB memory is needed, but the current most efficient implementation utilizes between 8 GB of vRAM) that makes Ergo friendly for GPU mining. In addition, Autolykos requires access to **private** keys, thereby preventing mining pool formation. As soon as a correct solution is found, the miner broadcasts the block along with the solution and is able to collect the block reward after a delay of 720 blocks using the secret he used during mining. The rest of the network verifies the solution using the miner's **public** key and this verification can be done very efficiently, requiring less than a kilobyte of memory.

## Prerequisites

In order to mine, you need the following setup:

1. A full node with wallet initialized and fully synced.
2. A computer with a GPU that is recognized by your OS.
3. Ergo mining software for your operating system. Ergo supports both AMD and NVidia GPUs. 

Ergo mining requires a configured and synchronized Ergo node and at least one GPU for mining. You may use multiple GPUs if you wish (to multiply your hashing power) but you only need one Ergo node. 

**Note that Ergo no longer works in Java 8 due to its lack of [strong cryptography](http://mail.openjdk.java.net/pipermail/security-dev/2016-October/014942.html). You must use Java >= 9** 

The links for setting up the mining software are:

* [Nvidia Miner](https://github.com/ergoplatform/cuda-miner)
* [AMD Miner](https://ergoplatform.org/blog/2019_08_07_amd/)

**!!!WARNING!!! Since Autolykos utilizes private keys, you should never use untrusted mining software. Check that the software is open-source and validated by the community**

## Sync node and Initialize Wallet

Follow the steps of setting up a node as described in [the tutorial](https://github.com/ergoplatform/ergo/wiki/Set-up-a-full-node).

Edit the config file of the node and add the following line.

``ergo.node.mining = true``

Ensure that the wallet is initialized and you are in possession of the correct mnemonic sentence.

Finally, ensure that the node is synced as described [here](https://github.com/ergoplatform/ergo/wiki/Set-up-a-full-node#check-if-the-node-is-synced).

## Configure and run the miner

On the computer where the miner will be running, create a file called `config.json` with the following content

```json
{
    "seed": "Attention!!! Replace this with your mnemonic sentence and keep it secret or you will get robbed", 
    "node": "http://192.168.1.100:9053",
    "keepPrehash": false
}
```

where:

- **seed** is the mnemonic sentence from your node's wallet obtained in the previous step.
- **node** is the URL of your node.
- **keepPrehash** is an optimization parameter. If set to `true`, the miner will consume at most 8GB of memory. If set to `false` the miner will consume at most 4GB of memory, but its performance will be for about 25% lower.

Run your miner using the command `./auto.out config.json` (for Linux) or `miner.exe config.json` (for Windows) and enjoy receiving block rewards!

Once you have received any mining rewards, you can view the balance as described [here](https://github.com/ergoplatform/ergo/wiki/Set-up-a-full-node#check-wallet-balance) and then withdraw the funds as described [here](https://github.com/ergoplatform/ergo/wiki/Set-up-a-full-node#sending-funds).


Mining Ergo for Fun and Profit


This tutorial will provide you with the information needed to get your AMD cards mining ERGO on either Windows or Linux.

Developer MH Samadani published his AMD Miner just three days after the official launch and is continuously updating it since. To keep track of his updates you can join the [Ergo Mining Telegram Channel](https://t.me/ergo_mining) and search for `#amdminer`. You can download and look into the miner [here](https://github.com/mhssamadani/ergoAMDminer).

The code is based on OpenCL and completely open source.
If you are using Nvidia cards, you can find the CUDA miner [here](https://github.com/ergoplatform/Autolykos-GPU-miner/tree/master/secp256k1).

Please, be aware that it is unsafe to use any closed source miners. 
The mining specifics of ERGO require you to disclose your secret key to the miner so make sure who to trust before exposing any vulnerable data!

These are the reported Hashrates for AMD cards: 

- rx570-8g: 22-24Mh/s
- rx580-8g: 23-25Mh/s
- rx Vega56: 24-26Mh/s

Before going any further I want to give credits to MH Samadani and his head developer [Amin Moradi](https://github.com/amin63moradi) for providing the miner and the base for this tutorial.

**Now let's get started!**

### Configuration

Copy these files into the same folder as your executable file and add your seed string and your node's address to `config.json`. In addition to that set `keepPrehash: true` in the same file.

- Miningkernel.cl
- Prehashkernel.cl
- Ocldecs.h
- Ocldefs.h
- Libcurl.dll( in windows)
- Config.json

### Requirements for Linux

#### 1. Install the AMDGPU-PRO driver by downloading the AMDGPU-PRO package for your specific Linux distribution from [amd.com](https://amd.com). Unpack this file and in a terminal window run:

```bash
$ amdgpu-pro-install --opencl=legacy,pal --headless
```

#### 2. Install OpenCL headers

```bash
$ apt install libcurl4-openssl-dev
```

#### 3. Install OpenSSL 1.02

```bash
$ apt install libssl-dev
```

### Requirements for Windows

#### 1. You need at least one AMD GPU with its driver installed [amd.com](https://amd.com)

#### 2. Download and Install AMD APK from mhssadini's github [here](http://amd-dev.wpengine.netdna-cdn.com/app-sdk/installers/APPSDKInstaller/3.0.130.135-GA/full/AMD-APP-SDKInstaller-v3.0.130.135-GA-windows-F-x64.exe)

#### 3. If not already available, build libcurl from sources with [Visual Studio toolchain instruction](https://medium.com/@chuy.max/compile-libcurl-on-windows-with-visual-studio-2017-x64-and-ssl-winssl-cff41ac7971d)

#### 4. Download and install OpenSSL 1.0.2 [here](https://slproweb.com/download/Win64OpenSSL-1_0_2s.exe)

### Building in Linux

#### 1. Edit the `ErgoOpenCL.cpp` in the master directory and comment `#define TEST` or uncomment `define TEST` to either build the miner or tester.

#### 2. Change the directory to `ergoAMDminer/Ubuntu` and run make. 

```bash
./makefile
```

#### 3. If everything was done correctly, you should now find ErgoOpenCL in `ergoAMDminer/Ubuntu/`. Go ahead and run it to start mining. 

```bash
./ErgoOpenCL
```

### Pre-Built Version for Windows

Download the [github](https://github.com/mhssamadani/ergoAMDminer), head over to the win64 folder and execute either `ErgoOpenCL_miner.exe` or `ErgoOpenCL_tester.exe`. If everything was set up correctly (see requirements and configuration) it should start mining.

### Building in Windows

Open `ErgoOpenCL.sln` Visual Studio.
Add the OpenCL, LibCurl and OpenSSL libraries.

Include directories:

![Picture 1](/img/blog/picture1.jpg)

And include additional directories:

![Picture 2](/img/blog/picture2.jpg)

Additional library directories:

![Picture 3](/img/blog/picture3.jpg)

Additional dependencies:

![Picture 4](/img/blog/picture4.jpg)

Now, in the `ErgoOpenCL.cpp` file, comment `#define TEST` to build the miner or uncomment `define TEST` to build the tester.

If you have any additional questions, suggestions, want to send flowers to `@mhs_sam` to or simply feel like joining the community, head over to our *telegram channels* - [Ergo Mining](https://t.me/ergo_mining) or [Ergo Platform](https://t.me/ergoplatform) - and say hello.

**Happy mining!**


Mining ERGO on AMD Cards

## Spending mining reward

This text is to help miners to withdraw funds mined.
 
A lot of folks launched a node and also a miner, with `pubkeyHex` from the miner embedded in the node config. Now
information on how to recognize the coins mined and withdraw them to another address. 
 
## On keys.

A miner can see a lot of keys in different formats. 

First, mining software and also mining support in the node (namely, `ergo.node.miningPubKeyHex` setting in the config) are using a `Base16-encoded` "raw" public key, which is just an encoded serialized point on elliptic curve. This key is enough for a miner (which can avoid then supporting Base58, address forming etc).

Second, a node wallet shows Pay-To-Public-Key (P2PK) addresses, which are starting with "9". P2PK adress contains not just elliptic curve point, but also network prefix and `checksum`, similarly to Bitcoin P2PK and P2PKH addresses. 

Third, there is `minig/rewardAddress` API method, which is intended for external tools generating block candidates. This API method shows something like `88dhgzEuTXaSfKEbxfa6vghvEGdBH39sn9h7As2Y2Z6SGd8bKXCXmRLY5JtU4g4RYBP4WcZWb3JwjXDK`, which is a special script to pay a miner in encoded form.

Anyway, if you put pubkeyHex from you miner into your node, everything is okay, just don't worry about different keys seen.

## Getting you balance shown & withdrawals

Probably you don't see mined coins after wallet initialization, if its done on height after blocks mined. Please note,
the node is not scanning blocks backwards, it is only scanning new blocks after the initialization. Thus in order to find mined coins, full blockchain rescan is needed atm (or, if you mine, launch another node on another machine, or on the same machine with different ports set in the config, namely, set new values to `scorex.restApi.bindAddress` and `scorex.network.bindAddress` fields; also please use version 3.0.1 as it is easier to configurate). 

## In order to spend rewards you need to follow the steps below:

### 1. Clear node state, if you're going to stop working node.

In order to clear the state of your node you need to stop the node and then remove all contents of `.ergo` directory (it could be hidden from you on Mac and Linux, try `ls -a` command in the directory you ran the node from).

### 2. Restoring a local wallet from the seed-phrase used in the Autolykos miner

Remember that mnemonic sentence you set in the `config.json` when configuring your Autolykos miner - now you need to restore build-in wallet from it. In order to restore your wallet start the node again and send a POST request to `http://[your_node_ip]:9053/wallet/restore` containing the `application/json` content-type body like:

```scala
{
  "pass": "your_wallet_pass",
  "mnemonic": "mnemonic_sentense_from_your_miner",
  "mnemonicPass": "mnemonic_pass_if_set"
}
```

, where `pass` is a new unique pass to be used to encrypt wallet data on your local disk, and `mnemonic` is a mnemonic phrase you copied from your Autolykos miner config (`config.json`). Please especially pay your attention to `mnemonicPass` field - this is a password of your mnemonic phrase, it's optional and you could have configured it when generating your mnemonic. So add this field to the request only in case your mnemonic is really protected with a pass, remove this field otherwise.

Don't forget to authorize your request setting correct `api_key` HTTP header corresponding to the `apiKeyHash` your configured in the node config file.

ATTENTION: In order to let the wallet scan all the blocks from the genesis you need to restore the wallet before your node would have started downloading full blocks (Check `fullHeight` in `/info` API method response - while it is `null` your node haven't start downloading full blocks)

### 3. Check your balance

When your node got synced with the network check `/wallet/balances` API method. The response should look like:

```scala
{
  "height": 3560,
  "balance": 67500000000,
  "assets": {}
}
```

Pay attention to the `height` field first - it should equal `fullHeight` displaying by `/info` API route. `balance` is a confirmed balance found by your wallet.

### 4. Make a transaction spending your reward

In order to withdraw a reward from your wallet, create a new payment transaction using `/wallet/payment/send` API route. In order to perform this operation send a POST request containing an `application/json` content-type body like:

```scala
{
  "address": "your_address",
  "value": 10000000
}
```

, where `address` is the address you want to move your funds to and `value` is how many nanoERGs you wish to move.



When the request is sent the node would return transation id in response. You can use [explorer](https://explorer.ergoplatform.com) to check when your transaction gets to the block.


Ergo Withdrawal

# Joining the Ergo main network at the very beginning

In order to join the network at its very beginning and compete to mine the genesis block, you need to follow the steps described below. If you're not going to participate in Ergo mining and just want to set up a full node, you need to follow steps 3 and 5.

## Preparations

### 1. Build mining software 

Check the [guide](https://github.com/ergoplatform/ergo/wiki/Mining) first.

Build a [miner](https://github.com/ergoplatform/Autolykos-GPU-miner) according to its readme instruction (for Ubuntu) or using  [Windows manual](https://ergoplatform.org/blog/2019_05_07_mining).

Try to run it like `./auto.out config.json` with test config:
```scala
{
  "mnemonic": "noise peasant subway frozen illegal pretty oak agent train valid wash title burst column yard decide move coin gas asset pretty hire happy fuel",
  "node": "http://159.203.36.162:9052",
  "keepPrehash": true
}
```
and see something like:
```scala
2019-06-27 14:44:58,626 INFO [main thread] Using 1 GPU devices
2019-06-27 14:44:58,626 INFO [main thread] Using configuration file mine162.json
2019-06-27 14:44:58,628 INFO [main thread] Block getting URL:
   http://159.203.36.162:9052/mining/candidate
2019-06-27 14:44:58,628 INFO [main thread] Solution posting URL:
   http://159.203.36.162:9052/mining/solution
2019-06-27 14:44:58,629 INFO [main thread] Generated public key:
      pk = 0x03 F5214F2F6D87C714 4A2E12F8D4C4E110 1C59FF7D9AEABC11 77C4CB50FA8497E7
2019-06-27 14:44:58,714 INFO [main thread] Got new block in main thread, block data: {
  "MSG" : "3637B40440681781F92EDC92B33E623330F05705446168952CBD3720BA922442",
  "B" : 3462030106355215694294694818737961234095984491840283822105474632310,
  "PK" : "03F5214F2F6D87C7144A2E12F8D4C4E1101C59FF7D9AEABC1177C4CB50FA8497E7"
}
2019-06-27 14:44:58,956 INFO [GPU 0 miner] GPU 0 allocating memory
2019-06-27 14:44:58,964 INFO [GPU 0 miner] Preparing unfinalized hashes on GPU 0
2019-06-27 14:45:13,443 INFO [GPU 0 miner] GPU 0 read new block data
2019-06-27 14:48:02,298 INFO [main thread] Average hashrates: GPU0 24.8537 MH/s Total 24.8537 MH/s 
```
The above notifications show that your miner is built correctly.

### 2. Generate mnemonic phrase for mining 

Run `./auto.out -G` to generate a new mnemonic phrase if you don't have one. 

```scala
$ ./auto.out -G
2019-06-28 12:08:32,915 INFO [main thread] !!!Generated new mnemonic, put it in your config.json file!!!
job great stage urge elite purity surprise any cram matrix typical table panel honey curious enlist fault matrix
!!!Generated new mnemonic, put it in your config.json file!!!
2019-06-28 12:08:32,918 INFO [main thread] Generated public key:
      pk = 0x03 61F8098779E5EC8C 2A851E3EF57C471E 9A6803F60666E93E EB0BDD67411439D0
```

In the example above your generated mnemonic phrase is `job great stage urge elite purity surprise any cram matrix typical table panel honey curious enlist fault matrix` while your public key is `0361F8098779E5EC8C2A851E3EF57C471E9A6803F60666E93EEB0BDD67411439D0`.
Save your mnemonic phrase (e.g. by writing down to a piece of paper) and keep it in secret at all times, anyone who have access to it will be able to steal your funds. Write down your public key, you will need it in the next steps.

### 3. Configure and start your miner

Create a `settings.json` config file with the following content (don't forget to replace sections in `<>` braces):
```scala
{
  "mnemonic": "<mnemonic generated at step 2>",
  "node": "http://<ip address of your node>:9053",
  "keepPrehash": true
}
```

and run a miner like `./auto.out settings.json`. It should initialize and start requesting a node for the block candidate. 
```scala
2019-06-27 15:14:02,267 INFO [main thread] Using 1 GPU devices
2019-06-27 15:14:02,267 INFO [main thread] Using configuration file mainnet-conf.json
2019-06-27 15:14:02,269 INFO [main thread] Block getting URL:
   http://<ip address of your node>:9053/mining/candidate
2019-06-27 15:14:02,269 INFO [main thread] Solution posting URL:
   http://<ip address of your node>:9053/mining/solution
2019-06-27 15:14:02,269 INFO [main thread] Generated public key:
      pk = 0x02 F611D5F6AAB70C05 4A530C6420395B3C 4521642DC7125A93 49AAA2D9BB89D7AF
2019-06-28 12:21:36,035 ERROR [main thread] CURL: Couldn't connect to server
2019-06-28 12:21:36,835 INFO [main thread] Waiting for block data to be published by node...
2019-06-28 12:21:36,876 ERROR [main thread] CURL: Couldn't connect to server
2019-06-28 12:21:37,676 INFO [main thread] Waiting for block data to be published by node...
2019-06-28 12:21:37,718 ERROR [main thread] CURL: Couldn't connect to server
```

No more actions are required with the miner.


### 4. Configure and run your full node

Check [guide](https://github.com/ergoplatform/ergo/wiki/Set-up-a-full-node) first.

Create a `settings.conf` config file with the following content (don't forget to replace sections in `<>` braces):
```scala
ergo {
  node {
    mining = true
    miningPubKeyHex = "<your public key from step 2>"
  }
  chain {
    initialDifficultyHex="011765000000"
  }
}

scorex {
  network {
    nodeName = "<some name to identify your node>"
  }
  restApi {
    # you may wish to configure an apiKeyHash to use your wallet. Check https://ergoplatform.org/blog/2019_06_04_wallet-documentation/ for wallet documentation.
    apiKeyHash = "1111"
  }
}
```

Download the latest mainnet release from [here](https://github.com/ergoplatform/ergo/releases/tag/v3.0.1) and run it like `nohup java -jar -Xmx3G -Dlogback.stdout.level=DEBUG ergo-3.0.1.jar --mainnet -c settings.conf` and you if you see similar to the below:
```scala
17:02:11.449 INFO  [main] o.e.settings.ErgoSettings$ - Running in mainnet network mode
17:02:12.262 INFO  [main] org.ergoplatform.ErgoApp - Entering coordinated network bootstrap procedure ..
17:02:12.933 INFO  [main] o.e.BootstrapController - Wrong response format, retrying in 10s
17:02:22.933 INFO  [main] o.e.BootstrapController - Wrong response format, retrying in 10s
```
You node is already configured correctly and no more action is required with it.


### 5. Wait for the mainnet launch

After these steps you're ready to participate in Ergo mining and should just wait. Your miner is waiting for block candidate from your node, while your node is waiting for the proof-of-no-premine that will be broadcasted by the Ergo Development Team according to the main network launch schedule.  The proof‐of‐no‐premine will contain headlines from the media (The Guardian, Vedomosti, Xinhua), as well as the latest block identifiers from Bitcoin and Ethereum. When the launch time comes, we'll distribute the no-premine proof and the mining will start.

To ensure that your node is mining, you may check your node log. It should stop to write logs from `BootstrapController` and write `Boot settings received. Starting the node`, so the logs file will looks like:
```scala
17:21:39.417 INFO  [main] o.e.BootstrapController - Wrong response format, retrying in 10s
17:21:49.437 INFO  [main] o.e.BootstrapController - Wrong response format, retrying in 10s
17:21:59.500 INFO  [main] org.ergoplatform.ErgoApp - Boot settings received. Starting the node ..
17:21:59.554 INFO  [ctor.default-dispatcher-3] s.c.n.NetworkController - Declared address: None
17:21:59.558 INFO  [ctor.default-dispatcher-3] s.c.n.NetworkController - Registering handlers for List((1,GetPeers message), (2,Peers message))
17:21:59.559 INFO  [ctor.default-dispatcher-3] s.c.n.NetworkController - Successfully bound to the port 9030
17:21:59.565 INFO  [ctor.default-dispatcher-4] o.e.n.state.ErgoState$ - Generating genesis UTXO state
17:21:59.568 INFO  [ctor.default-dispatcher-2] o.e.local.ErgoMiner - Trying to use key from wallet for mining
17:21:59.583 INFO  [ctor.default-dispatcher-3] s.c.u.NetworkTimeProvider - New offset adjusted: 2
17:21:59.585 WARN  [ctor.default-dispatcher-3] o.e.n.ErgoReadersHolder - Got GetReaders request in state (None,None,None,None)
17:21:59.598 INFO  [ctor.default-dispatcher-2] s.c.n.NetworkController - Registering handlers for List((55,Inv), (22,RequestModifier), (33,Modifier), (65,Sync))
17:21:59.729 INFO  [ctor.default-dispatcher-4] s.c.a.a.b.VersionedIODBAVLStorage - Update storage to version ByteArrayWrapper[6813BCA7232C6E156FB6229ECF165D157640A8576A5B320506E4C1B66011253402]: 14 elements to insert, 1 elements to remove
17:21:59.846 INFO  [ctor.default-dispatcher-4] o.e.n.state.ErgoState$ - Genesis UTXO state generated with hex digest 6813bca7232c6e156fb6229ecf165d157640a8576a5b320506e4c1b66011253402
```
At the same time your miner should write you something like:
```scala
2019-06-28 12:21:36,035 ERROR [main thread] CURL: Couldn't connect to server
2019-06-28 12:21:36,835 INFO [main thread] Waiting for block data to be published by node...
2019-06-28 12:21:36,876 ERROR [main thread] CURL: Couldn't connect to server
2019-06-28 12:21:37,676 INFO [main thread] Waiting for block data to be published by node...
2019-06-27 15:26:20,328 INFO [main thread] Got new block in main thread, block data: {
  "MSG" : "0777078E22BB64C771DE8A8D3B1E454847A91024D98AB86949091C8019FA7453",
  "B" : 964934076977634961863091541739065898773646368992290869855043026179318012,
  "PK" : "02F611D5F6AAB70C054A530C6420395B3C4521642DC7125A9349AAA2D9BB89D7AF"
}
2019-06-27 14:44:58,956 INFO [GPU 0 miner] GPU 0 allocating memory
2019-06-27 14:44:58,964 INFO [GPU 0 miner] Preparing unfinalized hashes on GPU 0
2019-06-27 14:45:13,443 INFO [GPU 0 miner] GPU 0 read new block data
2019-06-27 14:48:02,298 INFO [main thread] Average hashrates: GPU0 24.8537 MH/s Total 24.8537 MH/s 
2019-06-27 15:27:11,033 INFO [GPU 0 miner] GPU 0 found and trying to POST a solution:
```


Joining the Ergo main network at the very beginning


## Step 1: Tools

[Visual Studio](https://visualstudio.microsoft.com/downloads/)  
Choose free community version, you will need to select desktop development with C++ package during install.

[CUDA toolkit](https://developer.nvidia.com/cuda-downloads)    
Choose your system version, install with default options, it will update your graphics driver to a compatible version.

[Curl](https://curl.haxx.se/latest.cgi?curl=win64-nossl)   
Generic version without SSL, binary won`t work. Choose generic source, zip and click on show mirrors. Download and unpack.

[OpenSSL 1.0.2](https://slproweb.com/download/Win64OpenSSL-1_0_2s.exe)  
Download and install, select the OpenSSL binaries (/bin) directory during install.

[Autolykos GPU miner](https://github.com/ergoplatform/Autolykos-GPU-miner)  
Click on clone or download and download zip and unpack.

## Step 2: Building libcurl

Open the command line, go to ``c:\Program Files (x86)\Microsoft Visual Studio\2017\Community\vc\Auxiliary\Build\`` and run this script: ``vcvarsall.bat x64``

Open the command line, go to unpacked Curl directory, then cd winbuild and run this command: ``nmake /f Makefile.vc mode=dll MACHINE=x64``

After a successful build, go to Curl directory, ``\curl\builds\libcurl-vc-x64-release-dll-ipv6-sspi-winssl\bin`` and copy ``libcurl.dll`` to ``\Autolykos\secp256k1`` directory. 

## Step 3: Building miner

Open the command line, go to ``c:\Program Files (x86)\Microsoft Visual Studio\2017\Community\vc\Auxiliary\Build\`` and run this script: ``vcvars64.bat``

Open command line and go to unpacked Autolykos GPU miner directory, then cd ``secp256k1`` and edit ``winbuild.cmd`` file, change ``OPENSSL_DIR, LIBCURL_DIR`` to your OpenSSL and Curl main directories. You can change ``CUDA_COMPUTE_ARCH`` to GPU code architecture you want.

Run ``winbuild.cmd`` and build your miner. After succesful build you should discover miner.exe in the same directory.

## Step 4: Mining

Before you can mine, you have to [configure your node](https://github.com/ergoplatform/ergo/wiki/Set-up-a-full-node), [wallet](https://ergoplatform.org/blog/2019_06_04_wallet-documentation/) and [miner](https://github.com/ergoplatform/ergo/wiki/Mining)

After your node is synced, wallet is configured and unlocked, you have to create mining configuration file ``config.json`` with following structure: ``{ "seed" : "YourSeedString", "node" : "https://127.0.0.1:9052", "keepPrehash" : true }`` in the ``\Autolykos\secp256k1`` directory.

Open the command line and go to ``\Autolykos\secp256k1`` directory. Run ``miner.exe config.json``
