Aeon support at https://xmr.llcoins.net/

Looks like that in the past the page offered only English dictionary. It did generate valid keys and addresses but you couldn't import it into Aeon simplewallet because it works only with Electrum mnemonics. The page was then upgraded to support changing the wordlist, and is now compatible with Aeon simplewallet if default options are used (Electrum dictionary).

Note that, in theory, you should be ok whatever dictionary you choose because on the protocol level private keys and address is all that matters. However, when changing the dictionary you could run into trouble just because the current Aeon simplewallet (0.9.6.0) doesn't have the option to restore directly from keys and you'd have to hack your way into restoring the wallet generated by non-conventional means.

See here for some background info on what was the problem when generating wallets with that page and when / how it was fixed.


Of course it doesn't work for Monero, because Monero is not a fork of Bitcoin.
For mining profit, the simplest would be the following:
Daily mining estimate =
( (your hashrate) * (current block reward) * 720 ) / (network hashrate)

Note that you can't use Bitcoin hashrate for this, as it is a different alghorithm (CryptoNight). For example, a RX 470 will yield about 600H/s for Monero.
For the current block reward, we must look at the emission schedule, or simply look it up at some block explorer.
The emission is a function of current supply, and was defined in the CryptoNote whitepaper, section 6.1.

The upper bound for the overall amount of CryptoNote digital coins is: MSupply = 264 − 1 atomic units. This is a natural restriction based only on implementation limits, not on intuition such as "N coins ought to be enough for anybody".
To ensure the smoothness of the emission process we use the following formula  for block rewards:
BaseReward = (MSupply − A) >> 18,
where A is amount of previously generated coins.

The above is not really user-friendly since it uses bit-shifting for faster calculation.
User-friendly variant of the expression can be found here. Repeating for readability:

The Monero block reward = (M - A) * 2-20 * 10-12, where A = current circulation.

And a soft answer: all I had to do to find it was search for "emission" here on StackExchange.
Also, searching "mining" yields:
How to calculate mining profits in Excel?
Estimated mining profits are overestimated
Are [solo] mining yield calculations like dice or playing card calculations?
Where can I find a tutorial on how to mine with Monero?


Originally Monero used non-deterministic wallets. Deterministic (and mnemonics) are a convenience feature.

Take a look at the --non-deterministic command-line flag, which will generate a non-deterministic wallet, and also --restore-from-keys flag, which will restore a non-deterministic wallet (by prompting for the view and spend keys).

No functionality is lost (beyond any ease-of-use issues).


How to get the entire block blob for submission after mining nonce

The getbklocktemplate RPC returns a blockhashing_blob and a blocktemplate_blob.

You can either try to find a nonce (4 bytes) by mining using the blockhashing_blob, or you can try to find two nonces (4 bytes in the block header, reserved_size bytes in the extra field of the mining reward transaction) using the blocktemplate_blob and computing the transaction Merkle tree yourself.

When your nonce(s) pass the difficulty test, you put it/them in the blocktemplate_blob at the right offset(s) and you send the updated blocktemplate_blob to the daemon using the submitblock RPC.


Is there an example of a transaction that makes use of tx_extra field? Is this public unencrypted data?

Every transaction makes use of tx extra as it places the tx public key in there. The data is public but can be encrypted (e.g. payment IDs are encrypted in extra).

  ...that is viewable in the monero block explorer?

Select a transaction in https://testnet.xmrchain.com or https://xmrchain.com and click "More Details" at the bottom, then "Show JSON representation of tx".


After I downloaded this recent 17.2.2 update, should I delete the 17.1.9 I had downloaded a few months ago?

After you've updated, there's no need to keep old versions.


Is there a way to tell if a Monero node is on, even though it is not public facing and behind a router?

Without forwarded ports, no. Unless of course you also owned the node it was syncing from, in which case you could check that other nodes connected peers.


Any way to test my pool connection from the command line?

Pools use JSON over HTTP. To test connectivity, you can simply use curl on the mining port advertised in the "Getting started" page of most pools. This will cause an error message on the pool side since you don't "talk stratum", but is otherwise innocuous.

Another possibility, which doesn't use "traditional Unix command line tools" but still uses command line tools is to use a CPU miner (for example Wolf's at https://github.com/hyc/cpuminer-multi) to connect and attempt to mine. This will ensure that the server on the other side is a working Monero pool.


How to close a wallet without stopping the RPC server?

Recent monero code has a close_wallet RPC, as seen in https://github.com/monero-project/monero/pull/4007.

This call will close the currently opened wallet, if any, if you've started monero-wallet-rpc with --wallet-dir.


Multiple different wallets connected to same monero node

You can run multiple monero-wallet-rpc processes on the same machine (or different ones), and connect them to a single node (which can be either on the same machine again, or a different one). You don't have to do anything special for this, though it's best if the monero-wallet-rpc processes don't run off the same wallet file, or they'll overwrite each other's wallet cache when they exit, which is usually not what you want.

Now, it's pretty unclear what you mean by "I'm showing the addresses to see that they are connected to RPC. What is happening is that no matter which wallet-rpc first got connected this address is shown on the page.". What are these addresses ? Incoming connection IP addresses ? Wallet addresses ? How are you obtaining those addresses ? You really need to give information if you expect people to tell you what the problem is.


Ability to choose your own transaction fee

You can select a higher fee if you want. This choice is intentionally limited to a 1x, 2x, and 3x multiplier to avoid leaking too much information via the fee (ie, if you're the only one using a 2.7x fee, your transactions will stick out).

NOTE: from two weeks after the v3 fork, the fees multipliers will change from 1/2/3 to 1/20/166. The simplewallet setting blow is renamed from fee-multiplier to priority, so 1/2/3 are still used in simplewallet, but do not express actual multipliers anymore. The base fee will also decrease by 5 times at the same time.

This behavior is a global setting in simplewallet, and can be changed with: set fee-multiplier 1 to reset to default, same with 2 and 3.

Miners will select transactions based on decreasing fee per byte, so transactions with a higher fee multiplier will get priority over transactions with lower fee multipliers.

As J Dog says, a glut of transactions in the pool cannot be expected to last long term, as the block size will increase to meet demand.


Why are only 8 bytes of the hash compared with the target?

It is little endian, and it compares only 8 bytes because it's lazy and if this matches, then the other 24 bytes don't matter (they'd matter if those 8 bytes were equal, in which case you're deemed not to have found a share, where you could have found one). This is probably done for some combination of speed and laziness.


Full nodes suddenly appearing and dissapearing in a geographic region

There is a suspected bug in the P2P connectivity code, which causes some nodes to not see the entire Monero network, so the monerohash.com only sees part of the network. It is unknown how much of the network this "hides" from the statistics.


Monero daemon with --rpc-bind-ip parameter

This error is due to an abundance of caution in preventing the daemon RPC from being accessible from the outside without the user really understanding the consequences.

Here, if you really intend the RPC to be accessible from other machines, you can just add --confirm-external-bind to your command line, as the message says. Adding this option serves as a confirmation from the user that they really underand that (unencrypted) external access will be enabled.

Alternatively, if you know how set up an SSH tunnel, you could do that instead, which would allow listening only on 127.0.0.1, while allowing tunneled access to the external machine you want to use it from, with the advantage of encryption and authentication (and I don't know how to do that offhand, but looking for ssh tunnel on duckduckgo should give good pointers).


Pool miners talk to pools using JSON over HTTP. This is a fairly simple protocol, which is different from the one used by Bitcoin miners, but similar.
I don't know of a documentation for it, but you can easily see what it's doing by looking at cpu-miner.c in Wolf's miner (copy found on github, not the original):

https://github.com/okae/cpu_miner_wolf/blob/master/cpu-miner.c

For the other side of the communication, you can look at the pool server:

https://github.com/zone117x/node-cryptonote-pool/blob/master/lib/pool.js


The current algorithm is CryptoNightV1 [edit: now Cryptonight v4 as of may 2019], and will change in the future.
If you want to mine with ASIC or FPGA, you're looking at the wrong cryptocurrency.
Monero will change its algo at every network upgrade to remain ASIC and FPGA-resistant, and help the decentralization through the smaller player (CPU & GPU) wider participation.

With a CryptoNight ASIC/FPGA you could mine some XMC along with other ASICs.

Edit: If you want to mine Monero, then CPU (AMD ryzen series) and GPU (AMD RX550 and newer) are good hardware.
If you have enough Money, choose AMD Vega 56/64 GPUs.


How to use the --extra-messages-file option?

This option is available for the in-built miner. Reviewing how it's used:

Its expected format is one base64 string per line.
When the miner requests a block template to mine, it adds the current index line from the file as the extra_nonce field in the block template - this gets placed in the tx extra field.
When the miner finds a block, it increments the index counter so the next block template includes the next line from the file in the next extra_nonce.

So,

  What format should the text in the file be? Hex, Decimal, or some other format?

Data is expected to be base64 encoded.

  Once the transaction is mined, how do you parse the data out of the extra field and decode the message back to plain text?

You have to parse the tx's extra field. The format of this is a binary blob of tagged data. To read, you need to loop over it reading the tags and data like:

Start at index 0 of the data
Read the 1 byte tag
If the tag is 0x00 (padding), continue to next byte and read (step 2)
If the tag is 0x01 (pub key), skip over the next 32 bytes (the size of a pub key) and read next byte (step 2)
If the tag is 0x02 (extra)

The next byte tells you the size of the data
Read size of bytes (this gets you your extra data)

If any other tag found, read the next byte (size) then skip size bytes and goto step 2.

Keep looping until you have either found the tag/data you are looking for or read the whole field.


How do I delete an account from my monero wallet?

You can't delete accounts/addresses.
That said, if it's bothering you that much, you can of course delete (move/backup first) the wallet and restore a new one from seed words, which will restore your wallet without recreating unused accounts/addresses. Be sure to backup your current wallet so you have access to things like tx private keys, labels etc which also don't get restored.


Are there certain characters unsuitable for passwords?

There are no forbidden characters. However, you might have difficulty with characters such as \r and \n, since they're interpreted as "I'm done" when you type a string, and as terminator when reading from a file. $ works just fine (let me try right now just to double check... yes, it works).

Interesting characters that might cause trouble are non ASCII characters. For instance, depending on whatever terminal you're using, characters such as é will be represented differently (ie, if the terminal is using UTF-8, UTF-16, other Unicode, or some obscure encoding). So unless you're always using the same computer, you should avoid these characters.

0 may also be a bother, since it means end of string in C.

Of course, remember to quote/escape as appropriate for your shell if you specify a password using a shell.

There is no length requirement (within reason - don't go using 4 billion character password or you'll run out of memory, and there might be a standard C++ library string limit, but if there is, it's likely pretty high).


Stealth.org is a nice pricey domain
Stealthcoin = PoS vs Monero = PoW
Stealthcoin optimizes coinbase rewards to allow very rapid blocks, tradeoff being staker centralization*

* You can only withdraw after mining (staking) the equivalent of a full day worth of blocks, meaning in 1 year, the best case scenario is 365 people get to withdraw.

The project will likely have to age before a fair comparison is really doable.


Why is there a multiply by 8 in the hash_to_ec and derivation_to_scalar functions?

These multiplications are trying to address a similar problem discovered in the key image exploit - small order subgroup issues.

The derivation_to_scalar issue is easier to describe; it is listed on Daniel Bernstein's page about twist security. If an attacker provides a small order point (i.e. a point whose group has 8 members) in tx_extra for the transaction public key, then sends a small amount of XMR to each of those points in the group, whichever output is spent by the user will tell the attacker (and any "public" viewers of the chain that know where to look) the lower 3-bits of the secret view key. Mutiplying by 8 guarantees that the result of the ECDH step will always be in the main group, and therefore will never leak anything about the secret key.

Alternatively, curve25519 sets the lower 3-bits of the key (scalar) to zero. This reduces the security by 3-bits while simultaneously making the key a multiple of 8. All scalar point multiplications with this type of key will therefore result on the primary group.

hash_to_ec is a little different - it converts a 32-byte scalar to a y-coordinate then "recovers" the x-coordinate based on the ED25519 curve. So the point recovered might be on the ED25519 curve, but not the primary ED25519 group. Multiplying by 8 gets the "nearest" point in the primary group.


With the wallet open, changing the wallet restore height in the GUI's Settings section under the Info tab will cause the chain to be re-scanned from the block height specified.


Synchronising Blocks on Wallet restore from Seed

When you restore from a seed the wallet scans all blocks in the blockchain to find transactions belonging to the wallet. Since all transactions are hidden on the blockchain a fair amount of computation is needed for every transaction on the blockchain to find out if it belongs to the wallet or not. This can take a while, especially if you don't have a SSD disk.

To speed up the process you can input a restore height in the wizard where you enter the seed. This will force the wallet to only pull the block hashes until the restore height is reached and not scan the blocks for your transactions. It's important that the restore height is lower than the block height for the first transaction in the wallet. Otherwise transactions can be missed and your wallet will show wrong balance. To find out the restore height you can make a rough guess of the date when wallet was created and check the corresponding date on a block explorer. E.g if your wallet was created in June 2016 you could enter 1050000 as restore height which corresponds to May 18 2016.


How can we view the balance of a cold wallet storage and keep it cold?

This can already be done. You'll need the keyimages of the wallet in order to see the correct current balance of your wallet, this can be dome using the command,

  export_key_images

within the monero-wallet-cli interface, it will then save them to file, and then you can import that file into your watch only wallet using the command

  import_key_images

to update your view-only wallet.


How does nicehash perform share validation?

Whilst I can't speak to xmrrig-proxy as I'm not familiar with it's codebase, I can to xmr-node-proxy, which does actually perform full validation of the miner submitted job.

Aside from this clarification and to answer your specific points:

Pools perform full validation of submitted jobs and therefore a miner cannot send invalid work and get shares awarded.
A malicious pool could indeed not accept valid work, so there's an element of trust here. If a pool appears to not be accepting valid work and giving the correct shares, miners will begin to notice and use another pool.


https://monerohash.com/#network is a pretty good visualisation of the state of Monero mining. It also has some basic stats on nodes, and the blocks the monerohash pool has found.


Safely stopping Monero daemon sync (monerod)

The normal way to exit monerod is to use exit. Sending signal 15 (graceful exit) is also a canonical way to exit (for example if the process does not have a console). If it was started as a daemon (ie, with --detach), then sending the exit to the detached daemon is done this way: monerod exit.

monerod uses a database to store the blockchain, so normally it doesn't need anything special to save, as it should always be in a good state. However, an OS crash (or OS/filesystem bug) could cause some disk writes to be lost, causing corruption. monerod by default will use a "mostly safe" database mode, which may be vulnerable to such crashes, but is a lot faster. With the recent 0.11 release, monerod will use a hybrid approach, using the "fast" mode while doing the initial sync (where speed is more important), and switch to the safe method once synced. Therefore, after sync, you should not be able to lose data by database corruption. Note that, of course, if you have flaky hardware, all bets are off.


The esperanto term for daughter chains is Moneridos. Daughter chains are pegged side-chains which can be merged mined. They are designed to process microtransactions and other stuff that would just spam the main chain, like on-chain betting or gambling.

The differences to side chains are that they are deeply anchored into the Monero Core and will be enabled on any Monero node. Also, the plan is that they do not have any coinbase transactions. According to @fluffyponyza, tokens on daughter chains are only to be created on-demand when there are pegged transactions into the sub chain.

Read more at this reddit scalability discussion.


Is there a way to export the output of the command `show_transfers`?

https://askubuntu.com/questions/420981/how-do-i-save-terminal-output-to-a-file

To write the output of a command to a file, there are basically 8 commonly used ways.

Overview:

         || visible in terminal ||   visible in file   || existing
 Syntax  ||  StdOut  |  StdErr  ||  StdOut  |  StdErr  ||   file
=========++==========+==========++==========+==========++===========
   >     ||    no    |   yes    ||   yes    |    no    || overwrite
   >>    ||    no    |   yes    ||   yes    |    no    ||  append
         ||          |          ||          |          ||
  2>     ||   yes    |    no    ||    no    |   yes    || overwrite
  2>>    ||   yes    |    no    ||    no    |   yes    ||  append
         ||          |          ||          |          ||
  &>     ||    no    |    no    ||   yes    |   yes    || overwrite
  &>>    ||    no    |    no    ||   yes    |   yes    ||  append
         ||          |          ||          |          ||
| tee    ||   yes    |   yes    ||   yes    |    no    || overwrite
| tee -a ||   yes    |   yes    ||   yes    |    no    ||  append

List:

command > output.txt

The standard output stream will be redirected to the file only, it will not be visible in the terminal. If the file already exists, it gets overwritten.
command >> output.txt

The standard output stream will be redirected to the file only, it will not be visible in the terminal. If the file already exists, the new data will get appended to the end of the file.
command 2> output.txt

The standard error stream will be redirected to the file only, it will not be visible in the terminal. If the file already exists, it gets overwritten.
command 2>> output.txt

The standard error stream will be redirected to the file only, it will not be visible in the terminal. If the file already exists, the new data will get appended to the end of the file.
command &> output.txt

Both the standard output and standard error stream will be redirected to the file only, nothing will be visible in the terminal. If the file already exists, it gets overwritten.
command &>> output.txt

Both the standard output and standard error stream will be redirected to the file only, nothing will be visible in the terminal. If the file already exists, the new data will get appended to the end of the file..
command | tee output.txt

The standard output stream will be copied to the file, it will still be visible in the terminal. If the file already exists, it gets overwritten.
command | tee -a output.txt

The standard output stream will be copied to the file only, it will still be visible in the terminal. If the file already exists, the new data will get appended to the end of the file.


Why is the function open_tx executed twice for each transfer command?

In short, tests.

You can see this by following the path taken by the CLI wallet when doing a transfer, as you essentially end up in create_transactions_2. If you follow through that, you will see transfer_selected_rct gets called from various places (1/2 & 3), and it's that which makes calls through to open_tx via construct_tx_and_get_tx_key. Thus a test tx performed in create_transactions_2 will call through to open_tx, as will the final real one.


What is a mining pool, and why should I join one?

A mining pool spreads the risk/reward of hitting a block, so you'll get more consistent results--though you'll likely pay an administration fee.

Think of it in terms of a lottery pool. If every week you put in $10 and the total is $100 in your lottery pool, you'll get 10% of the winning payout--minus any administration fees. Whereas if you buy $10 of tickets by yourself, your odds of winning go down, but you receive 100% of the reward and pay no administration fee.


Proving ownership of a Monero public key is helpful if you solely want to verify ownership but there are other uses. Here are a few possibilities:

"Ownership" and "control" are not always the same thing. A new user may have a Poloniex Monero address which they "own" but a potential donor trying to encourage new users to set up full nodes may require a signed message to verify control of an address before a donation is sent.

Communicating details relating to a business transaction is another use case.  Merchant can use the message signing feature to confirm a package was sent, including a tracking #.

Suppose a buyer regularly sends monthly payments to a wine buyers club. One month the merchant suddenly changes its Monero address without warning. The buyer concerned about a possible MITM attack, could ask the merchant to sign a message confirming control over both their old public key and the new address.


It would appear that you spent less than 0.6 XMR in this transaction.  You must have received a 0.6 XMR denomination in the past, which remained an unspent output in your wallet until now.  That output was used as the input for the current transaction.  It was mixed with 8 other unspent outputs, so no one but you knows which was sent by you.

Note the output denominations of the transaction (.008, .03, .06, .2, .3).  The receiver in your transaction will be receiving some of those.  You'll receive at least one of those as well, since you'll receive change from paying with a larger denomination than you actually sent to the recipient.


Are alternate Monero full nodes possible?

Generally speaking, yes, it's possible. All a developer has to do is to carefully implement the protocol specification in her programming language of choice.

However, a formal monero protocol specification does not exist at the time of writing. It means hard times for 3rd party client implementations as they would have to have deep knowledge of the existing monero client and protocol.

Finally, I'd like to mention that btcd is not the only full node implementation for Bitcoin, apart from bitcoin-core there is also libbitcoin, another full node implementation. And to compare, other blockchain platforms also offer different full clients, e.g., Ethereum has seven different implementations as far as I am aware of. All you need is a well-written protocol specification.


How do you store seed phrases for multiple wallets?

Paper wallets are great but then you run the risk of losing it all in a fire.

Storing photocopies in more than one geographic location mitigates that risk significantly.
An alternative digital solution is to store all your seeds in a single text file encrypted and uploaded to multiple online locations. That way you just have to remember one password to decrypt your text file with all your seeds.
You could even use one of the many single/one password tools / services.
In my opinion, digital (so encrypted backups), hands down beats any paper / physical versions.


How to open a Monero CLI wallet by specifying the wallet name?

Use the parameter: --wallet-file <file name here>. E.g.

monero-wallet-cli --wallet-file MyWallet

(assuming you have a wallet file named "MyWallet" in the current working directory)


Kovri and Monero are 2 distinct stand-alone projects that does not share any source code in common. Even if developers are not the same, it is still the same community (they are both under https://github.com/monero-project, same funding system ). So while there is nothing technically that would prevent Kovri to continue if Monero were to cease, it is highly unlikely that it will happen in the current state of things.

However, the goal IS to build a project and a community that can sustain itself.


How to generate a unique deposit address for a Monero wallet

To create a subaddress, you need the wallet private keys. Assuming you have these, you can create them in javascript using this package, as an example.

You cannot do this having only the public key, you need both the private view key and public spend key.


Recovering Cake wallet from a lost iPhone to MyMonero on Android

The 25 word mnemonic seed provided by Cake Wallet is compatible with MyMonero. However, MyMonero will have to scan the full blockchain looking for transactions that belong to your wallet. This is quite resource intensive and therefore an import fee of 0.1 XMR is required, which has to be paid by another wallet. Put differently, it cannot be subtracted from the current wallet. Note that Monerujo, another third-party Monero wallet for Android, does not require an import fee and the seed is compatible.

  but cannot remember the exact date I created the wallet

First note that for a wallet like Monerujo, you'd have to use a Restore height too. If you don't remember the exact date, you can use an approximate date. If, after the wallet is fully restored, not all transactions show up, you can always redo the process with a lower Restore height. A list of sensible Restore heights can be found here by the way:

What is the relevance of the restore height?

  I have not started the recovery process because it looks a bit intimidating

It is not particularly intimidating if you (i) choose a sensible Restore height and (ii) diligently go through the steps. That being said, if you need any help, you can always open a new thread on r/monerosupport and the community will help you out.


As long as you have the wallet's 25-word mnemonic in a safe place, you cannot lose any funds, even if you remove all the wallet directories. Because, you can always recreate the wallet with the mnemonic. Of course, when doing that, you'd need to rescan the blockchain.

However, keep in mind that only the wallet you're sending transactions from, keeps a cache of the destination addresses. As far as I know, there's no way to sync that between CLI and GUI wallet folders (for the same address). Maybe in the future, one would be able to export and import that …

I am in a somewhat similar situation, starting using the GUI after the CLI. So, I copied the CLI wallet folder for use with the GUI. For past transactions performed with the CLI, the destination addresses are also visible via the History page of the GUI (click on Details there). However, the reverse wouldn't be true. Transaction details for transactions performed from the GUI would not be available if I were to restart using the wallet from the CLI directory. After syncing up, the balance would obviously be the same, but I wouldn't be able to see where I sent money to.

If you "branched" off the wallet directory from the CLI to the GUI (by copying it), there's generally no use in keeping the old directory. In theory, I think you would also be able to use the CLI with the wallet in the directory used by the GUI. You could verify that by making another copy, and then type show_transfers out in the CLI.


Selective transparency in Monero vs Zcash

This question boils to down which selective transparency options both coins offer. I'll start with Monero. In Monero there are three tools for selective transparency, namely the viewkey (called the tracking key in the CryptoNote whitepaper (a,B)), key images (I = xHp(P)), and the private tx key (r). Note that the letters between parentheses correspond to the letters presented in the CryptoNote whitepaper.

The viewkey allows you to see all incoming transactions for a certain account, but not outgoing transactions. More background information as to why can be found here.

The key images allow you to see all outgoing transaction for a certain account. Thus, with a combination of the viewkey and the key images, you will be able to infer a balance of a certain account.

The private tx key can be used as prove of payment on a case by case basis. That is, in case of a dispute, you can prove that you paid the receiver by publishing the private tx key (which you can obtain from the wallet), the transaction ID, and the receiver's address. An auditor can subsequently verify that you paid the receiver.

Basically 1 & 2 are important for auditing certain accounts (e.g. businesses and charities), whereas 3 is important in case of disputes.
There are, however, also a few things to note:

You cannot fake a balance by giving the view key to an auditor but omitting some transactions and key images. For more information, see here.

Instructions on how to prove a balance of a certain account can be found here.

The viewkey and key images won't show an auditor which address the account received the funds from or paid the funds to, respectively.

For this bulletpoint I will quote Luigi:

Oh, and a quibble. Revealing r (the private tx key) doesn't prove that you paid someone, only that that someone has received money. In practice, in an actual dispute, you'd be referencing a particular destination and TXID to a 3rd party, which would come much closer to proving to said 3rd party that you paid the recipient in question.

Now back to Zcash. As far as I know, in Zcash the only option for selective transparency currently is a key that is similar to Monero's private tx key. This makes auditing a certain account virtually impossible.


Remote node IP is always changing in Monero Gui wallet

In both Simple mode and Simple mode (bootstrap) the GUI will automatically connect to a random remote node. This configuration was preset by developers in order to improve user experience for the less technically inclined. This further means that, in both these modes, users cannot set a custom remote node. Whilst this may change in the future, users currently have to resort to Advanced mode in order to set their custom node. In Advanced mode, you can set the custom node on the Settings page. Switching to a different mode can be done as follows:

Go to the Settings page.
Close the current wallet.
In the wizard, select your desired mode.
Reopen the wallet via the Open a wallet from file option.


Can one add a payment ID to a subaddress in Monero?

It is not possible (well, you could do it manually but no wallet would recognize them).


Monero JavaScript/node.js - https://github.com/PsychicCat/monero-nodejs
Monero private testnet setup - https://github.com/moneroexamples/private-testnet
Test faucet - see Can I obtain Monero testnet coins without mining?


Mymonero and simplewallet mnemonic seed compatibility

MyMonero uses 13 word mnemonic seeds and simplewallet uses 25 word mnemonic seeds.
MyMonero can recover a wallet created in either format.
Currently simplewallet can only recover wallets with 25 word mnemonic seeds but there is code available to recover 13 word mnemonic seed wallets in case MyMonero ever disappears:
int main(int ac, const char* av[]) {

// get command line options
xmreg::CmdLineOptions opts {ac, av};

auto help_opt = opts.get_option<bool>("help");

// if help was chosen, display help text and finish
if (*help_opt)
{
    return 0;
}

// default language for the mnemonic
// representation of the private spend key
string language {"English"};

// get 13 word mnemonic seed from MyMonero
auto mnemonic_opt = opts.get_option<string>("mnemonic");

// get the program command line options, or
// some default values for quick check
string mnemonic_str = mnemonic_opt
                      ? *mnemonic_opt
                      : "slid otherwise jeers lurk swung tawny zodiac tusks twang cajun swagger peaches tawny";

cout << "\n"
     << "Mnemonic seed    : " << mnemonic_str << endl;

// change the MyMonero 13 word mnemonic seed
// to its 16 byte hexadecimal version
xmreg::secret_key16 hexadecimal_seed;

// use modified words_to_bytes function.
xmreg::ElectrumWords::words_to_bytes(mnemonic_str, hexadecimal_seed, language);

cout << "\n"
     << "Hexadecimal seed : " << hexadecimal_seed << endl;

// take the 16 byte hexadecimal_seed, and
// and perform Keccak hash on it. It will
// produce 32 byte hash.
crypto::hash hash_of_seed;

cn_fast_hash(hexadecimal_seed.data, sizeof(hexadecimal_seed.data), hash_of_seed);

cout << "\n"
     << "Hash of seed     : " << hash_of_seed<< endl;

// having the hashed seed, we can proceed
// with generation of private and public spend keys.
// the keccak hash of the seed is used as a seed
// to generate the spend keys.
crypto::public_key public_spend_key;
crypto::secret_key private_spend_key;

crypto::generate_keys(public_spend_key, private_spend_key,
                      xmreg::get_key_from_hash<crypto::secret_key>(hash_of_seed),
                      true);

cout << "\n"
     << "Private spend key: " << private_spend_key << "\n"
     << "Public spend key : " << public_spend_key  << endl;

// now we get private and public view keys.
// to do this, we keccak hash the hash_of_seed again
crypto::hash hash_of_hash;
cn_fast_hash(hash_of_seed.data, sizeof(hash_of_seed.data), hash_of_hash);

crypto::public_key public_view_key;
crypto::secret_key private_view_key;

crypto::generate_keys(public_view_key, private_view_key,
                      xmreg::get_key_from_hash<crypto::secret_key>(hash_of_hash),
                      true);

cout << "\n"
     << "Private view key : " << private_view_key << "\n"
     << "Public view key  : " << public_view_key  << endl;

// having all keys, we can get the corresponding monero address
cryptonote::account_public_address address {public_spend_key, public_view_key};

cout << "\n"
     << "Monero address   : " << address << endl;

cout << "\nEnd of program." << endl;

return 0;

https://github.com/moneroexamples/mymonero-keys
According to fluffyponyza:

When we first decided to create a mnemonic system the spec we came up with was: take the seed from the mnemonic, hash it for the spend key, hash it twice for the view key. Somewhere during the simplewallet implementation we forgot about that, and just used the mnemonic seed as the spendkey directly.
This proved to be a blessing in disguise, though, as we'd not realized that people might want to retrieve their seed. Using our original design this wouldn't have been possible, as we didn't store the seed in the wallet file.
Much later on when we were creating MyMonero (a different group of developers, I'm the only common link between the two) we decided that a 13 word seed would be much easier for people to remember, but because we wanted it to match simplewallet's implementation we made sure that we followed the spec as it was originally.
At some point in the future we'll add support in the command-line wallet for four types of derivation and let advanced users choose derivations with a command-line switch:

short mnemonic, spendkey is seed
short mnemonic, spendkey is hashed seed (MyMonero)
long mnemonic, spendkey is seed (current simplewallet)
long mnemonic, spendkey is hashed seed


What is the hash-rate difference in the available CPU miners?

I think this question misunderstands how miners work. Within the ones you listed, they each have a different purpose.

Wolf's CPUMiner, YAM Miner, and Claymore's CPU Miner are all meant for CPU. Some work on more operating systems than others.

Wolf's GPU miner and Claymore's GPU miner are both meant for AMD GPUs. Wolf's is open-source, and Claymore charges a mining fee but is sometimes a little bit faster.

All the ones you mentioned are about the same difficulty to use. The Monero Spelunker is the easiest to use CPU miner for Windows.

Performance for each will vary significantly depending on what cards/chips you have.

For a good start, check out the the Wiki on /r/MoneroMining. It doesn't have information for all the miners you had listed (yet), but it should help you understanding mining a little bit more.


Understanding Monero addresses in the wallet GUI

A wallet has a primary address (that starts with a 4) and can have any number of subaddresses (that start with an 8). Accounts are just an abstraction which allow subaddresses to be separated - you could create one account for your savings and one for daily spending for example.
When someone sends you XMR to an address, it is sent to that address. The wallet that the address belongs to can then spend the received XMR.


How much does Mymonero take as fees per transaction?

According to fluffyponyza the fee is 50% on top of the miner fee (with n fee when and it month hosting costs have been recovered:

  50% on top of the miner fee, so the old fees were 0.01 XMR per kb, and if you used MyMonero it was 0.015 XMR per kb. With the new fees it's 0.002 XMR per kb, and 0.003 XMR per kb with MyMonero. We also have an algorithm to turn the fee off once we've covered our monthly hosting costs, but that's never happened:-P


How do you get the IP address of a Loki Service Node on the network?

On any loki node regardless if its a service node or not, you can run the following command:

curl -sX POST http://localhost:22023/json_rpc -d '{"jsonrpc":"2.0","id":"0","method":"get_service_nodes"}' -H 'Content-Type: application/json' | grep -B 4 SERVICE_NODE_ID_HERE

Change localhost if your connecting to a remote loki node and change SERVICE NODE ID to the id you are looking for.


Literature suggestions to understand the cryptography used in Monero?

Here's someting about elliptic curve cryptography that helped me understand it. Also, there's a site studying security features of various elliptic curves. For other things (such as ring signatures), I'm hoping that someone else can provide useful references.


Sidechain with Monero as the base token and Zerocoin as the anonymous token

Yes it's definitely possible, but why create a whole new coin for that? A better idea would be to create a Zerocoin sidechain (post RingCT) for Monero that allows people to move their Monero into the sidechain, mix it and send it to anyone else on the sidechain, and then pull it back out.

This would avoid the massive risk associated with ZCash's trusted setup because the sidechain would never have much value in it, and so the worst that can happen is an attacker can drain whatever is in the sidechain at the point that they find an exploit.


If I received XMR in a sub-address, will my balance correctly reflect this transaction in a wallet that does not support sub-addresses?

No. The wallet needs to support sub-addresses so the balance can be calculated correctly. Consider the scenario below:

You create a wallet in MyMonero and send 5 XMR.
You restore this wallet in the GUI.
You receive 2 XMR in a sub-address (acquired via GUI).

The MyMonero wallet will continue to show the balance of 5 XMR while the GUI will show 7 XMR.


ELI5 how to install AEON on Ubuntu 16.04 LTS

The following assumes that your default downloads folder is called Downloads and that it's a subdirectory of your home directory, that the aeon source code archive that you downloaded is called aeon-0.9.11.tar.gz and that it get unpacked as an aeon-0.9.11 directory. You'll have to adjust the instructions if the names of your files or directories differ.

Open a command-line terminal and enter the following four commands:

cd ~/Downloads
gzip -cd aeon-0.9.11.tar.gz | tar xvf -
cd aeon-0.9.11
make

If you've already got all necessary dependencies installed, the above will just work. But if not, you'll need to install whatever's missing using whatever package manager Ubuntu provides. You've probably already got make — find out (from your terminal) by entering make --version, and if you've already got cmake, then cmake --version will tell you the version. The GCC 4.7.3 dependency means the C++ compiler, so check the version by entering g++ --version. If you have the boost headers installed, you can perhaps list them with ls /usr/include/boost, and you should be able to list the boost libaries with ls /usr/lib|grep boost: this may give you a clue as to which boost version you've got (for instance, I've got version 1.56, and that last comamnd tells me that I have various files with names similar to libboost_filesystem.so.1.56.0.

If the build works, you will end up with aeond, simplewallet, simpleminer and connectivity_tool in the folder ~/Downloads/aeon-0.9.11/build/release/src (note that “~” is a quick way of referring to your home directory). Try entering ls -l ~/Downloads/aeon-0.9.11/build/release/src for a detailed listing.


VIRT 100G usage of monerod; Is this expected?

The vast majority of the virtual memory usage is memory mapped I/O backed by the blockchain database on disk. A minority corresponds the process memory.

The monero database file is something like 70 GB, very roughly, and some extra space is reserved for expansion, so 103 GB seems totally plausible.

As a point of comparison, typical x86_64 has 256 TB of virtual address space, so 104 GB is 0.04% of it.


How can I calculate the Monero network hashrate?

The hash rate can only be estimated from the difficulty, which is itself adjusted up and down based on how fast blocks are found compared to the 120 second target. This estimation is the difficulty (currently 7462457559) divided by the target (currently 120 seconds), so currently about 62 MH/s.


How to convert Ledger seed to Monero compatible seed on Windows?

Note: Entering your seed on your computer can potentially expose it to malware if your computer is compromised.

First step is to download Git for Windows.

Go to gitforwindows.org and use the Download button.
Install it with default settings.

Next step is to install Python 3.

Go to python.org and download the latest Python 3 Windows x86-64 executable installer. I used the following link: https://www.python.org/ftp/python/3.8.1/python-3.8.1-amd64.exe
Open the installer, select Add Python 3.8 to PATH and then install with default settings.

Afterwards open the git-bash shell the following way.

Open the following path: C:\Program Files\Git in Explorer.
Start git-bash.exe as administrator, maximize the window.

Then enter the following commands, line by line.

pip3 install pycryptodomex ECPy ledgerblue pyreadline
git clone https://github.com/LedgerHQ/ledger-app-monero
cd ledger-app-monero/tools/python/
export PYTHONIOENCODING=utf-8
PYTHONPATH=`pwd`/src  python -m ledger.monero.seedconv.py offline

Now the program should have started successfully. To confirm the seed language, enter 2 for English. Then enter yes and it will ask you for your 24 word Ledger seed. Your Monero compatible seed should finally show up now.


How to use the view key to see amount sent to cold storage?

The CryptoNote protocol allows you to verify that your funds arrived safely at your cold wallet address. This is done as follows. You can verify that your funds arrived safely at your cold wallet address using this tool or this explorer/tool. The former tool is created by luigi1111, who is one of the core-team members of Monero, and fetches data from Moneroblocks. The latter tool uses its own explorer to fetch data, namely Monero Explorer.

First, make sure to save the transaction hash shapeshift, an exchange such as Poloniex, MyMonero, or simplewallet provided you with.
Fill in the cold wallet address, the viewkey that belongs to the cold wallet address (MoneroAddress provides this), and the transaction hash of the specific transaction. It should show you:

  This address owns output x with pubkey: xxxxxxxxxxxxxxxxxxxxxxxxx for amount x.xx

The sum of those outputs should be equal to the amount that was sent. An example of how it should look like can be found here. Generally it is suggested using a test amount first to try out the tool and get a bit familiar with it. Furthermore, the tool will check if the viewkey matches the address. Thus, in case you made a typo when noting down the addressor viewkey it will show you an error message to prevent you from sending funds into  limbo. Alternatively, if you made a typo when typing over the address or viewkey from either the printed page or the page were you noted down everything it will show you an error message too. Using this tool you can be certain that your funds arrived safely at your freshly generated cold (paper) wallet. Even if you are filling your "real" wallet, it is generally advised to first send a small transaction to test if "everything works". Furthermore, it is advised to first make a test wallet (e.g. 1 XMR) and restore that, so you can also verify with your own eyes that the funds arrived safely at the address.

Lastly, if you are looking for a guide on how to  securely generate an offline cold paper wallet, it can be found here.

  outgoing transactions of a cold wallet

For clarity, there are possibilities to do this. These have been discussed extensively before and implications have been posted in this thread. Furthermore, an important "feature" to do so has been merged into master a few weeks ago. From the pull request:

  They are used to export a signed set of key images from a wallet with a private spend key, so an auditor with the matching view key may see which of those are spent, and which are not.

It should be noted though that key images only work in a adversarial way.


In 2021 when the xmr algo is RandomX which hardware is most efficient

You can find here a compilation of some hardware mining specific for monero:
https://monerobenchmarks.info/


Where can I find a tutorial on how to mine with Monero?

Both CPU and GPU can mine monero but GPU is much faster. The best  way to get started with monero mining is by joining a mining pool and following the getting started guide.

Here is a list of mining pools you can join taken from https://www.monero.how/ . I myself is mining at supportxmr.com which is a small pool.

  monero.crypto-pool.fr
  minexmr.com
  xmr.prohash.net
  moneropool.com
  monerohash.com
  supportxmr.com
  xmrpool.net
  monero.miner.center
  xmrpool.eu
  usxmrpool.com
  xmr.poolto.be
  sheepman.mine.bz

The second way you can mine is through solo mining. You need to have a full node and the GUI or CLI wallet. In GUI wallet you just need to click the start mining button while in the CLI you have to type the start_mining command.


Syncing over tor is hard, I had the same issues, restarted many times, but you will get through in the end.


Transaction rejected by daemon with status: Failed Error: Reason: fee too low

This has nothing to do with unconfirmed outputs. What likely happened is that, due to varint encoding, a slight post creation change to the tx caused it to jump to a high size threshold, and since the fee is per kB, the fee was suddenly not enough. This is a bug in transaction creation. This is pretty rare, since it needs the change to cause a size increase, and the original size to be just a byte (or two, if unlucky) from the next kB limit.

There was a bug about this which got fixed a while ago, but there apparently is another one still, assuming you're using a recent master. The good news is that it is transient and doesn't break anything apart from needing to send again.

Chained payments do not exist in Monero. Since any output on the chain may be used by others as fake outputs, the owner is not allowed to use them either, for privacy reasons.


Potential mistake in trying to secretly transfer from one bitcoin wallet to another via monero - Theoretical

Due to fees it would never be the exact same amount, but in theory it could arise suspicion. Also, nothing stopping you from splitting the amount into multiple transfers at exit.


You either need to upgrade boost or use this PR: https://github.com/monero-project/monero/pull/6612
An earlier PR got merged that broke boost compatibility.


Clarification about old generated addresses?

I would answer the questions grouped.

1 and 2:

The address format has not changed from 0.11.1 to 0.12. So all monero addresses that you generated are still valid and you can send to them with 0.12.0 wallets.
But to move the funds again from a 0.11.1 wallet you need to set the ring size to 7 manually since otherwise the 0.12 v7 network would reject your transaction. Use the following command on the cli

  transfer 7 ADDRESS AMOUNT

More information is available here.

3a and b:

Short answer is No.

The blockchain will never know about your addresses. It only saves, transactions, so it will never know about the addresses you generate with your wallets.
Monero also uses stealth addresses, so each transaction you are receiving will not have your address linked to it. The transaction will go to a unique address that is displayed on the blockchain but there is no way for anyone without your private view key to know that the unique address on the blockchain belongs to your generate address.

Bonus you mind want to look into sub-addresses in order to reduce your batch creation overhead. (You will get multiple addresses from one wallet so only one backup seed is needed.)


Is it possible to build a BitcoinJ style library that will help enable lightwallets?

Basically yes, a wallet has to scan every block in the blockchain to see if any transactions belong to it.

When importing an older wallet, it only needs to scan from the last block known to that old wallet, forward. Depending on the age of the wallet this may be much less than the entire blockchain.

The new wallet code is much faster now because it can just sync block headers for ranges that the wallet doesn't care about. (A newly created wallet can be synced in seconds, instead of hours.) But for ongoing use of an existing wallet, you still need to scan every new block. Being more selective of individual blocks or block ranges could leak information to the server about your identity.


What is the limiting factor for synchronization speed?

Possible causes explained to me in #monero:matrix.org:

Verification tends to be limiting factor.
Using an HDD is known to be significantly slower than SSD/NVMe.
Apparently HDD seek time is a significant bottleneck.
Verification operations are not very parallelizable therefore if a single CPU core is spiked to 100%, that could be limiting factor, even if others are idle.  Monero code doesn't seem to properly utilize multiple CPU cores.
A single slow peer might be able to slow things down overall.
Wallet syncing at the same time as blockchain syncing -> very slow.

Notes:

I was just syncing the most recent few thousand blocks.
I was using an HDD rather than SSD/NVMe, so my bottleneck may not apply to you.

[1] Per selsta: "yes, because bottleneck is verification not network speed"
[2] Per selsta: "yes, HDD will always be extremely slow during verification."
[3] Per moneromooo: "It's seek time that matters, not contiguous r/w speed."
[4] Per Inge-: "disk queue length is indicative (while transfers/sec will be very low for random reads on a HDD) and if any single cpu core is pinned at 100% (overall CPU utilization could be very low as there is a limit to how parallelizable the workload is))" and "the number of cores that can be utilized are limited. I would expect parallel verification of transactions is possible, while parallel validation of blocks is more difficult"
Q: Wouldn't users complain about multiple cores not being used?
A: hyc: "you probably would never have noticed. I have 8 cores and pretty much never see more than 4 cores used
there's definitely something artificially limiting throughput
I just don't know how to pinpoint what it is"
[5] Per moneromooo: "If none is used, it's possibly waiting on data from a peer. If that peer's busy, it might wait a bit before sending."
[6] Per moneromooo.


What level of cryptographic review has the current Monero protocol received?

The members of the MRL have all earned their PhD (which fact the website does not reflect at present) in various mathematical fields.

Their publications have received various levels of peer review. The RingCT paper, for instance, has been submitted to the Ledger journal, and has been approved to be included in the first edition.

To answer the two other questions you posed:

Massive amounts of review. Perhaps the best way to illustrate this is to link you to the list of things that implement Curve25519, and that implement Ed25519 / EdDSA.
Quite a bit of review. As an example, take a read through Andrew Poelstra's answer to this StackExchange question. It is enlightening.


you'll want to restrict the RPC, otherwise other people that get access to your node can shut it down.

./monerod --rpc-bind-ip <external.ip.of.node> --restricted-rpc --confirm-external-bind

Binding to the external IP will allow you to connect from outside of your home. You might want to also use --rpc-bind-port <portnumber> if you want to reduce the chance that others will find your open node, like this guy: https://moneroworld.com/#nodes


Hash rate required to effectively mine an average of 1 block a day?

Currently the network hashrate is approximately 22.9 MH/s. There are about 30 blocks per hour and 720 blocks per day.

On average to find one block per day you would need 1/720 of the current network hashrate or approximately (22.9 MH/s)/(720) = 31.8 kH/s today. The relationship between MH and kH is found here


How can I set a wallet to use no-coinbase mode before syncing?

You can ^C while it's syncing in the foreground. The background refresh will take over while you are at the prompt.

^C while not in foreground syncing quits the wallet.


My antivirus (AV) software blocks / quarantines the Monero GUI wallet, is there a work around I can utilize?

A miner is included in the Monero GUI software and, as a result, most anti virus software flags the Monero GUI files as malware and subsequently quarantines them. Fortunately, however, there's a fairly trivial work around you can use. That is:

Create a new directory / folder.

Open your AV software.

Add an exception for the newly created directory / folder. Put differently, you have to whitelist the newly created directory / folder. A guide for Windows Defender can be found here.

Extract the .zip file (in case of Windows) or the .tar.bz2 file (in case of Linux or Mac OS X) to the whitelisted directory / folder.

Note that if you're using Windows and did not install custom anti virus software, Windows Defender is, most likely, acting as active anti virus software.
P.S. We encourage users to check the integrity of the binaries and verify that they were signed by BinaryFate's GPG key. A guide that walks you through this process can be found here for Windows and here for Linux and Mac OS X.


PoW is more secure than PoS in that it costs nothing to try to fork a PoS chain.  An attacker can try to make as many different chains as they can with a PoS chain, but with PoW if you try to fork the chain and you fail, that orphaned block took time and energy, because your computer is hashing away, working.  There is no work needed in PoS mining, therefore PoS chains will never be as secure as PoW.  Proof of Work stops bad actors from just running a script.  The attacker must launch bad workers, which is expensive to do.

See section three of http://bitfury.com/content/5-white-papers-research/pos-vs-pow-1.0.2.pdf


Basically, as long as the wordlist or the format doesn't change, the wallets are forward compatible with respect to 25 word mnemonic seeds. Furthermore, I am certain that, even if the wordlist or format changes, the devs will make sure the old seeds are forward compatible. However, I don't expect either to change in the foreseeable future. There was a minor change in the beginning of 2015, because there was an issue with a few of the words.

Bear in mind that you are always able to restore from keys as well. That is, restore your wallet from the spendkey and viewkey. Therefore, I'd advise to note down these keys too, in addition to the 25 word mnemonic seed.


This syntax is implemented in a mining pool's code. The transfer or transfer_split RPCs would not parse that kind of address.

A monero transaction can have one payment ID (this is a bit more complicated as this is not a consensus rule, merely a semantics agreement wallet side), so if you need to use N payment IDs, you will have to have at least N transactions. You can include destinations with no particular payment IDs along with one with a required payment ID, since having a payment ID where none is required does not mess things up.


A ring may not include the same input more than once. Prior to v6, duplicate ring members were allowed. This is enforced by the protocol (otherwise it wouldn't be a rule, would it).

Distinct rings in the same transaction may include the same input more than once. This is in fact necessary for the corner case of spending 2 inputs of an amount for which there are 11 instances on the blockchain (admittedly, it could still be rejected and you'd get to spend your outputs separately).


Permission denied is typically due to... bad permissions, unsurprisingly. You need at least execute permission (for owner if you own the file, for group if you're on its group, others otherwise).

Here, sudo fixes it, so it's likely you don't have read rights on the directory. Fix that. You probably saved this as root, which is a bad idea in the first place. chown will help here (chown user.group monerod, replacing user and group with your own).

Next, command not found means just that. There's probably no moneroD binary in the . directory. Typically, monerod is called monerod, not moneroD. Double check its name.

Last, if there really is a moneroD, then it might be the wrong excutable format (eg, 64 bit if you're on a 32 bit machine, etc). Double check you got the right binary format.

Anyway, this is a UNIX usage question, not a Monero question, so if further help with this problem is needed after those things are checked, you will be better off asking a UNIX/Mac stack exchange (assuming any further problems aren't Monero ones).


Why do I see only one transaction key R=rG per transaction while there are multiple output keys P=H(rA)G+B to represent multiple denominations?

This question was cross-posted to Reddit and was answered by dEBRUYNE_1 citing luigi1111's article:

  You may have noticed that this scheme only gives Alice one output for Bob per r, but with auto-denomination Monero and other Cryptonote coins have many outputs per transaction. To get different stealth addresses for each output, Alice (and Bob) append an "output index" (an output's position in the transaction: 0, 1, 2, etc.) to D before hashing it to create the secret shared scalar f. This is a bit of a clarification to Alice's step 2 on unlinkability. That is, while the shared secret D is already unlinkable to observers, appending an output index allows "unlimited" additional unlinkable outputs to be created from one shared secret (see point 3 in the hash section).


Not implemented and integrated into master branch yet, see here:

https://github.com/monero-project/monero/pull/2056


Cheapest GPU that is possible to mine on

Cheapest GPU is the one you have available. I mean, you can start mining with an integrated GPU like an AMD Radeon HD 7480D and get around 50 H/s.

If you want a full list of GPU Benchmarks, feel free to check my website:

http://monerobechmarks.byethost5.com/

Website's Reddit Thread

Website's Bitcointalk Thread


Why does my pool say my hashrate is lower than what my computer reports locally?

The hashrate that is reported by the pool is an average over some time period - for example the original core pool implementation uses a window of 10 minutes (600 seconds) to compute the average.

Your miner probably reports the average hashrate over a shorter window.

That could be the reason why you may observe discrepancies at a particular moment in time (if your miner has mined more slowly at some point over the past 10 minutes).


How can I use the SpendProofV1 to prove I sent Monero to an exchange?

The SpendProofV1 string contains a second, newly created ring
  signature that proves exactly the same input ownership again, but
  using different random initialization data. Only someone that owned
  the inputs of the transaction would be able to create this second
  valid ring signature. That is all the SpendProofV1 string contains.
  There is no key derivation communicated, because it is unknown by the
  wallet in this scenario.

(See What is the "SpendProofV1..." or "OutProofV1..." in the details of a sent transaction in the GUI?)

Therefore you need to send both the transaction ID and the SpendProofV1 string. The exchange will be able to use this information to verify that you sent the funds.


Can an output public key appear more than once in the blockchain

Is this possible?

Yes. It can appear in multiple blocks / transactions. It being an input/output doesn't make it the real one vs a decoy though.


Is there a website like blockchain.info but for Monero?

Sure, there are many block explorers. But there's a key difference, you can't look up addresses and balances because those don't technically exist on Monero blockchain!

You can decode a specific TX but only if you know in advance the matching address+viewkey or address+TXkey.

Here's a quick list:

http://moneroblocks.info/
https://explorer.xmr.my/
https://monerohash.com/explorer/
https://xmrchain.net/


restore deterministic wallet from specific date (YYYY-MM-DD) - Error: specified date is in the future

I know now what the problem is:
monerod is still syncing and above date is "in the future" because monerod did not get until 2017-04-21 yet ...


Difference between Unlinkability and Untraceability

With Monero, unlinkability means that you can display your receiving address publicly yet all payments made to this address cannot be linked to it.

This phenomenon is accomplished with the use of one time use stealth addresses for every single transaction.

Monero untraceability is provided by ring signatures each transaction uses multiple cryptographic signatures controlling multiple outputs to mix with the outputs of the sender. An observer cannot tell which outputs are controlled by which party providing untraceability (and plausible deniability) for everyone included in the ring signature.

It is possible to have unlinkability without untraceability. In fact there are many coins that offer one time use stealth addresses. Monero (and other CryptoNote currencies) are different because the use of stealth addresses is automatic and mandatory. If one time use addresses are not used every time, user
and network privacy is decreased. Monero makes it easy to obtain a high level of privacy by automating this process at the protocol level.

Ring signatures did not exist in any cryptocurrencies until it was introduced by CryptoNote. There are technologies that used mixing (CoinJoin) to make tracing Bitcoin (for example) transactions more difficult. However more difficult tracing is not the same as untraceable, particularly with the rise of companies offering blockchain analysis tools such as ChainAnalysis and BitCluster


The genesis block is automatically created for you from the genesis transaction and the genesis nonce that is hard coded here: https://github.com/monero-project/monero/blob/3ad4ecd4ff52f011ee94e0e80754b965b82f072b/src/cryptonote_config.h#L162

If you don't care about receiving the funds generated in the genesis transaction, then you can leave it unaltered and just choose any random value for the GENESIS_NONCE in the code mentioned above.

If you do want to receive the funds from the genesis block transaction, then you need to understand how to change the transaction, which is currently hard coded as 013c01ff0001ffffffffffff03029b2e4c0281c0b02e7c53291a94d1d0cbff8883f8024f5142ee494ffbbd08807121017767aafcde9be00dcfd098715ebcf7f410daebc582fda69d24a28e9d0bc890d1

To understand what the different fields in that transaction mean, see How can I create a new Monero genesis block?

To understand what you need to change about that transaction, see Monero Genesis transaction & nonce, specifically:

  create a wallet address and then create a transaction destined for
  your wallet on the main Monero network. You could then use a
  blockchain explorer to inspect the tx public key and output one-time
  public key, and copy/paste that into the genesis transaction.

Therefore, after creating your transaction on the main Monero network, alter the output #1 key field in the genesis transaction to match the output key from your transaction, and alter the transaction pubkey field in the genesis transaction to match the transaction public key from your transaction.

This will cause the destination of the genesis block funds to be your wallet.


What do Monero addresses have in common?

A more technical answer on how addresses are generated is provided below, as found here. Any similarities between the addresses are a consequence of how they're created.
As you can see, the first byte is always the same which, when encoded to base58, results in addresses starting with "4".

  To create the actual Public Address, the following is performed:

  The pair of public keys are prepended with one network byte (the number 18, 0x12, for Monero). It looks like this: (network byte) +
  (32-byte public spend key) + (32-byte public view key).
  These 65 bytes are hashed with Keccak-256.
  The first four bytes of the hash from 2. are appended to 1., creating a 69-byte Public Address.
  As a last step, this 69-byte string is converted to Base58. However, it's not done all at once like a Bitcoin address, but rather
  in 8-byte blocks. This gives us eight full-sized blocks and one 5-byte
  block. Eight bytes converts to 11 or less Base58 characters; if a
  particular block converts to <11 characters, the conversion pads it
  with "1"s (1 is 0 in Base58). Likewise, the final 5-byte block can
  convert to 7 or less Base58 digits; the conversion will ensure the
  result is 7 digits. Due to the conditional padding, the 69-byte string
  will always convert to 95 Base58 characters (8 * 11 + 7).
  This 95-character result is the (obscenely long) Cryptonote Public Address!
  If you're creating an integrated address, simply append the 64-bit payment ID to step 1 and continue; everything else is the same except
  for the lengths (77 bytes total, 106 Base58 digits) and the prepended
  byte (19, 0x13).


Why is there only a single implementation of mining pool software?

Lack of different implementation may look like lack of interest but in this case its most certainly that the current implementation by zone117x going solid for 2+ years and the first open-source for CryptoNote coins is good enough. There is another pool software implementation being run by Minergate but the client and server-side is closed-source.


Where is the code that compute the stealth address

The implementation of that white paper formula is actually P = Hs(8rA || i)G+B.

The 8 is there to force the rA EC point to be in the group of the base point G, even when A is a malicious point which is not in the base point group (i.e. is not a multiple of G).

The || symbol means byte concatenation, i.e. concatenate the bytes of the compressed representation of the EC point 8rA with a varint byte representation of the output index i. The output index is appended so that multiple outputs to the same recipient won't have identical public keys (which would be a disaster, because then they'd also share the same key image and only one of them would be able to be spent).

On this line you'll see a call to generate_key_derivation: https://github.com/monero-project/monero/blob/102a51bcd48a3cd2cb794aab7dbe243393f155b3/src/cryptonote_core/cryptonote_tx_utils.cpp#L393

The generate_key_derivation method calculates the 8rA part using ge_scalarmult to calculate the rA part and using ge_mul8 to turn that into 8rA.

On this line you'll see a call to derive_public_key https://github.com/monero-project/monero/blob/102a51bcd48a3cd2cb794aab7dbe243393f155b3/src/cryptonote_core/cryptonote_tx_utils.cpp#L408

The derive_public_key method takes the already calculated 8rA, uses the derivation_to_scalar method (which in turn uses the hash_to_scalar method) to produce Hs(8rA || i), and then uses ge_scalarmult_base to multiply it by G to get Hs(8rA || i)G. Finally it adds B to get the final result Hs(8rA || i)G+B.

You'll see some confusing methods like ge_p3_to_cached and ge_p1p1_to_p2 etc. This is because the most efficient way of performing different operations on EC points is to convert them into different representations prior to particular operations. For more information, see "Faster Addition and Doubling on
Elliptic Curves" https://cr.yp.to/talks/2007.12.03/slides.pdf


What resources are required for running a Monero mining pool?

Overall

The bandwidth usage for running a pool is surprisingly low. Any given month my pool mine.moneroworld.com only has 1-2% utilization of a 2TB allowance. The cost comes in the actual hardware.

  10's of users

I am currently running mine.moneroworld.com on a 2$ / month VPS with 1 gig of ram and 2 virtual CPUs. (for those that mine there, why do you think the fee is so low? :) ) It can handle "real" users well enough, upwards of 50 miners.

That scale, however, can not handle "fleet" level miners. One miner has access to about 3,000 mining computers and can direct them to a pool all at once. This particular miner can essentially kill my pool.

  For 100's of users

You could probably use a very high end VPS or a cheap dedicated server. (somewhere around 20-30$ / month)

  For 1000's of users

High end dedicated hardware is required (pending any pool efficiency improvements). I've seen the operator of the mega french pool write that the pool uses upwards of 4 servers to distribute the load.

  Caveats

Some of the resource utilization can be modified to increase pool efficiency. For instance, you can change the block template creation rate, because this is CPU intensive. You can also change the share submission time window - each share submission is data over the network. So if you allow a share every 5 seconds, your server needs to be able to handle a share every 5 seconds. And the existing pool code is incredibly inefficient for some tasks.


Why does imported wallet not show correct balance?

Don't import it, just create an entirely new wallet on MyMonero and just send all your coins from CakeWallet to MyMonero. This gives you the following benefit:

You won't have to rescan the entire blockchain from where your old wallet started and just start scanning today. Saving ALOT of time.

Don't import just send the entire thing over.

But if you want to keep your old transaction history for whatever reason, you'll have to pay that import fee.


Can Monero's privacy features be integrated into (copied) by bitcoin?

The simple answer would be no. The codebases simply aren't in any way similar. Bitcoin devs would need to do a massive rewrite of the code to implement ring sigs with confidential transactions, it would require a hardfork and would likely break functionality with code outside of Bitcoin such as wallets and such.

The longer answer would be maybe. It could possibly be integrated as a sidechain, but even then, it would not be as private as Monero's implementation as it would not protect fungibility on the Bitcoin blockchain, so chainalysis would still be possible, albeit harder. Given that, it would likely be a huge amount of effort for little gain.


It depends on the specs of your laptop, but that sounds like a plausible hashrate if your laptop is older or running other applications.

I have a desktop that using the xmr-stak miner can just squeeze 86H/s out of an overclocked i7 2600k. Given the restrictions placed on processors in laptops, I would imagine that they can be far lower than that.

Try using different miners if you haven't already, but be aware that CPU mining is not profitable compared to the enegry input. GPUs, particularity AMD GPUs, are much more efficient per watt when mining on Cryptonight (Monero's algorithm) and tend to effect the overall usability of your machine less.


Could a prediction market like Augur be built on top of Monero?

In the future, yes. Check out the Tari announcement. This, alongside the ongoing work at the Monero Research Lab to bring daughter-chains to Monero, is a big step forwards towards Layer 2 capabilities.


The entire lifecycle of an XMR transaction with RingCT

I'll do my best to answer:

1) Actually it starts with the wallet, not daemon, aggregating the inputs for spending.

2) The wallet asks the daemon for the mixins (decoys)

6) All values are encrypted as Pedersen commitments

6.1) They are also Pedersen commitments

6.2) Key Images are actually on each txin

8) Receivers wallet (receiver) checks each txout stealth address to see if it belongs to them. The wallet does Hs(aR)G + B with a being the receivers private view key, R being the tx pubic key, G the Ed25519 base point and B being the receivers public spend key. If the output stealth address matches Hs(aR)G + B, the wallet then checks to ensure it's not already spent by computing it's key image and checking the blockchain. This is the purpose of key images, to check whether an output is already spent (double spend protection).


Does mining require a daemon that allows incoming connections (open firewall ports)?

You are confused. The 8+0 does not mean this. The difference between the two types of connections are who initiated it: your daemon, or a peer. Data can flow in both directions, regardless of whether it was initiated locally or by a peer.

This also means that mining does not need incoming connections. It can work as well with or without.

Not allowing incoming connections makes the network fractionally more unstable. If you don't have incoming connections, there are less possible links between nodes, and the "depth" of network interconnectedness is less than it would otherwise be. Push to the extremes and you see it becomes easier to split the network in several parts, since you have less connections to sever.

As a last point, outgoing connections to not need open firewall ports. Incoming connections do. This might have been a mere typo though, but let's add this in case it's a real misconception.


How to view properties of a wallet opened with the monero-wallet-cli

The command to view the properties is the set command. You can access it like this:

./monero-wallet-cli --daemon-host XMR_NODE --wallet-file WALLET_FILE \
    --password 'XXXXX' set

To set a property, you just run the following:

set ask-password 0


One more question about sign transaction on cold-wallet node via wallet-rpc

If you call transfer or transfer_split on a hot wallet, you'll get data back in the unsigned_txset field. This was not yet present when you posted your question.

This unsigned_txset data can then be conveyed to the cold wallet, which signs it with sign_transfer, which gives you back a signed unsigned_txset field.

In turn, this is conveyed to the hot wallet, which then uses submit_transfer with that data.


If I update the Monero GUI, do I need reinstall the blockchain?

You can update the GUI and continue to use the blockchain already downloaded.


What's the smallest transaction you can send?

You can send as little as 1 "piconero" (1 atomic unit). This makes no economic sense of course, as the fee will be at least 2 billion times larger (depending on number of inputs).


How does a Monero pool confirm/reject a submitted nonce?

The hash_accepted field is the response from the proxy server for when a hash is acknowledged by the server the hashes field is the number of hashes the worker has submitted in the past.

When the server gets a new connection it sets it up like so:

var conn = {
    uid: null,
    pid: crypto.randomBytes(12).toString("hex"),
    workerId: null,
    found: 0,
    accepted: 0,
    ws: ws,
    pl: new net.Socket(),
}

This creates a variable called accepted and set to 0. now when a valid share is called this snippet of code is called which increments the accepted hashes and responds to the client:

conn.accepted++;
buf = {
    "type": "hash_accepted",
    "params": {
        "hashes": conn.accepted
     }
}

These code snippets are pulled from the server.js file on the CryptoNoter Github page, found here


Who is behind monero and how does is compare to other major crypto currencies?

Monero is open source, I don't think one can talk about a 'leader' of monero, though Riccardo Spagni (nick: fluffypony) might be considered, though I'm quite sure he wouldn't introduce himself as that, he is one of the main devs and also the 'public' spokesperson for monero. Also see this for a list of the core team members: https://getmonero.org/knowledge-base/people
I don't think (don't know) any processes to 'avoid' a hostile take over,however, if the community would be convinced that such thing had taken place the could always fork monero away from the current devteam, because monero is open source, that's not difficult to achieve...

Bitcoin used to be the same way I think, with off course as most important person Satoshi Nakamoto, but also lots of freelance contributors/developers, now bitcoin seams to much more corporate (blockstream: https://blockstream.com/) with a hierarchical structure and paid developers. Ethereum on the other hand has always been a corporation with an ICO (initial coin offering), a CEO (Vitalik Butterin) and paid developers... Whether it's a ponzi or not, I leave in the middle...

for more information about the history of monero, one could start by looking over here: https://www.reddit.com/r/Monero/comments/3f2fpd/the_strange_birth_history_of_monero_part_i_wtf_is/


How does the CPU RAM affect the hashrate?

What you mean is CPU cache, not RAM. In general, the bigger the cache, the better for mining Monero.

You can have as much mining-threads as you like but you need 2 MB cache for one thread. So if your CPU has for example 4 MB L3-Cache, the optimal number of threads is 2. If you have 3 MB, you should use 1 thread.

So all depends on the size of the CPU cache


Is there a config file for monero on ubuntu / linux installs?

The default configuration filename is bitmonero.conf. You should create it in the default data directory for your appropriate operating system.

Just add:

data-dir=[/path/to/your/new/dir]

On Unix/Linux/macos systems, the default directory is ~/.bitmonero


After calling get_transactions, you will have a list of the ring members in the vin.key_offsets field. You can then lookup these outputs using a call to get_outs.

An example of both calls:

curl -X POST http://127.0.0.1:18081/get_transactions -d '{"txs_hashes":["a6eb34ec1893ce43630efc2f2dfa98cde2d5e7f37c18d1d8303f3a6436a4cc9f"],"decode_as_json":true}' -H 'Content-Type: application/json

Returns 5164903, 2019770, 392759, 121787, 5621, 4659, 833, 1353, 6326, 487, 682 as the key_offsets (the ring members).

Each output after the first is incremented by the sum of the previous indexes. So the first member is at index 5164903, the 2nd at 7184673 and so on.

So translated, these outputs are then:

5164903, 7184673, 7577432, 7699219, 7704840, 7709499, 7710332, 7711685, 7718011, 7718498, 7719180

To get further information on each ring member, you can then call get_outs like following (which gets the first and last):

curl -X POST http://127.0.0.1:18081/get_outs -d '{"outputs":[{"index":5164903},{"index":7719180}]}' -H 'Content-Type: application/json'

Which returns:

{
  "outs": [{
    "height": 1545783,
    "key": "6dcc42839619ea4e1b1cb1b28d45659916207a445ec00e06ece45a7b7bfc1264",
    "mask": "449ce062721cbde5f282eeb292eb27636539b29c81a396fddeede73c72d0a66e",
    "txid": "124f70eb30ace64d577d82f193e0057b07fc4bdb053bf228dfc00b4e1099b1f1",
    "unlocked": true
  },{
    "height": 1694891,
    "key": "1089839b83fd45f7ab87a64398aad45176be4e6ee44872cf37c544358904d61c",
    "mask": "3f22409779524a01dc998e58fbccb58a02ca37e6e6be784f11d7b67dbdaf87e3",
    "txid": "4b1580e241b5499dd19faebc6c3c2dbf9bbb8a6c8144f538863fb3e71db10bd1",
    "unlocked": true
  }],
  "status": "OK",
  "untrusted": false
}


Can you only allow certain miners on a cryptonote blockchain?

A typical blockchain does not include this kind of access control. This includes Cryptonote. However, you can easily add something similar.

Now, daemons could be made to sync only from the set of IPs you specify. If all the allowed IPs are set to only connect to other IPs in the set (for example  using --add-exclusive-node), and set to disallow connections from other IPs, then you will achieve this, absent an attacker.

However, this is fairly brittle, as a single peer managing to connect to one of these allowed IPs will open the floodgates to a new blockchain. Moreover, you might want external IPs to have a "read only" view of the blockchain, so you might well want yourself to have your allowed IPs connect to external IPs for blockchain distribution.

A better way is to allow not by IP, but by public key cryptography. The high level steps are:

create a key pair
give all allowed miners the secret key, which they should keep secret
give any node asks the public key (ie, include it in the source code)
when mining, add a signature of something (say, nonce plus block height) in the coinbase tx's extra field
add a consensus rule that checks this signature is valid

Then mining is limited to those who have the secret key.


What are the benefits of restricting difficulty while mining?

the pool difficulty is basically how often your miner communicates back to the pool the work it has done. a lower difficulty does fewer hashes before sending results. if the difficulty is too low it will contact the pool too often possibly overwhelming the server, and you may get temporarily banned for spamming the server.


Does the latest Monero release (Nov 2019) contain I2P and Tor only in CLI or in the GUI too?

Actually, tor/i2p support has been in Monero since the previous release, not just the last one.

With regards to your specific questions:

The releases don't "contain" tor/i2p, rather they have options available to integrate with a local tor/i2p router to broadcast transactions over tor/i2p. See ANONYMITY_NETWORKS and README.
The settings are in the daemon. Therefore anything that uses the daemon (which is both GUI & CLI wallets), can use these options.
This is subjective. Some people will find the GUI simpler and some the CLI. The official GUI and CLI both offer the same levels of privacy.
The answer here depends. If you are using the built-in tor/i2p options, this is specifically for transaction broadcasting as of now. The functionality is present to help prevent linking a transaction to an IP address. Syncing blocks would still occur over clearnet.
They could - and that's the point. If you need to hide the fact you are even running Monero, you will need to route all your traffic through tor/i2p. This can be configured in your operating system (see the README).
When you say "download the blockchain" I assume you mean the raw blockchain file, and no, there is no privacy benefit to downloading this before downloading the CLI/GUI. There really is no benefit to that raw file at all these days - it was provided at a time when syncing the blockchain in the daemon was on the slow side - nowadays the sync speed has been significantly increased.


Is there a way to compile an AMD based miner for use on a mac?

Try the following:

brew install openssl libmicrohttpd
git clone -b dev https://github.com/fireice-uk/xmr-stak-amd
cd xmr-stak-amd
mkdir build && cd build
cmake -DOPENSSL_ROOT_DIR=/usr/local/opt/openssl -DOPENSSL_INCLUDE_DIR=/usr/local/opt/openssl/include/ ..
make

It may be necessary to insert the following line in CMakeLists.txt:

include_directories(/usr/local/include)

To run the executable:

cp bin/xmr-stak-amd ..
cd ..
./xmr-stak-amd config.txt

Note that the config.txt file and the opencl folder should be on the same location as the executable xmr-stak-amd.

You'd need to tweak the config.txt file to figure out the best setting for your GPU. To get you started, I've posted below the worst performing setting that should work on any GPU:

https://gist.github.com/stoffu/fa9a35928e0f6325f9d379c2d902d7cc

Relevant post on Reddit:

https://www.reddit.com/r/Monero/comments/6cla1s/can_someone_please_help_me_to_compile_xmrstakcpu/dkubnr4/


Please check that you have more than 0.3 XMR because it is the minimum payout value.

Pool Config:

PPLNS Fee                   0.6%
Solo Fee                    0.4%
BTC Fee                     1.5%
Minimum payout (Wallet)     0.3 XMR
Minimum payout (BTC)        4 XMR
Minimum payout (Exchange)   4 XMR


Block 1: New Job means that your GPU is starting a new process for the mining. 'diff' means how difficult the block is. Can't help for the rest.

Block 2: 1320/2700 MHz(Megahertz) means that your GPU clock is running 1320 MHz out of a max 2700(See block 4).

Block 3: 'Accepted' mean that the result you got might be a viable hash for solving the block.

Block 4: That is low make sure your graphics cards are being forced to work as hard as possible.


Why is there no P2Pool for miners?

Because no one has developed it yet.

Additionally, a 2 minute block time is very difficult to work with for a p2pool system. AFAIK, the p2pool system works because there are 30 second blocks in the p2ool sharechain, while there are 10 minute blocks in the bitcoin main chain. So, every 30 seconds there is an agreement amongst all the miners in the "pool" regarding how much work everyone has done.

So essentially, in monero, if the same p2pool architecture is used, there would need to be a secondary chain that is capable of reaching consensus in between the time when the real Monero chain reaches consensus.


The second line of the log indicates Address already in use, which means that the address the daemon is trying to use (0.0.0.0:18080) is already used by some other sofware on your machine. As if there was already a monerod daemon running.


I find the info in the ANONYMITY_NETWORKS.md document to be somewhat opaque and the cost of misconfiguring your anonymity network could be high.

I wouldn't use the term "opaque", rather they are detailed and expect a certain level of competence. There's really very little "cost of misconfiguring", rather things just wont work if misconfigured. At worst you will be just using a node like you currently do, over clearnet, and at best, working correctly broadcasting txs over anonymity networks.

  Under what conditions would you choose add-exclusive-node instead of add-peer?

This is more a monerod question than an i2p/tor question. Here is the help on those options:

--add-peer arg                      Manually add peer to local peerlist
--add-exclusive-node arg            Specify list of peers to connect to
                                    only. If this option is given the
                                    options add-priority-node and seed-node
                                    are ignored

So you see, they have different purposes.

Where the question relates to i2p/tor comes into how the tor/i2p integration works - quoting the documentation:

  Only handshakes, peer timed syncs and transaction broadcast messages are supported over anonymity networks. If one --add-exclusive-node p2p address is specified, then no syncing will take place and only transaction broadcasting can occur. It is therefore recommended that --add-exclusive-node be combined with additional exclusive IPv4 address(es).

Hence, to allow your node to broadcast transaction over tor/i2p you can --add-exclusive-node <tor/i2p-node>, but then if you also want the same node to be able to sync blocks (over ipv4), you also need to --add-peer <clearnet-node>.

  "If configured properly, additional peers can be found through typical p2p peerlist sharing." What is the proper configuration that achieves this?

Configured properly, meaning you have configured for outbound tor/i2p connections (e.g. set --tx-proxy and added one or more tor/i2p nodes).

  Does this mean you specify one anonymous peer manually and it will discover the rest?

If you connect to another tor/i2p peer that also has connections to other tor/i2p nodes, yes, you will receive peerlists which include other tor/i2p peers.

  Where does one find a list of peers to add manually? Is the one given in the document a real one intended for use, or just an example?

One can run their own tor/i2p peer by following the documentation for inbound connections. One of the things we hope to do (largely for the single-click GUI users use-case answered in your other question), is have a few community run/maintained seeds which operate on tor/i2p. This removes the need to run your own tor/i2p node, though just like with standard remote node usage, places a certain amount of trust in those remote nodes.

  Does one need anonymous-inbound if you're only running your node locally and connecting to it from a local wallet, or is anonymous-inbound necessary for participating in the p2p network?

--anonymous-inbound is necessary if you plan on running a full node that is made available to other node/wallets over tor/i2p. This maybe your own node on a VPS server which you plan to use over tor/i2p and/or make available to other users who need access to a node over tor/i2p (like the example peers available to GUI users mentioned above).


Are there any linux drivers for msi graphics cards?

You want an nVidia driver for linux that will support the GTX 760, which covers your graphics card. Here is one such driver, though newer drivers likely also work:

http://www.nvidia.com/object/linux-display-amd64-319.32-driver

I would guess that mining with that card might be okay from an income perspective, but the electricity costs will probably also be high.

This post would seem to get you started on how to actually mine on linux:

https://steemit.com/monero/@mobidick/how-to-mine-monero-on-ubuntu-16-04-using-ccminer-cryptonight


What ports should I forward on my router to be most useful to the network?

As I answered to your previous question, you do not need to forward any ports for the p2p interface. This is the interface nodes use to send each other data, such as blocks. transactions and peerlists. Other nodes can sync with you fine without router port forwarding because when you initiate an outbound connection to a peer, it is kept open, thus data can be both sent and received. More important for p2p traffic is how many connected peers you allow and how much bandwidth you allow. Settings already explained.

Wallets however need to talk to nodes over the RPC interface. Thus, if you want to help wallet users who don't run their own node, you can forward the RPC port to your RPC listening port (in your example this is port 18081). This you do on your router, normally under a section named "port mapping" or similar. You will be filling in details to tell your router to "make requests coming to port 18081 go to computer your.local.ip port 18081"


I set up my public node to use port 18089, but why does monerod keep trying to connect to port 18081?

The default config file location is actually in ~/.bitmonero/bitmonero.conf, so if you are using another location, you need to start the daemon with --config-file /etc/monerod.conf in your case.

Or if your domain is, as you say, already running on the port 18089, to run the status command you would need to:

monerod status --rpc-bind-port 18089


How can I get Wolf's open-source AMD miner to work on Ubuntu?

There is a problem with amdgpu and Gnome on the kernel 4.4 (default kernel with ubuntu 16.04). So If you want to use Gnome, Install a new kernel before installing the drivers :  example
Install amdgpu-pro
Install the latest AMD APP SDK
Install required dependencies and tools: "sudo apt-get install libcurl4-openssl-dev build-essential libjansson-dev"
Edit the Makefile : add "-I /opt/AMDAPPSDK-3.0/include" to the ligne that starts with "OPT"
Compil : run "make"
Edit xmr.conf : for the RX 480, rawintensity:960 and workersize:8 seems to give the best results
run "sudo ./miner xmr.conf"


monero-wallet-cli Wallet asks for password on Ubuntu but not Windows

Because the MSYS console is buggy and reports that the console is not a TTY. leading Monero to think it must read from a file (and thus not prompt). Apparently it works on a non MSYS console.

See https://github.com/monero-project/monero/issues/3951 for details.


Is there a way to force sync on Monero GUI?

Under the Settings tab you can click the Show Status box.  If you want to leave this open, it will intermittently post the daemon status(I am not sure how often it updates though), or if you prefer, you can type a few commands to activate info manually(the command box is to the right of the Close box; this is your CLI interface for the GUI).

Commands to see status of daemon: status or sync_info

You can also type help to see the rest of the commands and what they do.


Is a Monero hardfork to replace stolen funds impossible due to its untraceability

Due to the nature of mixins in the ring signatures you cannot be 100% sure that uninvolved transactions would not be affected in such event, the blockchain as a whole could be rolled-back for a single incident but it is unlikely to ever happen since no entity holds this kind of power over the Monero blockchain.


Overview of what happens when I run monerod diff

I may be wrong but I assume this is the code initialized when you run "diff" in monerod.

  uint64_t now = time(NULL);

  uint64_t diff = ts > now ? ts - now : now - ts;

  if (diff > 24*3600)

    strftime(buffer, sizeof(buffer), "%Y-%m-%d", &tm);

  else

    strftime(buffer, sizeof(buffer), "%I:%M:%S %p", &tm);

  return std::string(buffer);
}


Monero-wallet-gui: while synchronizing, blocks remaining number increases

The problem was solved by updating the GUI to the latest version.


Why are the Monero GUI components (exes) flagged by AV as malware?

Probably because they contain mining code (should you want to mine). Also because we don't code sign with a commercial certificate from Microsoft.


Missing 1 character in Monero address generation from a seed using Javascript

You aren't doing any padding.
See your related Q/A.
You have to pad blocks with '1's that convert to less than 11 characters.


Is there somewhere I can see a graph of current and future inflation rates of supply?

This spreadsheet compares Monero's emission with that of Bitcoin.
https://docs.google.com/spreadsheets/d/1qXi7zUSIh7F6UuSuhOryyFbHEy_LJuym3I3neAga_2s/edit#gid=239466694

Credit to luigi1111 for making this.


Would it be possible to use PoS on Monero without corrupting privacy and if possible how?

It is possible to generate a proof of balance (reserve proof), which states you own at least the claimed amount.
See rpc doc about it.
So theoretically, it is possible.


Will Chained Mempool Transactions ever be possible?

in addition to janowitz answer, chained transactions in monero are currently impossible because inputs are referenced with an index ID that is created when the tx makes it into a block. Thus, in order to make chained txs possible, the system would have to be reworked such that transactions are referenced by a unique identifier, so it doesn't matter where in the chain they end up. This reworking is also important for chain reorganizations.


How is the one time address generated from the public address?

A one time address for Bob is generated by taking a random r, multiply by Bob's public spend key, hash the result and multiply it by the curve base point, adding (in ECC terms) Bob's public view key.

The private key can be derived from this public key without further information.

See 4.3 in https://cryptonote.org/whitepaper.pdf for the details.


The Hs value in your failing transaction is incorrect. You've written 4e2918eb07facce065c1fcfe610a5b7d18064d64a7b8844d1844872f6d60159f but it should be f9b573a61a7e27c8dc3d48448e4184c117064d64a7b8844d1844872f6d60150f.

This is happening because your Hs function is doing keccak but not sc_reduce32. You were lucky that in the first transaction, the result of the keccak was lower than the "l" value used in sc_reduce32, so it didn't matter in the first transaction that you didn't do it.