How much time to have blockchain synced?

I am wondering if there's a command to predict / calculate how much time does bitmonerod.exe still need for a blockchain fully synced.

This is basically impossible to calculate. Syncing speed depends on a variety of factors, such as type of hard drive (SSD or HDD), computer specifications (old computer versus relatively new computer), and bandwidth.

On a decent computer with an SSD it will take about 1-2 hours. On a decent computer with an HDD it will already take 6-8 hours. If you have a relatively old computer it might take 12 hours to several days even.


My name contains a special (non-ASCII) character (e.g. é, ø, â, Ö) and I can't create a wallet with the GUI

Let's start with explaining in detail why this happens. This issue is basically the result of two bugs and is Windows specific. First, upon creating a new wallet, the GUI creates a temporary wallet file in C:\Users\<username>\AppData\Local\Temp\. It'll use this temporary directory regardless of the directory specified for the wallet. Therefore, even if you specified a different directory, the GUI will be unable to create a wallet because it can't store the temporary file. Second, the GUI only supports UTF-8 input strings for the wallet path and therefore is unable to create a wallet file that contains special characters. Likewise, it'll be unable to load a wallet file that is stored in a directory whose path contains a special character.

Fortunately, however, there is a quick workaround that allows you to create a wallet and use the GUI. Perform the following steps:

Browse to the directory monero-wallet-gui.exe is located.
Open monero-wallet-cli.exe by double clicking on it.
Enter a new wallet name + password. It'll also give you the 25 word mnemonic seed, make sure to note it down, i.e., make a back up of it.
After creating the wallet, exit monero-wallet-cli by typing exit
Open monero-wallet-gui.exe
On the second page of the wizard (first page is the language selection), choose Open a wallet from file
Now browse to the same directory as monero-wallet-gui / monero-wallet-cli. There should be a <wallet-name>.keys file (this is the wallet you just created with monero-wallet-cli). Select it.

You should now be able to use the GUI :)


I am using the GUI and my daemon doesn't start anymore

First of all, this is likely caused by your blockchain being corrupt. A blockchain can corrupt if you shut down the daemon ungracefully (e.g. a hard shut down or your PC going into sleep mode while you were syncing). As a general piece of advice, if you need to shut down your PC, first shut down monerod gracefully by typing exit (if you're running monerod separately) or click on the x (right top) if you're running monerod from within the GUI. Otherwise, you might corrupt the blockchain and you'd have to start all over again.

Now, let's verify that your blockchain is really corrupt so that you don't unnecessarily have to start all over again. This is done as follows.

[1] Exit the GUI.

[2] Browse to the directory monerod is located. On Windows and Linux this is the same directory as monero-wallet-gui, whereas on Mac OS X monerod is located in ~/Applications/monero-wallet-gui.app/Contents/MacOS | Note that if you cannot find monerod, it could be that your AV (AntiVirus) has quarantined it. In case this occurred, I'd advise to either put it back in the original folder / directory and create an exception or re-extract the binaries (the .zip file (Windows) or the tar.bz2 file (Mac OS X and Linux)) to a new folder / directory (for which an exception is created).

[3] Open monerod manually by double clicking on it (Windows and Mac OS X) or from the terminal with ./monerod (Linux).

[4] It'll likely shut down itself quickly. If that happens, proceed with the guide.

[5] If it doesn't shut down itself, type status a few times to check whether it's fetching any new blocks. If it isn't, proceed with the guide. It it fetches new blocks, however, it's not corrupted and the GUI was simply unable to start the daemon. Try restarting monero-wallet-gui. It should automatically connect to the daemon that's already running.

[6] Browse to C:\ProgramData\bitmonero (Windows) or ~/.bitmonero (Linux and Mac OS X).

[7] Note that, by default, both C:\ProgramData\bitmonero and ~/.bitmonero are hidden directories.

[8a] On Windows, you have to use the explorer to manually navigate to C:\ProgramData\bitmonero

[8b] On Mac OS X, you can typically use cmd+shift+. to unhide directories.

[8c] On Linux, you can typically use ctrl+H to unhide directories.

[9] Now open bitmonero.log

[10] If your log contains this line or something similar, the blockchain is corrupted:

  Failed to query m_blocks: MDB_BAD_TXN: Transaction must abort, has a child, or is invalid

[11] We'll first attempt to fix this before performing a resync from scratch.

[12] Again browse to the directory monerod is located.

[13a] On Windows, open a new command prompt from the same directory as monerod.exe. This is done by first making sure your cursor isn't located on any of the files and subsequently doing SHIFT + right click. It will give you an option to "Open command window here". If you're using Windows 10, it'll, most likely, give you an option to open the Powershell.

[13b] On Linux and Mac OS X, open a new terminal from the same directory as monerod

[14a] On Windows, type the following command in the command prompt:

monerod.exe --db-salvage

If that doesn't work in the Powershell, type:

.\monerod.exe --db-salvage

If that doesn't work either in the Powershell, type:

./monerod.exe --db-salvage

[14b] On Linux and Mac OS X, type the following command in the terminal:

./monerod --db-salvage

[15] If you were using a non-default directory for the blockchain, you have to add the --data-dir flag too if you start monerod separately. If you already have monerod running, type exit first to gracefully stop the daemon. This is done as follows:

On Windows, type the following command in the command prompt:

monerod.exe --db-salvage --data-dir path\to\your\blockchain

If that doesn't work in the Powershell, type:

.\monerod.exe --db-salvage --data-dir path\to\your\blockchain

If that doesn't work either in the Powershell, type:

./monerod.exe --db-salvage --data-dir path\to\your\blockchain

On Linux and Mac OS X, type the following command in the terminal:

./monerod --db-salvage --data-dir path/to/your/blockchain

[16] If that doesn't work you, unfortunately, have to resync from scratch. This is done by deleting data.mdb from C:\ProgramData\bitmonero or ~/.bitmonero (Linux and Mac OS X), which will trigger the resync.


Should I keep monerod instances active on mining rigs?

Generally, 1 Monerod instance per internet IP address, physical location, or operator is adequate to enhance network decentralization.


Is it possible to send from integrated to standard address?

Yes, of course. You simply send from the wallet you created the integrated address. This is because funds aren't technically sent from an address, they are set from a wallet that previously received funds.

  ...the site i want to send from uses a 64-bit integrated address

Integrated addresses are not 64-bit. An integrated address is just a standard address with an encrypted 64-bit payment ID embedded in it. This is why integrated addresses are longer than normal addresses.


TAILS - GUI v0.12 does not connect to the daemon (monerod) that is already running

This particular issue should be resolved GUI v0.13.

This issue is currently being investigated. There is, fortunately, a quick and easy workaround, which is starting GUI v0.12 with ./start-gui.sh. That is:

Browse to the directory monero-wallet-gui is located.
Open a new terminal.
Execute -> ./start-gui.sh

It should now connect to the daemon (monerod) that is already running in a separate terminal.


Quoting smooth, who is a member of the Monero core team and stepped in as Aeon lead developer a while ago:

AEON is certainly targeting running a node on a smartphone, but I don't think it is possible to completely rule out Monero (someday) doing that too.
As answered above by others the idea is to do experimental and perhaps even stupid things. Some of them may be adopted by Monero in time, others may not.
Also, as I said earlier in Monero's history when the clones were first appearing, what makes a coin stronger is defeating clones. (I reject the idea of expecting to stop cloning by trash talking clones or cloning, as Adam for example tries to do.) Every coin so defeated serves as credible evidence that the community, process, and technology of the original is sufficiently fit.
So you can think of AEON as a sparring partner to keep Monero healthy and strong. :)

Source: https://www.reddit.com/r/Monero/comments/3f28bk/whats_the_deal_with_aeon_coin_serious/


Does it make sense to mine Monero if I have free electricity?

How much you might generate in XMR will very much depend on how powerful the computer is you plan on buying. For example, a RaspberryPi probably wont earn you much at all, but a multi-socket EPYC server is another thing entirely. Of course, how much electricity these use is also very different, therefore you should probably double check with the electricity bill payer before investing in a machine that is going to consume more electricity than a typical home PC does.


How do i statically build Wolfs cpuminer-multi?

Here are well written instructions for a static compilation of cpuminer:

https://lxadm.com/Static_compilation_of_cpuminer


How can I sync the blockchain from scratch, gently in the background?

I know it's going to take days to fully sync (I have an HDD), but is there a way I can sync from scratch in the background and keep my computer usable in the meantime?

You could maybe try setting --max-concurrency=1 --prep-blocks-threads=1 which will limit the threads used. Of course, this will slow down your full sync.

You could also try these settings in combination with first downloading the raw blockchain outside of monerod and then importing. See instructions here. That way you are simply downloading a ~70G file before even processing (importing), it to the daemon. Downloading a file shouldn't slow the rest of your machine down. The bit that does the resource intensive work is the importing, and if you use flags like above, you will be limiting the resources made available to monerod at the expense of it taking longer to process.

  Will changing the block sync size or setting a bandwidth limit help?

I don't think changing the bandwidth settings is the best way to go here. You'd be throttling your bandwidth usage as opposed to the resources being used by your system to process the downloaded data. Sure, you'd end up spending longer downloading as opposed to processing, but when you are processing, it's going to zap the same amount of system resources that you are currently seeing.


How to setup own remote Monero node with maximum security / anonymity?

The major issue here would be that even though you're using Tails, all your connections end up at your home address which itself doesn't hide your IP.

You are correctly hiding your connection to your node but as this one is in your home and only used by you, it will "imply" a connection with yourself. To successfully anonymise the node it should be ran on a remote server which can't be linked to you by at least not "leaking" your private IP to the net.

In this paranoid situation, having a single transaction pushed to the network from a node used by only you and linkable by IP can imply (but not prove) this came from you. With your current setup I would connect from the Tails computer to a public remote node to be fully anonymised.


Fastest way to sync and start using Monero GUI wallet?

I followed the instructions provided here to download the raw blockchain and import it. The raw blockchain is somewhere around 4GB, and the import process for me took a couple of hours or so.

You'll need to be somewhat familiar with using the command line and installing packages using Homebrew, because you may need to install additional packages (such as wget) if you haven't already. I was somewhat familiar with using the command line and got stuck a couple of times, but was able to Google my way through it pretty easily whenever an error came up.

Note that these instructions include the process needed to set up a wallet in the command line, so if you've already got a wallet you won't need to do that.

If you need instructions on how to create a wallet in the GUI you can go here.


Can I restore my wallet with the mnemonic seed even if the seed words are changed in the future?

Yes, you can always use a historical wallet that matches the wallet from the time you created your seed. You would then need to determine what the new wallet expects. Because the seeds are depended on by users, it would likely be easy to upgrade, and hopefully a wallet version or two would be backwards compatible.

I don't know of any plans to change the seed words for the time being.


When is monero "unlocked balance" updated?

This looks like a dublicate from here.

You would need to wait 10 blocks, or about 20 minutues until your wallet shows the coins as balance and not as unlocked.


Monero does not implement SSL in the RPC but it's super simple to enable if you really want to open up a remote node with encrypted communication.

Some options are:

Connect via an SSH tunnel
Proxy an SSL enabled Apache/Nginx vhost
Use stunnel


Internet access lost due to DNS problems every time monerod starts

You might want to try adding --no-igd and see if that helps.

Another thing to try is to run with the environment variable DNS_PUBLIC=tcp.

In any case, it looks like a bug in your router.


Where to find my private key on monero gui?

Under Settings tab, click on the Show seed & keys button at the top. And watch your back - as it will show the seed and all the keys, you don't want someone seeing / recording this from behind your back.


I am new to crypto currency mining, from where I can get Monero wallet?

Download for your platform from https://getmonero.org/downloads/


install latest go from https://golang.org/dl/

create home/go/scr Add /usr/local/go/bin to the PATH environment variable. You can do this by adding this line to your /etc/profile (for a system-wide installation) or $HOME/.profile:

export PATH=$PATH:/usr/local/go/bin

create home/go/scr

follow https://github.com/sammy007/monero-stratum until error then

edit monero-stratum/hashing/src/hashing.c to looklike this

#include "crypto/hash-ops.h"

void cryptonight_hash(const char* input, char* output, uint32_t len) {
    const int variant = input[0] >= 7 ? input[0] - 6 : 0;
    cn_slow_hash(input, len, output);
}

void cryptonight_fast_hash(const char* input, char* output, uint32_t len) {
    cn_fast_hash(input, len, output);
}

then

cmake .

then

make


Typical passwords specified by endusers are used by Monerujo to unlock native monero-wallet-cli chacha8 encrypted files. I've not examined Monerujo CrAzYpass functionality that might be integrated with 2 factor authentication such as fingerprints. Unclear if CrAzYpass-enabled password files are portable to other devices.

Monerujo can use the very same wallet files the monero-wallet-cli uses. The Android File Transfer application allows wallet files to be transferred to or from Android devices to an external host supporting monero-wallet-cli.

Beside enabling an end user to specify a server name and port number, the Monerujo application allows an enhanced username:password@server_adddress:port syntax to be applid when connecting to a monerod server.  Both the monero-wallet-cli and iOS Cake Wallet clients also support this same functionality for establishing server connections. However, I do prefer not having to drill down so many levels in the Cake Wallet to specify a specific server.

Related Command Line Interface Information:

Server Syntax:  monerod --confirm-external-bind --rpc-bind-ip  address --rpc-bind-port port --rpc-login username:password

% monerod --confirm-external-bind --rpc-bind-ip 192.168.200.100 --rpc-bind-port 18081 --rpc-login test:123

Client Syntax: monero-wallet-cli --daemon-address address:port --daemon-login username:password

% monero-wallet-cli --daemon-address 192.168.200.100:18081 --daemon-login test:123


Would a fixed ring size improve anonymity?

There are several people close to the Monero project that would tentatively agree with you that a fixed ring size would improve anonymity.

As you point out, if you use a non-default ring size, your transaction will stand out.

Even if you were to use a random ring size each time, you'll be one of a small number of people that are not using the default ring size each time, so you'll stand out.

If the ring size does become fixed, then the way to increase anonymity beyond the fixed ring size would be to use a 'churn' transaction. This means you'd send the funds to yourself first, and then send the funds to the intended recipient. If the fixed ring size is 10, and you churn twice prior to sending the funds, your anonymity set would increase to 10^3 = 1000.

There are limitations to churning. For example, it is important to ensure that churns are not obvious on the blockchain. If it is rare to see a chain of outputs being spent 3 times in quick succession on the blockchain, then your churn will stand out.

More research therefore needs to be done by the Monero Research Lab to determine the effectiveness of different techniques to increase anonymity before any changes are made to fix the ring size or to recommend any particular anonymity techniques such as 'churning'.


Are there plans to optimize bandwidth usage by implementing something like xthin or compact blocks?

Yes, absolutely! Compact blocks is about the most sane scheme we've seen, and we'll likely implement something exactly like that.

For those that don't know how it works, the basic idea is that your node has likely already received most of the transactions in a newly mined block. So instead of receiving them all over again, a node will send the block header and a list of the transaction hashes in that block, and then your node can just ask for any transactions that it doesn't have.

This massively reduces bandwidth (in a hypothetical future where we have lots of transactions per block), but doesn't do anything to speed-up syncing from scratch or catching up to the rest of the network.


You can see the emission curve here:
https://i.imgur.com/Q9aHNIi.png

It's essentially the same exponential decay as Monero, but stretched out over 50 years or so rather than 7 or 8 years for Monero. Also note that there is no tail emission.

It is calculated from the source code. You can get the function here:  https://github.com/wownero/wownero/blob/4c6c7ab87b2a56165f400f6e49f17b9577a2bcad/src/cryptonote_basic/cryptonote_basic_impl.cpp#L84  and you can get the params to plug into the function in here: https://github.com/wownero/wownero/blob/master/src/cryptonote_config.h


Is there any reason not to upgrade Ubuntu when new updates are available?

I see no correlation or problem with upgrading your OS as related to Monero and I can think of no reason why the upgrade would create any problems for your Monero. As you have your mnemonic backed up, you are safe either way.

However, I hope you have taken time to set your "privacy" settings on Ubuntu. Contrary to other Linux distros, there is a little bit of anti privacy behavior. Nowhere near the massive privacy invasions of Microsoft and Apple, but there is some in Ubuntu also.


How can we be sure that monero wallet addresses are unique?

The question should be answered here:
Monero private key collision

TL;DR: There are 2^256 possible private spend keys, which would take 3.67×10^66 years to generate all of them at a rate of 1000 per second.

So while it is theoretically possible to have someone else generate the same key, as long as there is a large enough entropy pool for the random generation, you should be fine.


How can I create a million blocks in regtest or testnet?

Creating a private testnet and setting the difficulty very low is an easy way. You can start your testnet nodes passing the flag --fixed-difficulty N (where N is a very low number), so your mining node mines blocks near instantly.

There is also a new RPC command generateblocks, that can generate a bunch of blocks in regtest mode. It's currently not documented, but see the commit message. To use it, you would start monerod with the --regtest flag and the --fixed-difficulty flag (as detailed above). Then you can call the RPC interface passing the parameters: amount_of_blocks and wallet_address. For example:

curl -X POST http://127.0.0.1:18081/json_rpc -d
  '{"jsonrpc":"2.0","id":"0","method":"generateblocks","params":{
  "wallet_address":"44GBHzv...","amount_of_blocks":1000000}}'
  -H 'Content-Type: application/json'


How would someone premine a direct fork of monero ( can it be done )

It should be easy to emit all the coins in the first block:

Look for get_block_reward in cryptonote_basic_impl.cpp. You see how you're given the number of already generated coins. For the first block, it will be zero. In that case, you can return a large amount. For the second block, that value will be equal to the first block's reward. You can then return 0 if the number of already generated coins is not 0.

Note that there might be other bits and bobs needing some updating, mostly in tests.


Can a 95-character Monero address be reduced to a mnemonic phrase?

It's an interesting idea, and yes it would be possible to do. All you'd have to do is define some convention to make the conversion and have it coded. Then, if people like it, it could stick around and start to be used widely.

Personally, I wouldn't use it, as the string of words would be much longer than the base58 one. Consider a bigger dictionary than the one used for wallet mnemonics, say 8000 words. You'd need 30 words from that dictionary to encode it!
(106^58 = 30^8000)

With 70000 word dictionary you'd need 24 words. But that big of a dictionary comes with other problems like probably many similar words, which would again increase the chance of error.
With the 1626 word dictionary currently used for mnemonics, you'd need 37 words!


How to generate mnemonics from a random number?

The source is the only documentation I'm aware of for this. See bytes_to_words in electrum-words.cpp. Every 4 bytes of the number (which is just taken as a byte array), converts to 3 words:

    w[0] = SWAP32LE(*(const uint32_t*)(src + (i * 4)));

    w[1] = w[0] % word_list_length;
    w[2] = ((w[0] / word_list_length) + w[1]) % word_list_length;
    w[3] = (((w[0] / word_list_length) / word_list_length) + w[2]) % word_list_length;

Where w[1], w[2] and w[3] are indexes to words in the selected language word_list.


How to make a debug build of monero on mac os x?

I would recommend following the instructions to build from source (not using the  brew package). https://github.com/monero-project/monero#compiling-monero-from-source.

Once you have the dependencies installed you just make debug in the cloned repository directory.


When the seller initiates the transaction, the transaction will be broadcast and relayed to all Monero nodes immediately. All well connected Monero nodes should see the transaction in just a few seconds.

Depending on your specific wallet software, you may see an immediate notification that payment has been initiated to your wallet. You will see the full details of the payment, including the amount.

If you were to accept the payment at this point, there is a risk the seller may attempt a double-spend. This means the seller could announce a competing transaction which spends the funds back to the seller's own account. If the amount is small and the seller has a reputation to uphold, this is unlikely. But it is possible. Your risk here is similar to accepting a $20 bill from someone without taking the time to verify that it is counterfeit. Someone in a dark alley is more likely to attempt to defraud you than a shop keeper whom you can easily confront later.

If you want to be safe, you'll want to wait until the transaction gets mined into the blockchain.

Monero blocks are mined every 2 minutes, on average. Therefore, you will have to first wait an average of 1 minute before any block currently being mined has finished being mined. Then, you'll have to wait on average 2 minutes before your transaction gets mined into the next block.

If the network is busy and the seller's transaction did not have a high enough transaction fee to make it into the next block, you will have to wait until the network gets less busy. Therefore it's a good idea to wait for the transaction to be mined into a block, so you can be sure the fee paid was high enough for this to happen.

At this point, for the seller to defraud you, they would have to run a set of competing miners that would outcompete all existing Monero miners. The objective would be to create an alternate blockchain that ignores the transaction you had originally seen as mined, and replaces it with a transaction that spends the funds back to the seller. This is very expensive, and gets more expensive with the number of blocks in a row that the seller is attempting to outcompete.

It makes no sense for the seller to spend the vast amount of money required to attempt this attack if the amount of cash the seller is accepting from you is small.

At the time of writing, www.crypto51.app reports that it would cost approx $17k per hour to attempt to outmine all existing Monero miners.

Therefore, if you were to wait around with the seller for an hour after the transaction was made, it would make no sense for the seller to defraud you if there was less than $17k at stake.

In summary, if the seller is reputable and honorable, you probably want to wait for the transaction to appear in the blockchain for the first time (a wait of approx. 3 minutes on average). If they're very honorable, just the instant confirmation will be enough for you, because you can approach them later if anything goes wrong and ask them to re-initiate the transaction.

If they're not trustworthy, then you should wait until the cost of a 51% attack is likely to exceed the amount the seller can defraud you for.


To accept only a specific hash type at the proxy is pretty simple.

The miner is returning a hash and nonce for the job that was given to it. Therefore, at the proxy, you just set the nonce in the job blob, hash it (with the algorithm you are interested in), then compare the result hash to what the miner submitted. If they match, it's a hash for the algorithm you wanted.


How can I convert a blackball LMDB database into a wallet-readable format?

You will need to follow these steps to convert the database to a list of outputs that the wallet can read. I have performed this conversion on Debian/Ubuntu.

In order to extract the data, you need to build the LMDB tools. Follow the instructions on GitHub to make the LMDB binaries.

cd ~/monero/external/db_drivers/liblmdb

make

Then run the following:

./mdb_stat -a /folder/with/blackball/database

This will show the hash of the database that you have created. Take a note of the database name (eg: blackballs-418015bb9ae982a1975da7d79277c2705727a56894ba0fb246adaabb1f4632e3). You will use it in the next step.

You now need to extract the outputs that need to be blackballed. Use one of the following:

./mdb_dump -s blackballs-<hash> /folder/with/blackball/database/ | awk '/[0-9a-f]{64}/{print $1}' > /output/path/file.txt

./mdb_dump -s blackballs-<hash> /folder/with/blackball/database/ | grep ^.................................................................$ | tr -d \  > /output/path/file.txt

The resulting .txt file can be imported into the official GUI and CLI.


Does using a remote node provide risks to anonymity?

Yes, this is not recommended.

There are several ways using a remote node may impact privacy. They can be separated in two categories: passive attacks and active attacks.

Passive attacks involve just recording what's happening. This can be done by the node owner (if it's not you) or routers on the way, since the daemon connection is unencrypted. While secret keys are never transmitted betwen wallet and daemon, you can still glean some information, such as when you are sending a new transaction, or the last time you had synced your wallet.

Active attacks involve tampering with the connection. By sending invalid data, the daemon can in some cases make the wallet error out sending a transaction, and if the user decides to retry, new ring siblings will be requested, allowing the daemon to deduce the true output.

There are variations of these, and this is one of the reasons why you should run your own node, similarly to why you shouldn't connect to Tor through a remote Tor server, etc. Besides, running your own node adds to the network's decentralization.


Can't generate new wallet using Ledger Nano S on Mac OS 10.13

I have written a more descriptive guide to this part of the system configuration

After some help from IRC (thanks selsta), they discovered it was my user error.

In this part of the instructions supplied by Ledger, I didn't add the 2nd string because it already existed and I didn't think I needed to duplicate it. When I did add it, it worked.

In <key>ifdVendorID</key> add the entry <string>0x2C97</string>
In <key>ifdProductID</key> add the entry <string>0x0001</string>
In <key>ifdFriendlyName</key> add the entry <string>Ledger Token</string>


How to make an integrated address based on a subaddress?

You don't. Subaddresses also solve the problem integrated addresses were designed for (allowing source identification in a single address). Since you can now generate a subaddress per source/client/customer, you don't need to assign a payment id anymore, so the ability to make integrated subaddresses was not added.


Does the Monero executable for Windows not have a code signing certificate?

The website URL is correct. Once you've downloaded, you can check against the supplied hash and verify the signature of the hashes list. Details on the releases page of the project (where you can also download from).

Instructions on how to verify your download can be found here.


Features and security of new GUI compared to the command line wallet

The GUI has a QR code display, and a "tracking" mode, where a merchant can setup a transaction (new payment id, a particular amount), let a customer scan the QR code, and detect when the matching payment is seen on the pool or the chain. This still needs software on the customer side which can read the QR code and automatically present a tx to send, which the GUI can't do yet.

The GUI can also start/stop the daemon, saving you a few keystrokes.

It doesn't have anything about cold wallet signing, however.


Is there any way to construct a transaction manually?

Yes, there is. It works a bit different than in Bitcoin due to Monero specifics involving scanning for outputs with the view-key and checking the spent status by using key images.

First, we assume you have a fully-synced node and fully-refreshed watch-only wallet on the hot computer. Also, we assume you have wallet software on the cold computer (don't need the node, just monero-wallet-cli).

Using watch-only wallet, command export_outputs <filename>. There will be a file with <filename> created in the working folder*.
Copy the file to the cold wallet computer.
Using cold wallet, command import_outputs <filename>*. The cold wallet now has all the outputs and can prepare a signed key image for every one of them (unless something new was received after step 1. It won't display the correct balance because it can't check the spent status of the key images, as it is offline.

--- Stop here if you only want to monitor incoming transfers and don't care to see the correct balance and when something has been spent ---

Using cold wallet, command export_key_images <filename>. There will be a file with <filename> created in the working folder*.
Copy the file to the hot wallet computer.
Using watch only wallet, command import_key_images <filename>*. The watch wallet is now aware of spent status for each output and it shows the correct balance (unless something new was received in the meantime, after step 1.

--- Stop here if you only want to monitor the balance with the watch only wallet. Goto 1. after each newly received funds. Continue for cold spending. ---

Using watch only wallet and transfer command as you would normally, prepare an unsigned transaction. The syntax is the same as if it was a full wallet, but in this case the watch wallet will automatically save the TX to the unsigned_monero_tx file* and a message Unsigned transaction(s) successfully written to file: unsigned_monero_tx will be displayed.
Copy the file to the cold wallet computer.
Using cold wallet, command sign_transfer, to sign and export the transaction. Note that the wallet will look for the file to sign in the working folder*. The signed transaction will be automatically saved to the file* signed_monero_tx and a message Transaction successfully signed to file signed_monero_tx, txid ... will be displayed.
Copy the file to the hot wallet computer.
Using the watch wallet, command submit_transfer and the transaction will be sent to the network. The signed_monero_tx file* must be located in the working folder so it can be found by the wallet. A message Money successfully sent, transaction: ... will be displayed.
Goto 1. because you need the signed key image for the change output.

*Note on folders and file locations, as it could create some confusions. The wallet will look for the files and export them to the folder from where it was started, ie where your command prompt / shell was when you called monero-wallet-cli. It may or may not be the same folder as your actual wallet files or monero-wallet-cli, depending on how you go about it.

For example, your wallet could be on some USB drive like f:\temp\, and your wallet software on c:\monero\ and your shell working folder could be c:\.

If you remain in c:\ with the shell, you could start the wallet by its full path and specify the wallet file location: c:\monero\monero-wallet-cli.exe --wallet-file f:\temp\mywallet. In this case, all the import/export stuff would be read/written to c:\ because that's still your shell's working folder.

It would be probably feel more natural to cd into the wallet folder. Do f: to change drive and then cd f:\temp\. Then, simply start the wallet from that location by its full path again: c:\monero\monero-wallet-cli.exe --wallet-file mywallet. Notice how you don't have to write the full wallet path now as you're already there with your shell. In this case, all the files mentioned above would be written or read from the same folder as the wallet files.


Where is the encrypted Monero amounts in a transaction?

The encrypted/masked amounts are stored in the tx ecdhInfo field.

If you want to view these masked amounts on an explorer:

Visit: https://xmrchain.net/tx/9adbcfa8fe9011c2451b9636d3b68312047e93ec4477bf894687fb182a93a4c2/1
Scroll to the bottom and click "Show JSON representation of tx".

If you want to view in a daemon:

print_tx 9adbcfa8fe9011c2451b9636d3b68312047e93ec4477bf894687fb182a93a4c2 +json
...
"ecdhInfo": [ {
    "amount": "5ba540ef53551f4b"                                                                                }, {
    "amount": "10779889c631fda5"
  }],


Do coinbase transactions use stealth addresses?

moneropedia

  Stealth addresses are an important part of Monero's inherent privacy. They allow and require the sender to create random one-time addresses for every transaction on behalf of the recipient.


At the moment, the releases up until now haven't been signed.
What is possible at the moment is you could clone the existing GitHub repository at https://github.com/mymonero/mymonero-app-js and build the desktop app from source. We realise this is a bit cumbersome.
That said, there will be a new version released soon with GPG-signed hashes, and all future versions will be signed in the same fashion.
Hope that helps.


Privacy implications resulting from lack of xmr.to multiple output function

Let's say it is possible to guess the exact Monero transaction on the blockchain that resulted in the corresponding Bitcoin transaction.

That would not constitute a significant privacy leak. No one can know your Monero wallet address or even which outputs you were actually spending.


My Monero have never arrived from Kraken to my Monero GUI wallet. Please help!

No need guys to answer. After an hour I wrote my question, my problem was resolved . I followed the instructions of the member dEBRUYNE and restarted twice the GUI, first without stopping the deamon and the second time with stopping deamon. I do not know if that was the solution but thank God, my XMR are showing now in my Moner wallet GUI. Yeah!


where does "my pending balance" stay until I receive my payment in mining pools?

You can think of the pending balance as merely a number on a spreadsheet. First, some details:

Pools can choose different methods to allocate the reward amongst the miners.  The most common method of allocating miner rewards is to allocate it to miners only once a block is found and is mature (about 2 hours old).

Continuing that example, every time a block is found by the pool, the reward is recorded on the blockchain as an output owned by the mining pool's address.  The mining pool owns those funds until it decides to pay miners.

The mining pool software run by the pool is, of course, tracking how many shares are submitted by each miner.  It is therefore easy for the pool to calculate the number of shares submitted by each miner as a percentage of the total shares contributed that resulted in the block being found.

Once the two hours is up and the block is mature, the mining pool will retain its stated percentage of the block reward as its fee, and then will credit all the miners' pending balance with their respective percentage of the remainder.  In this sense, the pending balance is merely a number on a spreadsheet.

To reiterate, the pool owns the Monero until it has been disbursed to miners.  Miners trust that the pool operator is honest, that the pool operator is allocating shares correctly/fairly, and that the pool operator will make payouts according to the stated schedule or threshold.  Miners, therefore, appreciate it when pool operators use open source pool software.

So, over time, miners' accounts on the "spreadsheet" are credited with their respective portion of the mining rewards the pool earned.  Once the pool's payout threshold is reached for each miner, the pool will issue payments to that miner.  Generally, a miner can expect a small delay after they have reached their threshold, since it is more economical for the pool operator to wait and send payouts to multiple miners at once, rather than one at a time.


How to generate Monero wallet without displaying keys/seed on the screen?

If you use the --non-deterministic flag to monero-wallet-cli, the seed will not be displayed, since there is no seed for these. The secret view key is displayed, but not the secret spend key. This may or may not be enough for your purposes.

If you're on Linux machine (or similar), you can also pipe it to grep, like this:

./monero-wallet-cli --generate-new-wallet somename --non-deterministic | grep --line-buffered -v ^View\ key:

Note that you will NOT see the password prompts, so you should know when it's asking for one, and enter it blind when you know it's asking for one.


MRL RingCT research in the Ledger Journal

What are the background and qualifications of those assigned to do the peer review? Do we know the identity of "reviewer A" and "reviewer C" that are cited in the open review?

As with most academic journals, the reviewers are selected by the editor(s) of the journal. Reviewers are chosen based on their qualifications as they relate to the content of the article. (For instance, you wouldn't ask a cattle farmer researcher to review an article about cryptography).

As is common in academic peer review, reviewers identities are not revealed to either the authors of the article or the readers. Ledger is actually at the forefront of publication rigor by providing open reviews.

  How many readers does the Journal have?

According to the web page, the article has been viewed 1386 times at the time I'm writing this response.

  Who was behind the decision to include Ring Confidential Transactions by Shen Noether, Adam Mackenzie, of the Monero Research Lab as the first scholarly article in the first issue of the journal?

The editor(s) of the journal. So someone in this list: http://www.ledgerjournal.org/ojs/index.php/ledger/about/editorialTeam


Is it true that ledger nano s can only store monero and one other coin?

I have Bitcoin, Ethereum, and Monero but now there's no more space. So, well, it's 3 at least.


Monero log error messages ("transaction extra has unsupported format")

This error happens when the extra field in a Monero transaction cannot be fully parsed. This may or may not be a fatal error: the transaction public key (which is needed to scan for incoming monero) is located in that field, but is usually present before such errors.

One recent cause for these errors is a slight issue in subaddress code recently pushed to master, which would add an empty list of additional tx keys where none was needed (this has since been changed). It seems likely that the transactions showing that error are sent by people using Monero software built from master with that issue.

In any case, if this is indeed what is happening, the message can be ignored as the tx public key is already extracted and scanning will proceed normally.


You cannot. It will be set when the transaction is mined.


How can I configure a node for use by Monerujo?

I imagine --restricted-rpc is part of the problem. Remove that and you should be fine.

Also, make sure your remote node is fully sync'ed and externally accessible.

Also, if you are going to use RPC login (e.g. running the daemon with --rpc-login user:pass), in Monerujo, the format of the node address needs to be user:pass@xx.xx.xx.xx:port.

Edit: latest version has these options separated.


metadata protection for Monero usage on Mobile devices

While VPN and Tor usage is much higher that I2P usage on mobile devices today that is also the case for PCs.

There is already an I2P app for Android: https://play.google.com/store/apps/details?id=net.i2p.android

I see no technical reason why Kovri could not eventually implement support for mobile devices.


Got some problem on trying to make new GUI wallet translation

I got the problem.

I compared the file content I downloaded and the file on github

there are extra sections start like this

html lang="en" class=" is-copy-enabled is-u2f-enabled"

Then I changed the way download file:

Right-click save as from raw page instead on the github file list

And it just works! Thanks !


Daemon shuts down on startup ("MDB_BAD_TXN: Transaction must abort, has a child, or is invalid" error)

2017-11-27 21:26:00.492 3056    WARN    blockchain.db.lmdb  src/blockchain_db/lmdb/db_lmdb.cpp:72   Failed to query m_blocks: MDB_BAD_TXN: Transaction must abort, has a child, or is invalid

This indicates that your blockchain is corrupted. You can first try to fix this as follows:

Windows

Browse to the directory monerod.exe is located.
Open a new command prompt. This is done by first making sure your cursor isn't located on any of the files and subsequently doing SHIFT + right click. It will give you an option to "Open command window here". If you're using Windows 10, it'll likely give you an option to open the Powershell.
Now type monerod.exe --db-salvage
If you're using the Powershell, type .\monerod.exe --db-salvage
If that doesn't work, type ./monerod.exe --db-salvage
If that doesn't work you, unfortunately, have to resync from scratch. This is done by deleting data.mdb from C:\ProgramData\bitmonero\lmdb, which will trigger the resync.
Note that C:\ProgramData\bitmonero\lmdb is a hidden directory. Thus, you have to manually use the explorer to navigate to it.

Linux and Mac OS X:

Browse to the directory monerod is located.
Open a new terminal.
Now type ./monerod --db-salvage
If that doesn't work you, unfortunately, have to resync from scratch. This is done by deleting data.mdb from ~/.bitmonero, which will trigger the resync.
Note that ~/.bitmonero is, by default, a hidden directory. On Mac OS X you can typically use cmd+shift+. to unhide directories, whereas on Linux you can typically use ctrl+H to unhide directories.

Lastly, as a general piece of advice, if you need to shut down your PC, first shut down monerod gracefully by typing exit (if you're using the CLI) or click on the x (right top) if you're using the GUI. Otherwise, you might corrupt the blockchain again and you'd have to start all over again.


Easiest way for crypto illiterate web consumers to buy Monero to spend at website

"simplest way" <- perhaps point them to purchase Monero at a big exchange like Binance or Kraken. But, for a complete novice, even that will be daunting, that's just where we're at right now on the adoption / general knowledge curve of cryptocurrencies.

The sphere of learning about cryptocurrencies is vast, so if you want people to learn, why not create resources for them.

And as a seller, you could implement your own conversion of card to Monero or use a third party integration like Globee.

It really depends what your goal is; making the purchase easy or educating.


Using sneurlax/monerojs and I'm having a problem connecting to wallet

As you are not specifying the wallet details (port, host etc), that library uses the defaults:

class walletRPC {
  constructor(hostname = '127.0.0.1', port = 28083, user = undefined, pass = undefined, protocol = 'http', network = 'mainnet') {

Therefore, you would need to have started the monero-wallet-rpc, on the same host, with something like:

monero-wallet-rpc --rpc-bind-port 28083 \
    --disable-rpc-login --wallet-file your-wallet --password your-password

Or to start without an initial wallet like:

monero-wallet-rpc --rpc-bind-port 28083 \
    --disable-rpc-login --wallet-dir /some/path


Where is the blockchain saved, in windows?

On Windows the blockchain is stored in C:\ProgramData\bitmonero\lmdb. It's a hidden folder, but if you simply copy paste aforementioned path into your Windows explorer it will go to it. The folder contains your blockchain (data.mdb).


Are [solo] mining yield calculations like dice or playing card calculations?

Yes, kind of. Your model is an idealized representation of mining, and works with one exception. The network has a certain degree of latency between nodes, and as a result miners do not know immediately when another miners finds a block, but rather have to wait something like 1-10 seconds before learning about a new block. Now, at first glance,this might not seem like a big deal because everyone has this issue. But the reality is that network latency results in bigger miners winning a slightly higher share of blocks than their hashrate would suggest, and smaller miners get less. This is due to the fact that a miner effectively gets a head start on the next block after mining a block, and bigger miners therefore get more of these headstart a, gaining a slight advantage. The smaller one's hashrate is, the more exacerbated this effect becomes. I don't know of a foolproof way of representing this effect, though. A good starting point might be to say that a small miners is only 90-95% efficient, but such a factor would have to be empirically tuned to be as accurate as possible.


The scratchpad is filled with pseudo-random data based on the state (using rounds of the AES block cipher).

Check https://cryptonote.org/cns/cns008.txt for a detailed description of the algorithm (without the modifications introduced in version 7 of the protocol).


Compile (or download binary) XMR-STAK-CPU for armv8

It's possible, at least I managed to build XMR-STAK-CPU for Apple mobile CPUs, which are ARMv8. Though SSE instructions have to emulated with NEON instructions, it works pretty performant.
Some details on the experiment are here.


Are atomic swaps possible between Monero and other altcoins or Bitcoin?

Seems like there could be a neat novel way to do it, according to MimbleWimble mailing list post by A. Poelstra.

Note that the s' values need to be re-communicated every time the transaction changes (as does the nonce). Because it depends on the other party's nonce, this might require an additional round of interaction per channel update.
Note also that nothing I've said depends at all on what's being signed. This means this works just as well for MimbleWimble as it would for Bitcoin+Schnorr as it would for Monero (with a multisig ring-CT construction) as it would for Ethereum+Schnorr. Further, it can link transactions across chains.
I'm very excited about this.
Cheers
Andrew

There's also some discussion about it here.


Is there a list/repository of online markets / vendors that accept Monero?

Yes! There is, on the official getmonero.org website:

https://getmonero.org/getting-started/merchants

The nice part about this site is that the page is hosted on github, and anyone can add a merchant to that page but submitting a pull request here:

https://github.com/monero-project/monero-site/blob/master/getting-started/merchants.md

You can look at past edits to that page if you need help with submitting an edit.


From how much hashpower one may consider starting a public mining pool?

There is no definite number here... It mostly depends on how lucky you feel ;)

If you think that you will be the only miner connected to your pool once you make it public, that will be the equivalent of solo mining then... Depends on your hash rate (and lots of luck), this might or might not be profitable for you. However, every beginning is hard, so once you make your pool public, be sure to announce it around and attract miners as soon as possible and just be patient and hope that other will connect too...


Understanding monerod blockchain sync status

First thing you should try is "save" once you get the output

  Blockchain Saved

Input "exit" and wait for it to close (if it takes more than 2 minutes type exit again, it's a slightly common glitch)

Open monerod again and see if that helps.

If not, got to C:\ProgramData (must be accessed through Run) and delete the file bitmonero, this will force you to restart the blockchain, but will clear the glitch. Start monerod and you should be good to go.


Monero GUI startup (on Linux) getting *** Error in `./monero-wallet-gui': free(): invalid pointer: 0x00007f2afd1b9c60 ***

You can resolve this issue (which is related to OpenGL) by starting the GUI as follows:
QMLSCENE_DEVICE=softwarecontext ./monero-wallet-gui
This ensures the GUI uses the Qt Quick 2D Renderer instead of relying on OpenGL. More information about the Qt Quick 2D Renderer can be found here.

Qt Quick 2D Renderer is an alternative renderer for Qt Quick 2 that uses the Raster paint engine to render the contents of the scene graph instead of OpenGL. As a result of not using OpenGL to render the scene graph, some features and optimizations are no longer available. Most Qt Quick 2 applications will run without modification though any attempts to use unsupported features will be ignored. By using the Qt Quick 2D Renderer it is now possible to run Qt Quick 2 applications on hardware and platforms that do not have OpenGL support.
Qt Quick 2D Renderer is a Qt module that contains a scene graph renderer plugin.


Development Roadmap Design and Consensus

The Monero Design and Development goals roadmap was produced by the Monero Core Team

The Core Team is an integral part of Monero Research Lab so cooperation is ongoing. For simple tasks Monero developers may act independently without requesting significant academic review. However, for more important and cryptographically complicated tasks research is undertaken before coding begins. As issues are discovered during development, prior research is updated. Monero Core Developers are given access to ongoing MRL research before it is completed of received peer review

  This research bulletin has not undergone peer review, and reflects only the results of internal investigation.

One of the goals of sharing research while still in progress is to reduce the amount of time wasted pursuing objectives with critical flaws. Although significant cooperation exists, priority levels for certain tasks change over time based on the individual skill sets and interests of each developer/researcher.


Can the size of range proofs be reduced?

They are currently 6304 bytes (per output).

This will drop in the future by at least 1024 bytes. Beyond that will change (or not) with design decisions yet to be made.


How do I change the language of the 25 word mnemonic seed in the GUI or CLI?

The GUI languages work as follows. On the first page of the wizard you can select a language. If that particular language also has a corresponding mnemonic seed word list, your mnemonic seed will be in the same language when you create a new wallet. Thus, you'll get a 25 word mnemonic seed in your local language. Conversely, if it doesn't have a corresponding mnemonic seed word list, your mnemonic seed will be in English when you create a new wallet. Thus, you'll get an English 25 word mnemonic seed.

The code for this described behavior can be found here. As you can see from the code, the list of available languages for the mnemonic seed is:

<!--
List of available languages for your wallet's seed:
0 : Deutsch         (German)
1 : English
2 : Español         (Spanish)
3 : Français        (French)
4 : Italiano        (Italian)
5 : Nederlands      (Dutch)
6 : Português       (Portuguese)
7 : русский язык    (Russian)
8 : 日本語          (Japanese)
9 : 简体中文 (中国) (Simplified Chinese (Mainland))
-->

Thus, as can be seen from this list, if you select Deutsch as language, it will also give you a corresponding Deutsch (German) 25 word mnemonic seed. The code for this behavior is as follows:

<language display_name="Deutsch" locale="de_DE" wallet_language="Deutsch" flag="/lang/flags/german.png" qs="none"/>`

To clarify, wallet_language determines the language of the 25 word mnemonic seed, which is Deutsch in this example.

Now if you, for instance, select Swedish as language, it'll give you an English 25 word mnemonic seed, because it doesn't have a corresponding Swedish mnemonic seed word list. The code for this behavior is as follows:

<language display_name="Swedish" locale="sv_SE" wallet_language="English" flag="/lang/flags/sweden.png" qs="none"/>

As you can see, the wallet_language is now English.

  As a consequence I would like to change my wallet language to English before using it.

Now, unfortunately, closing an existing wallet, selecting a new language (in your case English) on the first page of the wizard and lastly reopening this particular wallet (using the Open a wallet from file option on the second page of the wizard) will not change the language of the 25 word mnemonic seed. Therefore, we have to use the CLI as workaround. This is done as follows:

Exit the GUI and make sure to stop the daemon as well.
Browse to the directory your wallet files are located (Documents\Monero\<wallet-name> on Windows | ~/Monero/<wallet-name> on Linux and Mac OS X).
Copy <wallet-name>.keys to the same directory as monero-wallet-cli. On Linux and Windows, monero-wallet-cli will be in the same directory as monero-wallet-gui. By contrast, on Mac OS X, monero-wallet-cli will be in ~/Applications/monero-wallet-gui.app/Contents/MacOS
In the directory your wallet files are located, rename <wallet-name>.keys to <wallet-name>-backup.keys
You should now have <wallet-name>-backup.keys in the directory your wallet files are located and <wallet-name>.keys in the same directory as monero-wallet-cli
Open monero-wallet-cli by double clicking on it (Windows and Mac OS X) or with ./monero-wallet-cli from the terminal (Linux)
Enter your wallet name and password. The wallet doesn't have to be connected to a daemon to change the mnemonic seed language.
Now type set seed language
This will show you a list of available seed languages and their corresponding numbers. For example, English is 1
Enter the number of your preferred seed language and hit enter.
Type exit
Copy <wallet-name>.keys back to the directory your wallet files are located.
You should now have both <wallet-name>-backup.keys and <wallet-name>.keys. Note that the former still contains your old mnemonic seed language (kind of as backup), whereas the latter contains your new mnemonic seed language.
Restart the GUI. You should now have your "old" wallet with a new mnemonic seed language.
On the Settings page, press Show seed & keys to verify the mnemonic seed language.

Lastly, if you want to change the mnemonic seed language of your CLI wallet, simply start from step 6.


What is a .bitmonero.conf template for setting up a public remote node to be accessed with the monerujo android wallet?

This is what I have:

data-dir=/var/lib/monero
log-file=/var/log/monero/monero.log
log-level=0
no-igd=true

rpc-bind-ip=0.0.0.0
rpc-bind-port=18089
restricted-rpc=true
confirm-external-bind=true

You may want to add

rpc-login=username:password

to restrict access if you must.

You can add comments by starting the line with a #.

log-level=0 reduces the log output of the daemon to a minimum. 4 being the maximum.


Priority among transactions with same fees

It's up to the miner which transactions will be chosen to be included in a block, so a miner might optimise his selection to fill as much as possible of the available block size limit.


Will CPU mining cause high power consumption?

It will cause more electricity usage. How much electricity depends on several factors such as the number of threads used, which you noted. The only way to know for sure is to measure the electricity usage at the wall with a device like a "Kill A Watt" meter. Measure the watts being used while the computer is on but not mining. Then measure the amount of watts used while mining on one thread, then with two threads, up to the total number of threads your CPU supports. The difference of those measurements will tell you how much electricity the computer uses while mining on the different number of threads.

From those measurements you can determine which mining arrangement gets you the most hashes per watt. You will want to take measurements incrementally with each thread because, depending on the system, 2 threads may be more efficient than 3 threads. Or, 6 threads may be more efficient than 8 threads, and so on.

Also keep in mind that mining will create heat and this could increase your need for air conditioning, and that will add to your costs. One CPU won't make much of a difference...maybe 1 to 3 degrees F in a bedroom, but your results may be different.


Does the monero gui client use the GPU to sync with the blockchain?

Currently (v0.10.3.1), the daemon (monerod) and the clients (monero-wallet-cli, monero-wallet-rpc and monero-wallet-gui) only use the CPU for their computations.

Only some programs dedicated to pool mining use GPUs.


About the actual implementation of the **mix-ins** construction process

Yes, get_outs does mixin selection. There is no double spending check done there.
The second question looks like the same as the first one. There is no double spending check done during the mixin selection procedure.


Because of the wording of your question it is not clear if you sometimes run your own node (when checking your balance) or if you never run a node and check your balance with another method (connecting to a remote node or using a view key tool available online).

If you are running 0.9.4 and all you want to do is check your balance then there is no urgency to update to 0.10.0.

If you are running a Monero version prior to 0.9.4 you should update now.


How to calculate mining profits in Excel?

I would do this in a couple parts:

1.) First of all review how you would integrate an API feed into Excel:

https://www.youtube.com/watch?v=NX4Jb3Tj3J4 or
https://www.import.io/post/how-to-get-live-web-data-into-a-spreadsheet-without-ever-leaving-excel/
or even something like Alteryx

2.) You'll need access to a real-time API that has the current traded value of the currency.

https://poloniex.com/support/api/

3.) Finally you'll just need to calculate the the hash rate to XMR conversion.


All unlocked rct outputs will be eligible for inclusion in a ring signature. Those outputs will be stored with the placeholder 0 amount, the real amount being unknown except to the recipient (and the sender, though needing extra information kept outside of the blockchain).

Outputs from the block rewards, which will still be in the clear, will also be available as rct inputs, and will be stored as rct outputs. This will make smaller coinbase transactions, even though their amount is known.

To sum up, the number of eligible rct outputs will be the number of unlocked outputs at amount 0 (and there are none before the fork).


Aside from the Monero Stackexchange what else are good resources for learning about Monero?

If you just want a chat then your best resource is maybe r/monero, if you want to start running a node maybe go to the monero website, if you want the research papers leading up to Monero/another explanation of the tech then maybe you would like:

The CryptoNote whitepaper :)
The RingCT paper
Some slides for extra bonus pictures and comparisons and stuff


What is Triptych and how does it relate to Monero ring signatures?

In Monero currently, we use a ring signature comprising of 10 decoy inputs to each input being spent - so a ring size of 11 - and it scales linearly. This last point is what prevents us from using a much larger anonymity set, as if we double our 11 to 22 for example, we double the size requirements for the signature(s) in the transaction. CLSAG offers a way to compact the size of the signature, however it to still scales linearly.

Now enter Triptych, devised by Sarang Noether and Brandon Goodell of the
Monero Research Lab. This ring signature scheme scales logarithmically in size (and verification time). What this therefore offers Monero is a way to have larger anonymity sets (larger rings) without the linear cost in terms of size or verification time.

Simplified, larger anonymity sets offers better privacy but it has to be balanced against the size and verification time of the transactions. Thus, Triptych is a very interesting advancement for Monero - a way to increase the anonymity sets without impactful size and verification costs.


Is it possible to get a rough timeline/cost estimate for the future monero development?

Monero is run as an open source project, rather than a startup. As such, it is developed at the speed at which its contributors... contribute. Something getting done depends on someone with the right skills deciding to help, and finding the time to do so. As such, no timeline can be given. Funding does help, as some people will pour more time if funded, but that can hardly be made into a cost estimate.

About the specific items mentioned on the image you link to, there are a few things that are out of date:

0MQ isn't done. It was pretty much working months ago, but issues with it ended up with a rewrite being started.
SSL/TLS does not exist. I understand this is something that comes with 0MQ.
client side handling of unconfirmed transactions is done (waiting to be merged now merged, see https://github.com/monero-project/bitmonero/pull/916)
address and tx signing, key export is mostly done - tx signing may not be, I'm not sure what this is, but the other two were merged in the last week or so


What technique(s) should be used to secure funds in my wallet(s)?

The first line of defense: use a secure operating system. This means no Windows, no running random binaries (except below), and keeping patches up to date. If you know how to use them, use VMs, and do all risky stuff on VMs, not the host.

When you've done that, backup your wallet/seed, use a complex password for your keys file.


Is there anyway monero can be investigated

Monero is a cryptocurrency for which the reference implementation is open source, available at https://github.com/monero-project/monero. Anyone may read the source, and modify it to suit their own ends, provided the (BSD) license is respected (which basically means don't be an asshole and pretend you wrote it all yourself).

You will need some basic competency in C++ to read and understand the source.


Kovri operational security example(s) - file permissions

The third point is about general operating system security with regards to which system users have read, write and executable permissions on files and folders in the kovri data path. setfacl (or chmod) can be used to set permissions on existing files / directories and umask is used to set permissions for newly created files in a directory.

Which users / groups you grant what access to is specific to your setup and needs.

As an example, if you only want the korvi user to have any access you could run:
chmod 700 && umask 0077


Why do incoming transfers appear in my wallet later than in block explorer?

The explorer is likely listing the transasctions that are in the pool (ie, not yet mined). Recent simplewallet will show those with show_tranfers, as "pool".

Bear in mind that a transaction in the pool which hasn't been mined is not yours yet. If all goes well, it'll be yours soon, but you should not trust a pool transaction yet for large amounts if you think the other party might try to scam you.


Are monero addresses always 95 characters long?

Yes, because Monero uses a modified base58 encoding method. During encoding, it breaks the address into 8 byte blocks and adds padding in order to guarantee that the resulting base58 address is always 95 characters long.


Failure of an exchange or pool to upgrade to Monero v0.10.1 by January 5th

Miners will lose what they would have gained if the pool had been on the right fork: any block mined on the wrong fork will eventually get reorganized away. If the pool's on the wrong fork, any money from the wrong chain it sends miners will be just that: on the wrong chain. It will therefore only appear in wallets running the wrong chain. This will hopefully not include the miners themselves, and it will certainly not include ecxhanges.

Users sending to an exchange from the wrong fork will not see any money arrive. But then they won't have lost their money, since it'll still be there in the correct fork, so they'll see their money back once they update. Users can't sent from exchanges on the wrong fork, unless the exchange itself is on the wrong fork, and that's unlikely to happen.

You can't directly check whether a third party has upgraded. Best you can do is ask. Once the chain has its first ringCT tx, you'll quickly see who has updated and who hasn't, but that may be a bit late. There is close to a month to update though, so there should not be any issue, given the update is uncontroversial, and of obvious benefit to everyone.


Wallet passwords are never stored on your computer. They're used at the time of input to derive the encryption key which is then used to decrypt your actual wallet data.

Deriving the key from the password is done with CryptoNight. The encryption of wallet data (using the derived key) is done with ChaCha8.

More details can be found here.


Are there Monero developers who also contribute to the development of Bitcoin?

There are no contributors of my knowledge in both Bitcoin and Monero.

However Monero has adopted many ideas from Bitcoin which have never been implemented there mostly due to politics around (hard) forks. Confidential Transactions (CT) have been extended and adopted by Monero as RingCT and also the initial idea of Stealth Addresses has been adopted from a proposal to the Bitcoin protocol. Even currently (once again) discussed Schnorr signatures are being in Monero since the first Cryptonote reference implementation.

In general you can say most of Monero's developers are very aware of methods used in Bitcoin but are not contributing to it directly (as of my knowledge). Still Bitcoin or any other open source project can adopt anything from Monero's codebase since it's fully open source.


Validate the result of a job sent by a miner

The pool adds unique data into a block template (in the reserved space) and creates a hashing blob so that it sends each miner unique data (a unique hashing blob) for each miner to hash. Note here that the pool stores the block template it used to create the miners hashing blob.
The miner adds unique data (the nonce) to the supplied hashing blob and then hashes it repeatedly (changing the nonce each time), until it finds a nonce that creates a resulting hash that meets the required jobs difficulty target.
The result sent back from the miner is the result hash, not "block hex". The pool verifies the result hash by:

Taking the block template from step 1 above, the stored template
Adding the submitted nonce into this template (and note, this is not added to the reserved space, the block template has its own location/field for a nonce)
Getting the hashing blob and then hashing it
Comparing the resulting hash to the miner supplied result hash

Verification then involves the several steps:

Do the hashes match?
Does the hash meet the jobs difficulty target?
Is this the first time this miner submitted this hash and nonce?

If these all pass, it's a verified job/share submission.

Lastly, if the hash meets the network difficulty target, the pool can submit the block template (from steps 3.1 & 3.2) to the network.

  A new blob is constructed from the blocktemplateblob. Which uses
  extraNonce and the nonce obtained from miner in place of bytes 4-8 in
  the reserve location if I understand correctly.

The nonce from the miner is not placed in "bytes 4-8 in the reserve location". It's placed in the part of the block that holds the block nonce. Blocks have a specific field for the nonce.

  What's the point of putting random bytes in 4-8 bytes of blocktemplate.
  Can someone explain what's happening here?

This is specific to the nodejs-pool implementation. Recall, the pool can use the reserved space in any way it needs to. For nodejs-pool, which is a multi-process pool, it needs to add extra randomness into the reserved space. It calls this extra randomness variable "instanceId". When a pool instance starts, it instantiates a specific "Coin". The "Coin" constructor sets the "instanceId" to a random 4 byte number. This ensures that multiple pool processes/instances always set something unique in the reserved space. It has to do this because the other unique(ish) data it writes to the reserved space (the variable they call "extraNonce"), starts at 0 and increments for each blob created. Therefore multiple instances of the pool all start with "extraNonce" the same, 0. But you don't need to get hung up on the way that nodejs-pool uses the reserved space - all you need to know is: you have to ensure your miners aren't hashing the same hashing blob and you can use the reserved space any way that works best for your implementation.


Is it possible to (readonly) check the balance of a Monero address with only providing the address and ViewKey (no Payment Id or SpendKey or whatever), and without first installing/syncing software for it? Just a simple web interface for this?

Yes, that's possible

Private wallet

For a private wallet, turns out this is really a good question! I don't have an answer for you but maybe this post will help you: How can I check the balance of a Monero paper wallet?

exchange wallet:

A very easy way would be to grab an API of some exchange (for example Binance), have your funds there and by accessing a website you can check the balance of your wallet.

So since an exchange gives you access to your balance, you could easily use that to show that balance somewhere.


You can try mining with monero-wallet-cli to see your hashrate but I'm pretty sure it will be below 30H/s (a laptop i3 CPU). With this, you'd be getting about 0.006xmr/day. You can estimate mining profits here, just scroll down a bit and type in your hashrate.


When attempting to install Windows 10 64 bit GUI: This application failed to start because it could not find or load the Qt platforms plugin "windows"

there seems to be a space in the path where it is stored. move it to a place without spaces and try again


How easy is it for merchants to accept Monero payments and convert them into fiat?

Currently their are not any liquid exchanges that will convert Monero into fiat directly, although that is likely to change in the future.

You can either

Send Monero via Shapeshift.io or XMR.to which will send Bitcoin to a fiat payment processor such as Coinbase of Bitpay.;
Convert Monero into a fiat equivalent such as USDT (https://tether.to/) which is available on exchanges such as Poloniex.

Depending on confirmation times, I would approximate:

Converting XMR into fiat via Shapeshift.io or xmr.to to Coinbase, Bitpay or equivalent can easily be completed in 10-20 minutes
Conversion to USDT can happen as soon as you can get your Monero to an exchange (such as Poloniex). The number of deposit confirmations required will depend on the verification level of your account.

I would expect fees to total under 2% (depending on volume) for the xmr.to/shapeshift.io to fiat option and under 1% for the USDT/tether option
The fees will be equivalent or slightly less than the rates chaaged by most credit card companies, without the risk of chargeback and with far superior privacy for your customers.


Why does Monero create two or more inputs for transactions?

This is done to try and make more transactions look the same. An attempt is made to make the transactions a 2/2 (2 input, 2 output transaction). Therefore, even if one of your inputs has enough to fund the output(s), the wallet will attempt to add another input as well.

Source comment(s):

wallet2.cpp#L9315

// for rct, since we don't see the amounts, we will try to make all transactions
// look the same, with 1 or 2 inputs, and 2 outputs. One input is preferable, as
// this prevents linking to another by provenance analysis, but two is ok if we
// try to pick outputs not from the same block. We will get two outputs, one for
// the destination, and one for change.

Then later:

wallet2.cpp#L9361

// while:
// - we have something to send
// - or we need to gather more fee
// - or we have just one input in that tx, which is rct (to try and make all/most rct txes 2/2)

  So it is not the case that Monero is combining multiple inputs to send a large amount of XMR.

This is a slightly different question/observation and is incorrect. Monero absolutely uses multiple inputs to fund a large output. For example, if you own three outputs with values 10, 50 and 100 XMR and want to spend 130 XMR, the wallet will create a transaction with two inputs (your owned outputs that have 100 and 50), and two new outputs (with 130 and 20). The 2nd output is your change.


Because it's not economic for the pool or miner. There's also a "hard" cap (which goes up with median) at 2x the median. If a miner mines a too big of a block, he loses some base block reward (emission) and for it to be economic to him, the fees must be high enough to compensate and earn a little more.

Each wallet fee level corresponds to a % increase incentive for the miner. Bigger the fees, faster the increase. Bigger the increase, cheaper the fees =)

Low priority (min fee) - 1x - 0.6% increase is the "sweet spot" (economic up to 1.2%, after that it's negative earnings)

Normal priority (default fee) - 4x - 2.4% increase is the "sweet spot" (economic up to 4.8%, after that it's negative earnings)

High priority 20x - 12% increase is the "sweet spot" (economic up to 24%, after that it's negative earnings)

Ultra priority 166x - 100% increase is the "sweet spot". Can't make a bigger block than this, anyway :)

When a miner fills the block from highest to smallest fee, it will be the fee of last TX to get into a block which determines the optimal increase. So, it's not just enough to have 1TX in the pool to hasten an increase. There must be many of those, enough to make 100 blocks full of high-fee TX-es to lift the median quickly.

This is why a huge backlog can never develop.


How does one craft a Monero transaction locally, sign with their private key and then broadcast using javascript?

Monero transactions are much more than some simple data that is signed with a private key. You need outputs to spend, mixin outputs from the blockchain, lot's of math for RingCT etc. This is one of the reasons the RPC interfaces (daemon and wallet) exist. These can be called by any language which can call a URL and create/parse JSON.

If you use the wallet RPC, you can call transfer with get_tx_metadata: true and do_not_relay: true to get tx_metadata which can later be broadcast with submit_transfer (or of course do this all in one step with just transfer, without the aforementioned parameters).

If you just want to understand the math that goes into RingCT, read the MRL-0005 paper, or the broader Zero to Monero book. And if you just want to understand the structure of a transaction, see the Monero source code which defines the structures used.


Regular expression to reduce mnemonic to first 3 letters only

What I currently have:

echo $(echo "${MNEMONIC}" | tr " " "\n" | sed 's/^\(...\).*$/\1/' | tr "\n" " ")


Can I quickly move my node from my Windows box to a virtualbox Ubuntu guest by making the blockchain path a shared folder?

I'm pretty sure you're not going to be able to share a folder on Windows and mount it in a VirtualBox guest Ubuntu, using the blockchain from that mounted shared folder. This is because the blockchain file is memory mapped when opened and I'm pretty certain vboxsf (which is the kernel module that handles the share), doesn't support this.

You could create the share and copy/move the file(s) to a non-vboxsf mounted folder, just not use it from the mounted share. If space is your concern, start monerod from scratch on your VM with --prune-blockchain. That will give you a much smaller blockchain on disk.


Anyone have experience with using AMD and NVIDIA GPUs on the same rig?

It is definitely possible. You would have to start the AMD and nVidia miners seperately and configure them so that they only used the index of the GPU that they are compatible with. I think in claymore's cryptonight miner it would be
   -di 02 if you wanted to use GPU 1 and 3. (Computer's use arrays that start at zero to count indices)

As far as I'm aware there are not any nVidia and AMD dual miners for cryptonote algorithm.

Please add more about your operating system for clearer instructions.

Edit: Use ccminer-cryptonight https://github.com/tsiv/ccminer-cryptonight/releases for your nVidia GPU

Use claymore's cryptonight miner for AMD.

If your #1 GPU was AMD and your #2 GPU was nVidia:
claymore would have a "-di 0" flag in the command line or config file
ccminer would have a "-d 1" flag in the command line or bat file


What is the next big step in Monero's future?

The 2 important things coming soon are ringCT and Kovri.

In fact, ringCT is already coded into the last client software and the hard fork allowing such transactions will activate somewhere in January. RingCT is important because it's the last piece of the blockchain privacy puzzle:

Currently, you can't know from where the funds came, thanks to ring signatures.
Currently, you can't know where the funds went, thanx to stealth addresses. This holds true even if you sent those funds yourself and lost your local transaction history! It's interesting to know that you can't recover the destination address from the blockchain.
Soon, you won't know how many Monero were moved, thanks to ringCT.

Kovri is in the works, and it's important because it could be baked into nodes, allowing them to communicate anonymously over I2P. This way, any attempt to track users by using IP addresses would be futile.

Further on, we can look forward to multisig, which should come some time after ringCT. For long-term plans, there are the Monero design goals.

There's also payb.ee coming soon, which is a payment processor developed specifically for Monero.
Oh yes, and GUI coming soon as well, which is what will make it more appealing for the end-user.

I believe that in the future we'll see clever ways to make and improve light wallets, as well. In fact, the Monero CLI wallet is a light wallet already as it can use a remote node to perform transactions. The mymonero.com is a light wallet as well since the client-side javascript could be coded as a stand-alone program and provide security, while the model sacrifices privacy to take the load off the client (the server keeps your view key to be able to monitor incoming transactions while you're away).

What would be the one to push a wave of adoption, I can't tell. But I'd expect some major exchange adding it to be an important step. As confidence grows and the ecosystem develops, we could expect organic growth, and few more smaller waves as people "click" with the tech.


Why does Monero seem to only use the first six decimal places (and not the full 12)?

That's simply because you just don't have a fraction of a balance that small. When you think about it, roughly estimating that 0.1 XMR = $1, then 0.000001 = $0.0001, and so very seldomly is anyone dealing with prices smaller/more precise than that.

A second thing to consider... Technically, Monero (like Bitcoin) doesn't use decimals at all. It uses what are usually referred to as atomic units, or in Bitcoin lexicon "satoshis". Technically,

1 XMR = 1 000 000 000 000 atomic units
1 BTC = 100 000 000 atomic units

Or in other words, you don't have 1.234567000000 XMR, you have 1 234 567 000 000 atomic units.

This is so that all outputs are integers, which helps ensure that input and output math is exact (integer math is exact, while floating point math can get muddy). The "coin" conversion to decimals is just to make things easier to use for humans.

When you think about it in atomic units, it doesn't make sense that decimals "aren't used". Of course they are! They are what make you have 1.234567 XMR and not 0.000001234567 XMR!


How was the Monero emission curve chosen?

It was chosen arbitrarily by thankful_for_today, with no research or thinking of any kind. But we're stuck with it, and since it's part of the social contract it isn't going to change:)


Why is my monero signed signature different everytime I click on sign?

Monero does not use the EdDSA signing algorithm you might have been expecting. Instead, it uses the Schnorr algorithm, which uses a random k value as part of the signature. Therefore each signature will be different because k will be different each time.

See https://en.wikipedia.org/wiki/Schnorr_signature

Here is pseudocode for the signing and verification:

base point = G
private spend key = b
public spend key = B = b*G
msgHash = keccak256(message)
Hs() means hash with keccak256 then convert to scalar number
|| means concatenation

generate the signature:
k = randomScalar()
signature.c = Hs(msgHash || B || k*G)
signature.r = k - b*signature.c

signature is valid if signature.c == Hs(msgHash || B || (signature.r*G + signature.c*B))


What installer to choose for 64-bit GUI?

One of them is a portable zip file, the other is an installer that will install Monero onto your computer. The installer is likely an easier option for beginner/intermediate users.


please start Monero GUI
set view only wallet
set Blockchain location
restart  Monero GUI
ok ^_^


Getting transaction hash / ID from the raw data

The tx hash is not serialized. Rather it is computed from the tx data. This answer discusses how the hash is calculated.


Gui never updates. Data.mdb will not sync. Need handholding guide. Please help

node.moneroworld.com is what keeps the blockchain for you, meaning (1) you don't need to download it and (2) you're at its mercy for some kinds of MITM attacks.

If you want to get the blockchain on your computer, set your own computer (127.0.0.1) as the node address, instead of node.moneroworld.com. Then start the daemon when asked, and it'll start downloading the chain.


If I send two transactions to the same recipient, can they infer the true sender?

Your public address will never appear on the blockchain. What you're spending is amounts sent to one-time destinations so they're unlinked. Not only that, but each one-time addres will be "mixed" with a few others. With this, there's no way to link the two payments together. To the recipient, they will seem unrelated unless you tell him yourself they're coming from you.


There is no way and there won't ever be a way.
This is becasue Monero is unlinkable, meaning no two destinations can be linked together. In other words, nobody can tell where certain Monero went to, so can't really calculate any stats.

This is achieved by utilizing stealth addresses, where the sender generates a one-time destination from the recipient's address. Unlike with Bitcoin, no Monero are actually sent to the stealth address itself (your wallet address never ever appears on the blockchain), but are sent to something derived from it (one-time public key). All the destinations (one-time public keys) look the same and this takes care of the recipient's privacy. The owner of an address is the only one able to know which one-time public keys "belong" to him, by means of a private view key.

The only way to gather some partial stats would be through centralized services such as a web-wallet provider mymonero.com. They can know how much their users received, stored and sent out, because their backend stores the users private view key and updates the balance every time the user logs in (they don't publish this data, though). It's worth noting that these stats could be misleading. The user could spend his Monero by other means (through the standard wallet) and the site would have no knowledge of the changed balance until the user would log back in. Also, he could keep re-sending to himself and the site would see inflated balance, because it would have no knowledge that it's the same Monero going back and forth.


How can i specify in mining to only use 75% of my CPU power?

Typically if you have an AES-NI capable processor you will find the "sweet spot" at 1/2 the number of cores you have, so you won't ever be mining to 100% anyway. Right now we don't have a mechanism to throttle it beyond that, but we are working hard at that exact thing as part of the Smart Mining effort.


Correlation of number of full nodes to network hash rate

No one can know the number of full nodes at any given time, because not all nodes connect to each other, and there is no way of knowing about nodes that you are not directly connected to. Node information is not obtainable from the blockchain.


Altcoins to Monero payment buttons for website?

You could consider using globee and changing afterwards to monero through ShapeShift (you could automate this i think).

Changely has a bad reputation, maybe related to big ASIC miners, and it must be the reason they're on XMO and not XMR.


Can view-only wallet create unsigned tx via RPC call?

I have been trying to accomplish exactly what you are describing for the past few weeks and I have come to the conclusion that this is not possible via RPC. You can only do this via the CLI. I am in the process of writing a RPC wrapper around the CLI so that I can make programmatic RPC calls that issue the proper CLI commands. A step-by-step guide around the CLI process can be found here: How do I use cold transaction signing? but you've probably seen this already. I am using this as a guide for the RPC wrapper.


What options are available for directly buying Monero with fiat currency?

For direct purchase of Monero with fiat currencies there are now multiple options:

Livecoin - Online Exchange supporting Wire transfer (SWIFT) and other options
Coincut - Online Exchange allowing purchase by GBP Bank transfer
 Bitfinex - US dollar USD wire transfer disabled
LiteBit - Online Exchange supporting multiple fiat purchase options including SEPA bankwire, GiroPay and SOFORT
Orillia - Purchase with SEPA
AnycoinDirect - Purchase with SEPA, Sofort, Trustpay, MyBank, IDEAL, Giropay, EPS or Bancontact/Mistercash
MoneroForCash - Purchase with fiat locally P2P
EasyMonero - Purchase with fiat locally P2P
Kraken - Euro and US dollar
LocalMonero.co - Any payment method that the community wishes to use, fiat or crypto, online or locally, a centralized P2P platform modeled after LocalBitcoins.com
Poloniex - Online Exchange with Credit card support and Wire Transfer for deposits and withdrawals

The options above meet your criteria for avoiding the Bitcoin transit hoop. Security, privacy and ease of use will vary.

Bisq is a P2P decentralized exchange not mentioned above because it currently requires the use of Bitcoin as an intermediary currency when purchasing with fiat. There is hope that multisig support for Monero now in development will eventually enable direct fiat purchases.


When you sign a Monero transaction, are you signing a hash?

In the interest of pedantry (and since I can't comment -_-):

You sign the hash of the transaction prefix. In Monero that is everything but the signatures.
(at the above answer) Monero relies on ed25519, not EdDSA. EdDSA is a particular signature system (completely absent in Monero). Monero's ring signatures are presently the Fujisaki-Suzuki variety, implemented in the ed25519 curve.

One additional quibble: in Monero's ring signatures, the hash doesn't actually have "mathematical" transformations applied--it is rather hashed again along with a bunch of other data--so one actually could "sign" an arbitrary-length message instead of a hash of said message.


At the momnent, they don't exist. This is likely to change as the currency gains traction. You can always go on IRC Freenode #aeon and ask the devs to add some hashes.


The payments command in monero-wallet-cli lists the transactions matching specific payment ids.

payments payment_id_1 [payment_id_2 payment_id_3 ...]


Run bitmonerod with the option "--db-sync-mode safe" and it will persist every change immediately. Then if your system crashes or restarts suddenly, there will be no data lost and bitmonerod will pick up wherever it left off the next time it starts.


Error when trying to run monero-wallet-rpc with docker-compose up

I had the exact same error message when running monero-wallet-rpc without the option --disable-rpc-login.

Then, as explained by vtnerd in this open issue:

  The file is always created in the current working directory when
  authentication is enabled.

To create the file, you need to be the owner of the working directory.

I set the current user within the docker container as the owner of the working directory, so Check permissions disappeared and monero-wallet-rpc started correctly.

By the way:

When leaving --disable-rpc-login you should provide --rpc-login user:password.


What is in ~/.bitmonero/lock.mdb? Is it needed to start syncing from a blockchain backup from another computer?

Do I have to backup the entire lmdb/ directory or just lmdb/data.mdb?

You may as well backup your whole ~/.bitmonero folder, to keep your config, logs and blockchain.

What is in ~/.bitmonero/lock.mdb?

It's just a lock file used to control concurrent access. You're presumably going to shut down Monero before backing up so whether you copy this file or not it really won't matter.

Is it needed to start syncing from a backup blockchain data from another computer?

No.

After starting anew do I have to run monero --detach --prune-blockchain again or is it unnecessary?

You don't need to use --prune-blockchain again. Once your blockchain is pruned it will always be pruned. Whether you use --detach or not is up to you.


Monero CPU mining sofware for Solaris 11 OS

The official download source is the best place to get Monero mining software. The Solaris operating system is not officially supported and is different from other OSes, though it shares some similarities with Linux.

In this thread at Reddit the person asks about SPARC CPUs and Solaris, but seems to give up quickly trying.

Q: Is there any chances to see it in a near future?

Maybe.
Q: Perhaps it is possible to adopt some Linux version?

Perhaps.
Q: How hard is to change the code?

Changing the code is simple, getting it to work requires the ability to write software and compile it under the Solaris operating system.
Q: Solaris OS is powerful to aggregate multiple CPUs - perhaps it is worth to try?

Solaris aggregates more SPARC CPUs and the OS runs faster than using Intel x86 CPUs which are limited to 4 to 8 Platinum 8180's (which cost $80K).

The IBM POWER9 has a bigger L1 Cache and is lower priced than Intel.

"Q: Worth it to try?": Worth it to try something else first.

The other ways of doing it (Mining Monero) have many people working on it while those trying under Solaris are few or nearly none.

The operating system Solaris with Intel CPUs isn't much quicker nor does the speed of the operating system make much difference to mining speed. If you used SPARC CPUs you'd be a bit better off and a member of a tiny community.

Best to stick with Windows or Linux and be part of the largest communities.

How many years have you been programming under Solaris and working on improving Monero Software?

If you've been doing that a few years it shouldn't be too difficult. A couple of AMD 7601's under Linux is bound to be cheaper ($10K) and quick at 3100H/s 332w. Use of "free resources" is going to have some limits, especially if you're mining (otherwise the person with the free resources might as well use them themselves).

I don't think it's "worth it" but I can offer this deal: You do it and you can keep what you make.

Your answer is quite opinion based, but I know a fair bit about computers and have checked Monero mining benchmarks. If your time is free the community will appreciate the code you give back. Worth it to you, it's up to you. Not worth it to me.


How to calculate the achieved difficulty of a mined block

Why is there a difference there?

The difficulty displayed on block explorers is the difficulty the hash has to be greater than, not what difficulty the hash is.


How can I create a new Monero genesis block?

Go here and screw around with the genesis tx and nonce. You probably also want to change other stuff (network id) to avoid contacting live Monero nodes.

I've helpfully decoded the genesis tx so you know/can guess what to change:

version
01
unlock time (varint, height, 60 here)
3c
vin length (value in)
01
vin #1 (of 1) type (gen, 0xff)
ff
height for gen input
00
vout length (value out)
01
output #1 (of 1) amount (17592186044415 as varint)
ffffffffffff03
output #1 type (to key, 0x02)
02
output #1 key (32 bytes)
9b2e4c0281c0b02e7c53291a94d1d0cbff8883f8024f5142ee494ffbbd088071
extra length in bytes (varint, here 33)
21
extra pubkey tag (0x01)
01
transaction pubkey (32 bytes)
7767aafcde9be00dcfd098715ebcf7f410daebc582fda69d24a28e9d0bc890d1


Why was `always-confirm-transfers = 1` not the default in version 0.10.0.0?

I can't tell you why it currently (version 0.10.0.0) is not enabled by default. However, about 10 days ago I filed an issue (#1058) for this on GitHub. Meanwhile, it seems there's a pull request in the works (#1185) to actually enable this by default in the future.


How does Monero's transaction fees change according to price?

Monero's fees are not dependent on price. They are based on the size of the transaction (minimum 0.002 Monero per kB, rounded up).

There is some research going on about making the fees dynamic, based on directly observable quantities such as transaction rate, but this isn't anything firm yet.

Monero price is inherently foreign from the blockchain, and as such it is difficult to have an automated consensus system which takes it into account. It may be vulnerable to Sybil attacks, and attackers paying miners to lie about the current exchange rate.

For at least the near future, fees are expected to be changed "manually" by the dev team, if the price of Monero stays for enough time at a level which makes transaction fees too expensive, or too cheap (yes, it's pretty subjective, and it will be that way until a non gameable automated way is worked out).


The fees are not exactly hard-coded, the amount per kB is hardcoded. This was enacted after the block overflow attack where the attacker had to expand the blocksize by flooding it with transactions until they were able to fit more than 512 transactions in a single block, which they were able to do for little cost because tx fees were so cheap at that time. So, the switch to a fixed fee per kB was done to make any kind of flooding or spam attack much more expensive to pull off. I believe the intent is that it is a temporary measure, and it will be removed allowing for dynamic tx fees per kB in the future.


Using the wallet RPC method create_wallet, how do we find our wallet address?

If the response from a call to create_wallet has an empty result object, no error object and has HTTP status code of 200, the wallet has been successfully created and opened.

You can then simply call the wallet RPC method get_address to obtain the wallet address.


How do you add support for (server side) SSL/TLS mining?

You could use the stunnel program to do that (https://www.stunnel.org).

It waits for incoming SSL/TLS connections and redirects the decrypted data streams to a local port (e.g. a server that doesn't support SSL/TLS on its own).


Removing private view key from computer after exporting from ledger?

You have to manually remove the wallet files from your computer. The best option would be to store them on an encrypted removable device.


What are advantages and disadvantages of Monero's privacy features as compared to Bitcoin?

I would say. The primary difference, privacy wise, is. Monero got it, and Bitcoin don't.

What are the primary differences between Monero and Bitcoin
What advantages does Monero offer that are not provided by other cryptocurrencies
Does Bitcoin have any technical advantages over Monero


How can I solve these stuck transactions?

If you have a transaction stuck at the daemon, you can flush it with flush_txpool:

$ monerod help flush_txpool
Command usage:
  flush_txpool [<txid>]

Command description:
  Flush a transaction from the tx pool by its <txid>, or the whole tx pool.

Then in your wallet you can rescan_spent.

  What is the reason?

If your domain is not in sync with the rest of the network or is on an incorrect chain, this kind of thing can happen.