How to sign a message with my public monero address and verify it using the cli / gui / javascript app?

Sign & Verify using the cli

You can sign a file (which may hold your message) using the cli sign command like this

sign <file_to_sign>

The signature will be printed to the screen.
You may then provide this signature to someone else to verify. The command to verify is

verify <filename> <address> <signature>

Try it yourself

You may reproduce those steps and make sure you get the same results:
Create a wallet using the seed austere locker smelting nozzle wagtail tuxedo acidic earth rover utility value tomorrow unusual vipers ferry dynamite algebra agenda rarest number rotate avatar deftly elapse avatar

(do not use this seed for anything else except this test)
Create a file named msg_file whose content is my message. sign the file:

[wallet 47e7vP]: sign msg_file
Wallet password:
SigV1XED2SBdQuN37x5h73fzVorD6JSZaTBKfaA7mFx6pHnQp5Z9UnysaQKdYkJRKFhNMLVMrw2z7GJkzB1e5EnkD6ska

This is your signature. Then verify the signature:

[wallet 47e7vP]: address
47e7vPdJA3WQbJRjT3WmGdSfocofRUiAYMTJSnjPAZwCfDcAmz2oBEZYV5KGJSYAA13Bj7D2bXiaWTfvKCfbDkDY2kuUFMf
[wallet 47e7vP]: verify msg_file 47e7vPdJA3WQbJRjT3WmGdSfocofRUiAYMTJSnjPAZwCfDcAmz2oBEZYV5KGJSYAA13Bj7D2bXiaWTfvKCfbDkDY2kuUFMf SigV1XED2SBdQuN37x5h73fzVorD6JSZaTBKfaA7mFx6pHnQp5Z9UnysaQKdYkJRKFhNMLVMrw2z7GJkzB1e5EnkD6ska
Good signature from 47e7vPdJA3WQbJRjT3WmGdSfocofRUiAYMTJSnjPAZwCfDcAmz2oBEZYV5KGJSYAA13Bj7D2bXiaWTfvKCfbDkDY2kuUFMf

If you sign the file yourself you will probably get a different signature than me. This is because the signing is not deterministic. Nevertheless, you should be able to verify my signature without problems.

Sign & Verify with another application using RPC

You can also use the official wallet rpc server (monero-wallet-rpc) to sign and verify from another application, using http request.
Start an rpc server by running monero-wallet-rpc with your desired flags. Assuming your rpc server runs on the local machine (localhost) and listens to port 18082, from the terminal run:

curl -X POST http://127.0.0.1:18082/json_rpc -d '{"method":"sign", "params":{"data":"my message"}}'

which will give you back:

{
  "id": 0,
  "jsonrpc": "2.0",
  "result": {
    "signature": "SigV1BwFKNzqm3YjbkkqVQ97TZCewPuqX5e6YZBuV6gkaXQXcAFfVEMBrMMVfYhax7hAcrJM7nHVW94APvPpV7NJRSEJB"
  }
}

Then to verify, run:

curl -X POST http://127.0.0.1:18082/json_rpc -d '{"method":"verify","params":{"data":"my message", "address":"47e7vPdJA3WQbJRjT3WmGdSfocofRUiAYMTJSnjPAZwCfDcAmz2oBEZYV5KGJSYAA13Bj7D2bXiaWTfvKCfbDkDY2kuUFMf", "signature":"SigV1BwFKNzqm3YjbkkqVQ97TZCewPuqX5e6YZBuV6gkaXQXcAFfVEMBrMMVfYhax7hAcrJM7nHVW94APvPpV7NJRSEJB"}}'

to get the result

{
  "id": 0,
  "jsonrpc": "2.0",
  "result": {
    "good": true
  }
}

Obviously, you can use this method with any application that supports http requests.

Note, signing a text file with the cli, and signing the text using rpc are two different methods, and you can't take signature from one method and verify it using another. This means you should use the same method both for signing and verifying.


How can I tell what difficulty my solution is?

You can find the difficulty of a submitted hash (which is just a big endian hex encoded string) by dividing the base difficulty (2^256-1) by your hash.

As such, nodejs-pool (the most common pool software), checks your submitted hash difficulty as follows:

let hashArray = hash.toByteArray().reverse();
let hashNum = bignum.fromBuffer(new Buffer(hashArray));
let hashDiff = baseDiff.div(hashNum);

if (hashDiff.ge(blockTemplate.difficulty)) {
    // valid here against block, so mined a block
} else if (hashDiff.lt(job.difficulty)) {
    // invalid here (this is where you are failing the test)
} else {
    // valid, record share
}

Using your supplied hash and target (which is also BE encoded hex string) you would yield:

job.difficulty = 4294967
hashDiff = 472

Hence it is of low difficulty (thus an invalid, low difficulty, share).


Why does Monero not softfork like Bitcoin does?

Let's first define the terms:

Hardfork means that nodes running old and new software will have a diverging view of the blockchain.  They'll be on their own fork, playing by different rules.

Softfork means that even though nodes running old and new software have a different view of the blockckhain the blockchain doesn't fork.

Let's now take RingCT (RCT) as an example of a fork.  This is a huge update so old and new software will have different views of RCT transactions.  Nodes running old software won't understand RCT so they'll view RCT transactions as invalid and blocks containing RCT transactions as invalid.

Now we have two choices:

Disguise RCT transactions in some manner so they'll look like old transactions.
Let the old nodes reject RCT transactions.

If we opt for 1. We're adding complexity in terms of the implementation code but also complexity we have to deal with when analyzing the network itself.  This is unavoidable because not only do we have to implement a new thing, but we also have to make it look like something else.

We're also creating another, more subtle, problem for ourselves.  All the old nodes on the network are now zombies.  They're there, but they're not doing any validation (they can't, because they don't understand the new rules).

To make matters worse, it's very hard for anyone to reject the new rules.  We can't upgrade, because we don't want the rules, but we can't do nothing either because we'd be turned into a zombie.  To object we'd have to implement our own version of the software which explicitly rejects valid transactions just because they are implementing the new protocol!

If we opt for 2. We have the problem of forcing everyone to take a stand. The chain will split in two.  Those running old software will be on one chain, those running the new software will be on another.

In most cases the old chain will simply die, because nobody finds it valuable.  But sometimes, we'll get in a situation where both chains have perceived value, like with Ethereum and Ethereum Classic.

And now, we're finally in a position to answer the original question.  Are hardforks or softforks safer?

Hardforks are safer because they reduce complexity (both in the implementation code and in the network's rules).  They ensure all nodes on the network are validating.  They force people to regularly update their software (to increase performance, patch security holes etc).
Softforks are safer because they prevent the community from fracturing (by taking away choice).


What is the purpose of running a Monero node?

Purpose is to independently transact yourself, and verify the blockchain state yourself. If you don't need to transact or check transactions, you don't need to run a node.

If you don't run a node, you must rely on others to do the checks for you and broadcast your TX to the network when you want to transact.

And no, nodes don't make any profit unless they also mine.

For average user behind NAT (like me), he's hardly contributing to the network (as he's not accepting connections, and is connected to 8 open nodes by default) and his node is mostly of use to only himself. Nodes with lots of connections and high bandwidth are those which actually matter to the network and form its backbone: nodes of pools, exchanges, wallet providers, block explorers, big services, enthusiasts etc. and they're incentivized by their own (mostly economic) interests, and not by direct monetary incentive.


Transaction stuck as "pending" in the GUI

First of all, if you're using the CLI, see this Q&A:
Transaction stuck as "pending" in monero-wallet-cli

It's important to make sure you're running the latest version (v0.17.1.9 at the time of writing). You can check the version # on the Settings page of the GUI (under Debug info). If you're not running v0.17.1.9, please upgrade first:
How do I upgrade my software to the newest version?

The following assumes you're using a local node
A transaction being stuck on Pending is typically caused by the local daemon being out of sync with the network. To verify that you're fully synced, perform the following steps:
[1] Go to the Settings page of the GUI.
[2] Go to the Log tab.
[3] Type status into the command + enter (e.g. 'help' or 'status') box.
[4] An output will be displayed that looks like:
Height: 1456425/1456425 (100.0%) on mainnet, not mining, net hash 290.20 MH/s, v6, up to date, x(out)+x(in) connections, uptime xd xh xm xs

[5] Now to verify that you're actually fully synced, compare the first number (of Height:) to the height displayed on a blockchain explorer like, for instance, XMRchain. You're fully synced if your height matches the height displayed on a block explorer.
[6] If the GUI is stating that you're fully synced (100.0%), but your height doesn't match the height displayed on a block explorer (and is off by a large number), it is erroneously reporting that you're fully synced. This is, fortunately, easily resolved as follows. First, exit the GUI and make sure to stop the daemon as well. Second, restart the GUI + daemon. Third, use the status command to verify that it's now correctly displaying the top height.

Once you've verified that you're fully synced, we can resolve the issue as follows:
[1] Go to the History page of the GUI and copy your transaction hash / ID.
[2] Use multiple block explorers (for instance, XMRchain, MoneroBase, or MoneroBlocks) to confirm that your transaction isn't present in either the mempool or the blockchain.
[3a] If it's present in the mempool, simply wait until it gets mined.
[3b] If it's present in the blockchain (i.e. mined already), but is still stuck on Pending, perform the following steps. First, exit the GUI and make sure to stop the daemon as well. Second, restart the GUI + daemon. Lastly, let it run until it says Connected in the left bottom. This should resolve your issue.
[4] If it's not present in the blockchain, again go to the History page and copy the transaction hash / ID.
[5] Go to the Settings page of the GUI
[6] Click on the Log tab.
[7] Go to the command + enter (e.g. 'help' or 'status') box.
[8] Type status to again verify that you're fully synced.
[9] Type -> relay_tx <txid>
[10] As an example, let's say your transaction hash / ID is 4d0f32b7b1c371f1807f4bd6552362cc5b3d61b68b8f8407bb93193f9b1b0273 (randomly taken from the blockchain), you type -> relay_tx 4d0f32b7b1c371f1807f4bd6552362cc5b3d61b68b8f8407bb93193f9b1b0273
[11] Use one of the blockexplorers to check whether your transaction is in the mempool now (and thus will be mined soon).

If these steps don't work for you, try these:
[1] In the command + enter (e.g. 'help' or 'status') box on the Settings page, type -> flush_txpool
Note that it doesn't return an output.
[2] Exit the GUI.
[3] Browse to the directory your wallet files are located (Documents\Monero\<wallet-name> on Windows | home/<username>/Monero/<wallet-name> on Linux | Users/<username>/Monero/<wallet-name> Mac OS X).
[4] Rename <wallet-name> (the file without extension) to <wallet-name>-old
[5] Restart the GUI. This will trigger a wallet refresh from scratch, which shouldn't take longer than 30 minutes.
You should now be able to send a new transaction. However, it could be that the "old" transaction hash / ID is still on the History page. You can safely ignore this.

The following assumes you're using a remote node
It is quite unlikely that a remote node is out of sync with the network. However, if, for some reason, it is and you used it to send a transaction (which got subsequently stuck on Pending), perform these steps to resolve your issue:
[1] Go to the Settings page and make sure to use a different remote node than the one you were using. A list of remote nodes can be found here:
https://moneroworld.com/#nodes
[2] Exit the GUI.
[3] Browse to the directory your wallet files are located (Documents\Monero\<wallet-name> on Windows | home/<username>/Monero/<wallet-name> on Linux | Users/<username>/Monero/<wallet-name> Mac OS X).
[4] Rename <wallet-name> (the file without extension) to <wallet-name>-old
[5] Restart the GUI. This will trigger a wallet refresh from scratch, which shouldn't take longer than 30 minutes.
You should now be able to send a new transaction. However, it could be that the "old" transaction hash / ID is still on the History page. You can safely ignore this.

If you, after all these steps, still aren't able to send out a transaction, it'd be best to either open a new issue the GUI repository or contact me on Reddit.


You are probably linking them in as C++.
Lookup the different in linkage between C and C++, and/or copy how Monero already does, ie:

extern "C"
{
#include "c_header.h"
}

Alternatively, rctOps.h has a convenience layer above these if performance isn't critical.


How can I automatically sell Monero? What about the balance locking?

How can I automatically sell Monero?

This is a little vague. What are you selling Monero for? Assuming you are selling Monero for some other cryptocurrency, you can still sell with zero-conf if you so wish. Zero-conf being the moment your wallet sees the tx (i.e. the tx is in the tx pool). Of course, there is a level of risk in doing so, which dissipates after it is mined into a block, then further dissipates the more blocks deeper down the chain it goes. In terms of "automatically", you will have to write something that sends the Monero when you have received whatever currency you are accepting. From the Monero side of things, you will use the wallet RPC, monero-wallet-rpc.

  What about the balance locking?

This can mean a few things, but in the context of the rest of your question I assume you are referring to the situation where you want to make lots of transactions in succession but cannot because you have no unlocked balance. This situation is one whereby you are unable to send a tx until your change has confirmed on the blockchain.

If you have 10 XMR in only one output and send 1 XMR to someone, two outputs are created, one for 1 XMR to your recipient and 9 XMR in change back to you. Your 9 XMR is locked until confirmed on the blockchain. Another way of thinking about this is with bank notes in a wallet. If you have a single $100 note and buy something for $10, you are giving the merchant $100 and then have to wait for your change ($90) before you can go buy a coffee for $2.

The simplest way to mitigate this is keep your wallet fragmented with small outputs. One way of helping achieve this is via a couple of wallet options, found with help set:

min-outputs-count [n]
 Try to keep at least that many outputs of value at least min-outputs-value.
min-outputs-value [n]
 Try to keep at least min-outputs-count outputs of at least that value.

Another thing you can do is make sure to send lots of small transactions from your cold-wallet to your hot-wallet regularly.

  Is it possible to manage a Monero wallet carefully enough that a "re-org" never happens? I don't know what a "re-org" is.

A re-org is a network level consensus thing (chain with most work wins) and as such there is nothing you can do at the wallet level to prevent a re-org. A re-org can in theory happen at any time/depth, though it's not that common and usually only small. By default, Monero transactions are deemed fully confirmed after 10 blocks (~20 mins) depth in the blockchain, which is a safe depth to deem the tx as final. Circling back to your first question, you can deem a tx final at any depth you like (i.e. when you release goods), and many merchants are happy to take on the risk of a zero or single block confirmation. The level of risk and semantics are different depending on which currency you are accepting of course.


The frontend has been updated recently and does not redirect to the no-javascript version automatically if you have javascript disabled. This is clearly a mistake and should be fixed soon.

For the time being you can access explicitly the no-javascript version at https://xmr.to/nojs

Note that if you access it on its onion address at http://xmrto2bturnore26.onion you will also get the no-javascript version.


How does check_hash work in difficulty.cpp?

The check_hash function returns true if hash * difficulty < 2^256 and false otherwise.

From src/cryptonote_basic/difficulty.h:

/**
 * @brief checks if a hash fits the given difficulty
 *
 * The hash passes if (hash * difficulty) < 2^256.
 * Phrased differently, if (hash * difficulty) fits without overflow into
 * the least significant 256 bits of the 320 bit multiplication result.
 *
 * @param hash the hash to check
 * @param difficulty the difficulty to check against
 *
 * @return true if valid, else false
 */
bool check_hash(const crypto::hash &hash, difficulty_type difficulty);


What happens if we send using an unencrypted payment ID after the new v0.15 upgrade?

The Monero wallets, from v0.15, will no longer allow transfers with an unencrypted payment ID.

No coins will be lost in an attempt to use these unencrypted payment IDs; the sending wallet will simply report an error explaining that unencrypted payment IDs are bad for privacy and abort the transfer.

The short, encrypted payment IDs can still be used (such as the ones in integrated addresses), so either use those or better still, use subaddresses.


There can be no such thing, because "private" is not well defined. Even if you were to ring sign against every single other output on the chain, everybody doesn't use Monero, right ? Moreover, there is a difference beteen untraceability and unlinkability, and more (tracking first relaying node, etc). Different facets with different solutions.

Generally, the higher the mixin, the larger the anonimity set. However, when you start getting into the less used mixins, such as 73 or 352, two transactions using mixin 73 will be likely to be sent by the same wallet. This may be an argument for quantizing mixin values.

As an aside, the wallet default mixin is 4, which provides more privacy than the bare minimum allowed by the network.

It is probable that minimum mixin will be increased in one of the next few forks, since this was one of the recommendations of https://lab.getmonero.org/pubs/MRL-0004.pdf.


How does Monero's multisig work under the hood?

I can only explain it to the extent I understand myself.
As written in the original post, we have user 1 with address (B, A) and user 2 with address (C, A), where B and C are individual public spend keys and A is the shared public view key (further on, small-caps will mean secret keys).
So, the 2/2 multisig address is obtained by simply summing the public spend keys of individual participants. The address is then (B+C, A). That's the address, but who can spend from it once some funds are received?
To an outsider it's just like any other address (F, A), where F = B+C. If you give the address to someone and say "send to this", he has no idea that the public spend key is actually composed of 2 (or more) keys, he sees only the combined key F. In fact, there exists a wallet which is able to spend from the multisig address alone. It can be constructed by whomever obtains the required number of individual secret keys. For doing this, there's a tool being added in PR-2218 (currently only N/N). Even without any special way of constructing TX-es, this allows for an one-time use multisig wallet. User 1 gives the private spend key to user 2 who constructs the master wallet and does whatever he wants with it further on.
But we want to sign individual transactions and avoid handing over control of the entire wallet. That makes it a bit more complicated, as the TX construction has to be done in steps which don't reveal the secret key to the other pary.
So, both parties already have the shared secret view key a and the combined public spend key F. This lets them both have a watch-only wallet and scan for incoming transfer. Recall how one-time public keys destined for this wallet are constructed:
P = Hs(rA||i)G + F,
and the recipient (any 1 of them) can check:
P' = Hs(aR||i)G + F, P = P' ?.
That's the output. To spend, we must produce a key image (also to check spent status) and produce a signature with the corresponding one-time secret key, but without revealing the "owning" wallet secret spend key.
As described in Luigi's write-up, fist step is key image creation.
Normally, the key image would be:
I = xHp(P),
but to construct it you need to know x, and you can't know x without the "master wallet" secret spend key, because:
x = Hs(aR||i) + f.
However, we can build it in parts:
User 1 does: I_1' = bHp(P), and
user 2 does: I_2' = cHp(P).
Any user can compute the complete key image from the partial pieces:
I = Hs(aR||i)Hp(P) + I_1 + I_2,
which works because:
I = Hs(aR||i)*Hp(P) + I_1 + I_2 =
= Hs(aR||i)Hp(P) + bHp(P) + cHp(P)
= (Hs(aR||i) + b + c)Hp(P)
= (Hs(aR||i) + f)Hp(P)
= xHp(P)
Further on, we construct the ring signature, etc. but that part I don't understand well, so can't continue.


Compare solutions for instant payments. Lightning Network vs Daughter-chain

It's probably better to understand first that daughter-chains are quite different to Lightning Network. A daughter-chain is a side-chain pegged to the main-chain and what's been discussed is having the implementation in the core wallets. This would make it very useful from a user perspective, in my opinion, alongside the more generic use-cases daughter-chains can offer beyond just faster/micro transactions.

  ...but also that lightning-network would be also possible to implement in monero, once multisig transactions are implemented.

This is incorrect. Multisig (which is now in the code since the v0.12 release) is definitely not all that would be needed to implement Lightning on Monero. There would need to be protocol changes to do things like OP_CheckSequenceVerify.


Given that Monero comes from Esperanto, it'd probably be best to use Esperanto's pronunciation. As u/Bagatell_ pointed out on Reddit, you can use Google Translate for this:

  https://translate.google.com/#eo/en/monero has audio

Other suggested pronunciations can be found here:

https://www.reddit.com/r/Monero/comments/5kska9/how_is_monero_pronounced/


It does what the text on your screenshot says: it monitors the blockchain for incoming transactions matching the amount you specify. This is intended as a poor man's point of sale system: if you're selling things for monero, you can use this screen with these steps:

find a customer who wants to buy something and pay with monero
enter the item's price in the box in your screenshot
let the customer scan the QR code
let the customer send monero using that QR code using their wallet
wait till a transaction is reported on this screen, and check it says the payment is for the full amount
optionally wait for a confirmation or more
give the customer the item


Is it safe to make backup of wallet? If so, is there a reference procedure somewhere?

You can use any of those methods:

backup the mnemonic seed, a 25 word list of words that encode your private keys. This is the simplest way, and you can then restore your wallet with monero-wallet-cli --restore-deterministic-wallet later. After creating a wallet, you can obtain its seed with the seed command in monero-wallet-cli.
backup the keys file and the password you saved it with.
backup the private spend and view keys. You can then restore your wallet with monero-wallet-cli --restore-from-keys.  After creating a wallet, you can obtain its keys with the spendkey and viewkey commands in monero-wallet-cli.

Note that when you restore a wallet, you lose all information about tx keys (needed if you want to prove payment later), any tx notes you saved in monero-wallet-cli, and extra information on outgoing transactions (such as the destinations addresses).


Can I use the same Monero miner on a 32bit and 64bit os?

Compiling and installing xmrig on a 64 bit OS will work fine.


Saving hashes of data in Monero blockchain

It's possible to store arbitrary data in the tx extra field. You'd have to manually construct your tx though (no wallets allow for this) and block explorers will only show the hex data of it, if at all.


How can I check the network usage of my Monero node?

This is possible with the 0.14.1 (April 2019) update. rbrunner created new code that allows users to see global traffic stats.

While monerod (the node software) is running, you can type the following command in the terminal:

print_net_stats

This will display information on how much data was transferred and the average upload and download speeds, among other useful network connectivity information. Here is an example output:

Received 7354450 bytes (7.01 MB) in 4682 packets, average 1.39 kB/s = 0.02% of the limit of 8.00 MB/s
Sent 49976456 bytes (47.66 MB) in 4705 packets, average 9.47 kB/s = 0.46% of the limit of 2.00 MB/s


The log file is ~/.bitmonero/bitmonero.log. On Windows, it is somewhere else which someone who knows will edit here soon.

The status command reports your hash rate. If you're running a detached monerod:

./monerod status

You could use watch to run this at whatever interval you want, eg:

watch -n 60 monerod status >> /tmp/monerod.log

Or you could grep the log, where the hash rate goes once requested by the show_hr command you included:

tail -f ~/.bitmonero/bitmonero.log | grep --line-buffered hashrate:

Edit: The hashrate isn't logged, as mentioned below. Another way, then:

(watch -t -n 60 './monerod status >> /tmp/monerod.log'&) 2>&1 2> /dev/null; tail -f /tmp/monerod.log


Export a list of Integrated Addresses from GUI (or monerod)?

The wallet RPC interface has a make_integrated_address command that you can call repeatedly to do that.


How can I use a private node on Wolfram Warptangent?

First thing to note is that simplewallet was renamed to monero-wallet-cli in Wolfram Warptangent. Secondly, it could be that the node is currently offline. There are other remote nodes available here. To quote:

node.moneroworld.com are nodes that are from Monero long-term community members, so high trust level
2nodez.moneroworld.com are nodes from anyone (includes the nodes in node.moneroworld.com)
Connect to a random remote node by pointing your wallet to node.moneroworld.com or 2nodez.moneroworld.com, using the following commands:
(linux / unix-type)
./monero-wallet-cli --daemon-host node.moneroworld.com
or ./monero-wallet-cli --daemon-host 2nodez.moneroworld.com
(windows)
monero-wallet-cli.exe --daemon-host node.moneroworld.com
or monero-wallet-cli.exe --daemon-host 2nodez.moneroworld.com
or download this file to your monero folder and double click on it.
Remote nodes are secure - they can't spend your money. You do sacrifice privacy though, and you really should be running your own node, you know, because decentralization. But I understand that convenience wins out.

Note that you have to launch monero-wallet-cli from the terminal (on Linux and mac OS X) or from the command prompt (on Windows) with the aforementioned commands. To open the command prompt on Windows you have to go to the folder monero-cli-wallet is located and make sure your cursor isn't located on any of the files. Subsequently do SHIFT + right click and it will give you an option to "Open command window here".


How to get the transaction public key and outputs from get_transactions?

Parse the field named extra to get the public key. The 32 bytes after the byte 0x01 is the tx public key.

The output keys are in txs[].as_json.vout[].target[].key if you used the parameter decode_as_json:true.


Renaming the files is just fine. The wallet files have no idea what they're called, so no conflicts will happen. The FOO.address.txt file can be deleted, it's just information for the user, and is not used after creation. Just make sure the files aren't being used (ie a wallet program running) while you rename or the files will be saved again with the old name when the wallet program exits.


The most straightforward way is probably to generate 256 bits of entropy (a fair 20 sided dice will give you a bit more than 4 bits per roll, so make it 64 rolls), and record all these throws in the custom entropy box at https://moneroaddress.org, then generate a new wallet from this.

You'll have downloaded this page first (it can run standalone from your hard disk, without internet access), and make sure the GPG signature checks out (there are instructions on the page).

Depending on your level of paranoia, you may want to do this on a computer that will never see the internet ever again.

This will get you a 25 word seed. 13 words seed are MyMonero's. The view key is derived from the spend key, rather than from a separate entropy pool. simplewallet still does this for deterministic wallets, but still uses the 25 word system for those. The simplewallet one is best, since MyMonero can import those too.


What is the difference between Monero (XMR) and Enigma (ENG)?

Enigma (ENG) has relatively different goals than Monero (XMR). Whereas Enigma works to encrypt information stored by applications, Monero works to hide transaction data.

Engima prioritizes securely securing data. It is not meant for these assets to be frequently "sent" to other users, or at least in the same capacity. Their basic privacy protocol is best shown as follows:

In this diagram, the user has two types of information that is passed to the blockchain. The blockchain is merely a distributed database that stores data. First, users can store T-data transactions that store the hashes of data. For example, if I want to store a copy of this StackExchange answer text on the blockchain, I would "hash" the text and store only this hash in the blockchain. I recommend you learn more about hashing to see why this is important.

Second, users can store T-access transactions, which assign authorization for specific files. They decide who has permission to gain access to data stored with the T-data transactions.

The actual data (in this example, the full content of this response) is stored outside of the blockchain. The privacy documentation says the following:

  Data collected... is encrypted using a shared encryption key and sent to the blockchain in a T-data transaction, which subsequently routes it to an off-blockchain key-value store, while retaining only a pointer to the data on the public ledger (the pointer is the SHA-256 hash of the data).

For practicality purposes, imagine this data storage as a centralized cloud provider Amazon AWS.

Services run on the side of the blockchain to provide applications to users. They can be given permission to access user data through T-access transactions. The service can then query this data on the blockchain, pull the actual files from Amazon AWS, then interact with the user directly to provide a service.

Keep in mind that while a user can create a T-access to revoke access to files at any time, the service may have archived them, making complete removal difficult.

I am not aware of how the history of T-access transactions is managed. I do not know if an outside observer can see who was previously given access to what data. This is something I recommend you spend some time researching, since it could create undesired public connections (eg: you granting permission to a healthcare provider).

Monero does not offer simple support for the mechanism explained with Enigma. Instead, it provides protection for transactions. Ring signatures hide the origin of funds spent by hiding the real output among other sources of money. Ring confidential transactions (RingCT) hide the amount. Stealth addresses break the link between sources of funds and addresses (making rich lists impossible). You can learn more about each individually by searching around in StackExchange and watching the linked videos.

Monero overall has a simpler use-case. Enigma is much newer, and there are more considerations that are still developing. You probably shouldn't make private transactions on Enigma, and you likewise probably shouldn't write applications directly on top of Monero (use a second-layer approach instead).


Is it possible to use samba share as blockchain data location?

LMDB requires mmap to work, and searching the internet shows that Samba did not support mmap, but now does, at least on Linux. You might have to update your software, and configure it to have mmap support.


Monero RPC command for getting global index of one-time public key

In other words, in there a command that lets me find the global index of a one-time output from its public key?

If you know (which it sounds like you do) the txid that created the output, you can just use /get_transactions, which reports the global output indices in the response field output_indices.
If you didn't know the txid, there isn't an RPC method that takes as input an output public key and returns its global index. That said, it wouldn't take rocket science to write something to search the LMDB database directly.


How might someone view the balance of a multisig monero address without both its private keys?

There is no Multisig right now for Monero and it still on research. Based on the milestone here its not yet complete.

However, if you are asking how the multisig works when it is implemented I don't know either. The post proposing the multisig is not available anymore.


Does the receiver need to be online in order to complete a transaction?

Yes, there is a key exchange, which implies two-way communication.  But the first line of communication is the receiver providing their public address (public key, aka public spend-key plus public view-key).  The information going the other direction is the transaction itself.

The transaction output is encrypted by the sender using the recipient's address and broadcasted to the network, where it is recorded by miners.  When the receiver's wallet later scans the blockchain for outputs sent to it, the wallet's private view-key will decode the output on the blockchain, thus proving ownership of the output.

The receiver's wallet will only know it has a new output when it is online and scans the chain, so in that sense the answer to your question is yes.  But the receiver does not need to be online contemporaneously with the sender because the blockchain keeps that record for whenever the receiver does get online.


Why is GetMonero.org copyrighted with a CC-BY-3.0 license?

Because the CC BY 4.0 didn't exist when we created the site. Changing the license requires an agreement from all those that have submitted a PR, so unless there's something specific in 4.0 that we want it's simply too much effort to change.

The reason we chose CC BY 3.0 is because it seemed the most appropriate to the written material, images, and logo. It allows people to share it in any way, remix it, build on top of it, modify it, even for commercial purposes. The only thing they have to do is provide proper attribution to the site, provide a link to the license, and indicate if changes were made.

Why would we want to restrict the ways in which people can use and benefit from the material on the site?


FWIW, the issue was solved. Perhaps I had two copies of the daemon and the two different wallets were using the different daemons. In any case. All is well now.


What is the password for monero.hashvault.pro pool?

The password field is utilized to better identify your worker, but I assume you are only using your CPU, so it's fine to leave it as "x".

On hashvault.pro exchange the only thing required to track your current impending balance is your wallet address. Of course, the same address you put in your configuration.

https://monero.hashvault.pro/en/#!/dashboard

Go to the dashboard, and find "track live stats" and enter your wallet address.


What are the most secure options for backing up your mnemonic seed?

You could also scrypt your paper wallet. Then use base64 to get the encrypted data in a printable format. This way somebody stealing it will still need a password to get the keys or mnemonic seed and scrypt will make sure that brute force attacks are infeasible even for weak passwords.

Encode:

scrypt enc -t120 data.txt | base64 > data.enc.txt

Decode:

base64 -d data.enc.txt > data.enc
scrypt dec data.enc

One major drawback though is that you'll probably have to scan+OCR to get the encrypted data back from paper into a digital format ;-)


What is the origin of Monero and its relationship to Bytecoin?

The answer to this question is long and any shortening doesn't do the question justice.

This is an edited version of the excellent investigation of the bytecoin scam performed by user "rethink-your-strategy" on the bitcointalk forums written August 15, 2014. It is the best available account of the bytecoin scam, and covers the following areas from the original question:

It has been edited due to the (entertaining) vulgarity of the original report and to fit in the 30k character limit of answers.

The Alleged CryptoNote/Bytecoin Story

CryptoNote is a new cryptocurrency protocol. It builds on some of the Bitcoin founding principles, but it adds to them. There are aspects of it that are truly well thought through and, in a sense, quite revolutionary. CryptoNote claim to have started working on their project years ago after Bitcoin's release, and I do not doubt the validity of this claim...clearly there's a lot of work and effort that went into this. The story as Bytecoin and CryptoNote claim it to be is as follows:

They developed the code for the principles expressed in their whitepaper, and in April, 2012, they released Bytecoin. All of the copyright messages in Bytecoin's code are "copyright the CryptoNote Developers", so clearly they are one and the same as the Bytecoin developers. In December 2012, they released their CryptoNote v1 whitepaper. In September 2013, they released their CryptoNote v2 whitepaper. In November 2013, the first piece of the Bytecoin code was first pushed to Github by "amjuarez", with a "Copyright (c) 2013 amjuarez" copyright notice. This was changed to "Copyright (c) 2013 Antonio Juarez" on March 3rd, 2014. By this juncture only the crypto libraries had been pushed up to github. Then, on March 4th, 2014, "amjuarez" pushed the rest of the code up to github, with the README strangely referring to "cybernote", even though the code referred to "Cryptonote". The copyrights all pointed to "the Cryptonote developers", and the "Antonio Juarez" copyright and license file was removed. Within a few days, "DStrange" stumbled across the bytecoin.org website when trying to mine on the bte.minefor.co.in pool (a pool for the-other-Bytecoin, BTE, not the-new-Bytecoin, BCN), and the rest is history as we know it. By this time Bytecoin had had a little over 80% of its total emission mined.

Immediate Red Flags

The first thing that is a red flag in all of this is that nobody, and I mean no--body, is a known entity. "Antonio Juarez" is not a known entity, "DStrange" is not a known entity, none of the made up names on the Bytecoin website exist (they've since removed their "team" page, see below), none of the made up names on the CryptoNote website exist (Johannes Meier, Maurice Planck, Max Jameson, Brandon Hawking, Catherine Erwin, Albert Werner, Marec Plíškov). If they're pseudonyms, then say so. If they're real names, then who are they??? Cryptographers, mathematicians, and computer scientists are well known - they have published papers or at least have commented on articles of interest. Many of them have their own github repos and Twitter feeds, and are a presence in the cryptocurrency community.

The other immediate red flag is that nobody, and I mean no--body, had heard of Bytecoin. Those that had heard of it thought it was the crummy SHA-256 Bitcoin clone that was a flop in the market. Bytecoin's claim that it had existed "on the deep web" for 2 years was not well received, because not a single vendor, user, miner, drug addict, drug seller, porn broker, fake ID card manufacturer, student who bought a fake ID card to get into bars, libertarian, libertard, cryptographer, Tor developer, Freenet developer, i2p developer, pedophile, or anyone else that is a known person - even just known on the Internet - had ever encountered "Bytecoin" on Tor. Ever. Nobody.

Indisputable Facts

Before I start with some conjecture and educated guesswork, I'd like to focus on an indisputable fact that obliterates any trust in both Bytecoin's and CryptoNote's bullshit story. Note, again, that I do not doubt the efficacy of the mathematics and cryptography behind CryptoNote, nor do I think there are backdoors in the code. What I do know for a fact is that the people behind CryptoNote and Bytecoin have actively deceived the Bitcoin and cryptocurrency community, and that makes them untrustworthy now and in the future. If you believe in the fundamentals in CryptoNote, then you need simply use a CryptoNote-derived cryptocurrency that is demonstrably independent of CryptoNote and Bytecoin's influence. Don't worry, I go into this a little later.

So as discussed, there were these two whitepapers that I linked to earlier. Just in case they try remove them, here is the v1 whitepaper and the v2 whitepaper mirrored on Archive.org. This v1/v2 whitepaper thing has been discussed at length on the Bytecoin forum thread, and the PGP signature on the files has been confirmed as being valid. When you open the respective PDFs you'll notice the valid signatures in them:

signature in the v1 whitepaper

signature in the v2 whitepaper

These are valid Adobe signatures, signed on 15/12/2012 and 17/10/2013 respectively. Here's where it gets interesting. When we inspect this file in Adobe Acrobat we get a little more information on the signature:

Notice the bit that says "Signing time is from the clock on the signer's computer"? Now normally you would use a Timestamp Authority (TSA) to validate your system time. There are enough public, free, RFC 3161 compatible TSAs that this is not a difficult thing. CryptoNote chose not do this. But we have no reason to doubt the time on the signature, right guys? crickets

See these references from the v1 whitepaper footnotes? Those two also appear in the v2 whitepaper. Neither of those two footnotes refer to anything in the main body of the v1 whitepaper's text, they're non-existent (in the v2 whitepaper they are used in text). The problem, though, is that the Bitcointalk post linked in the footnote is not from early 2012.

May 5, 2013. The footnote is referencing a post that did not exist until then. And yet we are to believe that the whitepaper was signed on 12/12/2012! What sort of  fools do they take us for?

A little bit of extra digging validates this further. The document properties for both the v1 whitepaper as well as the v2 whitepaper confirms they were made in TeX Live 2013, which did not exist on 12/12/2012. The XMP properties are also quite revealing:

XMP properties for the v1 whitepaper

XMP properties for the v2 whitepaper

According to that, the v1 whitepaper PDF was created on 10/04/2014, and the v2 whitepaper was created on 13/03/2014. And yet both of these documents were then modified in the past (when they were signed). Clearly the CryptoNote/Bytecoin developers are so advanced they also have a time machine, right?

Final confirmation that these creation dates are correct are revealed those XMP properties. The properties on both documents confirm that the PDF itself was generated from the LaTeX source using pdfTeX-1.40.14 (the pdf:Producer property). Now pdfTeX is a very old piece of software that isn't updated very often, so the minor version (the .14 part) is important.

pdfTeX 1.40.14 pushed to source repo on Feb 14, 2014

This version of pdfTeX was only pushed to the pdfTeX source repository on February 14, 2014, although it was included in a very early version of TeX Live 2013 (version 2013.20130523-1) that was released on May 23, 2013. The earliest mentions on the Internet of this version of pdfTeX are in two Stack Exchange comments that confirm its general availability at the end of May 2013 (here and here).

The conclusion we draw from this is that the CryptoNote developers, as clever as they were, intentionally deceived everyone into believing that the CryptoNote whitepapers were signed in 2012 and 2013, when the reality is that the v2 whitepaper was created in March, 2014, and the v1 whitepaper haphazardly created a month later by stripping bits out of the v2 whitepaper (accidentally leaving dead footnotes in).

Why would they create this fake v2 whitepaper in the first place? Why not just create a v1 whitepaper, or not even version it at all? The answer is simple: they wanted to lend credence and validity to the Bytecoin "2 years on the darkweb" claim so that everyone involved in CryptoNote and Bytecoin could profit from the 2 year fake mine of 82% of Bytecoin. What they didn't expect is the market to say "no thank you" to their premine scam.

And Now for Some Conjecture

As I mentioned earlier, the Bytecoin "team" page disappeared. I know it exists, because "AtomicDoge" referred to it as saying that one of the Bytecoin developers is a professor at Princeton. I called them out on it, and within a week the page had disappeared.  cowards.

That was the event that triggered my desire to dig deeper and uncover the scam. As I discovered more and more oddities, fake accounts, trolling, and outright falsehoods, I wondered how deep the rabbit hole went. My starting point was DStrange. This is the account on Bitcointalk that "discovered" Bytecoin accidentally a mere 6 days after the first working iteration of the code was pushed to Github, purely by chance when mining a nearly dead currency on a tiny and virtually unheard of mining pool. He has subsequently appointed himself the representative of Bytecoin, or something similar.

At the same time as DStrange made his "accidental discovery", another Bitcointalk account flared up to also "accidentally discover this weird thing that has randomly been discovered": Rias. What's interesting about both the "Rias" and "DStrange" accounts are their late 2013 creation date (October 31, 2013, and December 23, 2013, respectively), and yet they lay dormant until suddenly, out of the blue, on January 20th/21st they started posting. If you look at their early posts side by side you can even see the clustering: Rias, DStrange.

At any rate, the DStrange account "discovering" Bytecoin is beyond hilarious, especially with the Rias account chiming in to make the discovery seem natural. Knowing what we unmistakably do about the fake CryptoNote PDF dates lets us see this in a whole new light.

Of course, as has been pointed out before, the Bytecoin website did not exist in its "discovered" form until sometime between November 13, 2013 (when it was last captured as this random picture of a college girl) and February 25, 2014 (when it suddenly had the website on it as "discovered"). This can be confirmed by looking at the captures on Wayback Machine: https://web.archive.org/web/*/http://bytecoin.org

The CryptoNote website, too, did not exist in its current form until after October 20, 2013, at which time it was still the home of an encrypted message project by Alain Meier, a founding member of the Stanford Bitcoin Group and co-founder of BlockScore. This, too, can be confirmed on Wayback Machine: https://web.archive.org/web/*/http://cryptonote.org

It's hard to ascertain whether Alain had anything to do with CryptoNote or Bytecoin. It's certainly conceivable that the whitepaper was put together by him and other members of the Stanford Bitcoin Group, and the timeline fits, given that the group only formed around March 2013. More info on the people in the group can be found on their site, and determining if they played a role is something you can do in your own time.

Update: Alain Meier posted in this thread, and followed it up with a Tweet, confirming that he has nothing to do with CryptoNote and all the related...stuff.

Batshit Insane

The Bytecoin guys revel in creating and using sockpuppet accounts. Remember that conversation where "Rias" asked who would put v1 on a whitepaper with no v2 out, and AlexGR said "a forward looking individual"? The conversation took place on May 30, and was repeated verbatim by shill accounts on Reddit on August 4 (also, screenshot in case they take it down).

Those two obvious sockpuppet/shill accounts also take delight in bashing Monero in the Monero sub-reddit (here are snippets from WhiteDynomite and cheri0). Literally the only thing these sockpuppets do, day in and day out, is make the Bytecoin sub-reddit look like it's trafficked, and spew angry bullshit all over the Monero sub-reddit.  Clearly they're pissy that nobody has fallen for their scam. Oh, and did I mention that all of these sockpuppets have a late January/early February creation date? Because that's not  obvious at all.

And let's not forget that most recently the sockpuppets claimed that multi-sig is "a new revolutionary technology, it was discovered a short time ago and Bytecoin already implemented it". If you think that's bad, you're missing out on the best part of all: the Bytecoin shills claim that Bytecoin is actually Satoshi Nakamoto's work. I'm not  kidding you. For your viewing pleasure...I present to you...the Bytecoin Batshit Insane Circus:

Seriously. Not only is this insulting to Satoshi Nakamoto, but it's insulting to our intelligence. And yet the fun doesn't stop there, folks! I present to you...the centerpiece of this Bytecoin Batshit Insane Circus exhibit...

Of course! How could we have missed it! The clues were there all along! The CryptoNote/Bytecoin developers are actually aliens!

One last thing: without doing too much language analysis (which is mostly supposition and bullshit), it's easy to see common grammar and spelling errors. My personal favorite is the "Is it true?" question. You can see it in the Bytecoin thread asking if it's Satoshi's second project, in the Monero thread asking if the Monero devs use a botnet to fake demand, and in the Dashcoin thread confirming the donation address.


Why do monerod and monero-wallet-cli have mine commands?

When you type the start_mining command in monero-wallet-cli (or simplewallet in older versions), the wallet software forwards that instruction to the daemon together with the address that is  currently open. The demon then starts mining and sends the rewards to that address (in case it can find a block).

If you start_mining in monerod, you have to specify the address where you want the rewards sent. Other than that it works the same way.

cpuminer-multi is a piece of software that is used to mine on pools. You have to specify the pool URL and an address to start mining (there are a few other options like the number of threads to use).


you can use the full node by running the Monero GUI Wallet (however it's in Beta 2)

here's the link for windows
https://downloads.getmonero.org/gui/monero-gui-win-x64-v0.10.3.1.zip


Auditing outgoing transactions in Monero

Yes, this is called a SpendProofV1 and is implemented by the official Monero wallet. See this answer: What is the "SpendProofV1..." or "OutProofV1..." in the details of a sent transaction in the GUI?


Option 1 - from the sending wallet
You can check it from the sending wallet using monero-wallet-cli:

find the transaction key using the transaction id (requires your wallet-cli to have store-tx-info set to 1):
  get_tx_key TX_ID

check that the transaction has been confirmed:
  check_tx_key TX_ID TX_KEY RECIPIENT_ADDRESS

The output should be something like:

RECIPIENT_ADDRESS received [AMOUNT] in txid <TX_ID>
This transaction has 1191 confirmations

Option 2 - using a view only wallet
Create a view only wallet:
monero-wallet-cli --generate-from-view-key wallet-name

Then input the public address and private view key.
You will then see a list of incoming transactions for that wallet.


Mining XMR - upgrading my graphics card hd 6950 to gtx 780

I could go in to a longer answer, but essentially the crux of it is a GPU that old is not likely to provide any greater performance for mining that would be worth the investment of purchasing it.

To really get significant improvements in hash rate per watt, you should consider getting current generation AMD grpahis cards or basically any high end CPUs.


Problem transfering to Monero address copied from SE comment using monero-wallet-cli. `Error: wrong address`

In the first two cases you have "\n" in the address.

9z1N6pssDU3hvq9X6iqxk2g2e4tfc2WqfiMcKLR2dE8mZVjGN4yCKBD4QE8j<\n>
xNMMCabNQNzDKLUnZSguEMMr4YPSBcMuJ8p


Which type of hardware is the most efficient for mining Monero?

In terms of power efficiency, the reigning champ was the Nvidia 750Ti. That GPU will get you 250H/s and use about 30-40W power. For efficiency, that puts it around 6H/s/W.

With the optimized ARM64 code I've been working on, a small ARM64 box (like a high end TV box) can get you 22H/s using less than 5W power. Much slower mining, but much higher efficiency, at 4.5H/s/W.


Difference between "Wallet" and "Account"

Accounts were created as part of the subaddress scheme.

A wallet has a seed. From this seed, the primary address private spend and view keys are derived. From these private keys, subaddresses are derived. Subaddresses are grouped into accounts.

This primary address is the first address in the first account in the wallet.

Each account has its own balance, and can have multiple subaddresses associated with it. Since accounts are only groupings of subaddresses, there is no such thing as an account address (unless you count the first subaddress in the account as the "account address").

So a wallet can have multiple accounts, and each account can have multiple subaddresses.

Since accounts and subaddresses are deterministically derived from the seed, you only need to know the seed in order to restore the account/subaddress structure when restoring a wallet (although any labels you assign to the accounts/subaddresses will need to be noted separately).


If I compile from source, how can I change default wallet and daemon 10-block lock time?

All that's required is to change one line of code in the cryptonote_config.h:

#define CRYPTONOTE_DEFAULT_TX_SPENDABLE_AGE             10

and build with the new value.


Why does the stealth address involve a hash function?

In your system although the recipient can still find his transaction using R, he would also need to know r for deriving the corresponding private key.

You could fix that by making r also public, and still only the user would be able to derive the private key ra+b, but then everyone in the network can figure out that the recipient was the address (A,B)... Using the hash eliminates the need to publish r and thus preserves the recipient's privacy.


Don't have Mnemonic seed from https://moneroaddress.org/ --- Can I still access funds that I sent to offline wallet?

In order to access the monero on a particular account, you need the secret keys for that account. The mnemonic seed is a representation of those using words. So if you did not keep the mnemonic seed, nor the secret keys, that monero is lost forever.

Now, there's a much better chance that the browser might have saved that page to disk, or that it might be written to swap, but that's still probably out of luck. You could maybe grep the swap partition for "Keep it secure!", which is the bit of text just before the seed on that page. Quite the long shot though.


How scalable and decentralized can a block chain currency be?

We say Monero is scaleable because there nothing in the protocol level preventing Monero from accepting a very large number of transactions. There is no coded limit on the block size.

The processing capacity for nodes is based on a few things:

Frequency of transactions
Size of the blockchain

Regarding the first, transactions can not happen faster than nodes can accept and evaluate them. This is limited by the CPU speed, hard drive speed, and internet capacity of the node. It is very unlikely that the rate of transactions could exceed growth rates of 5MB/s, which even a 5400rpm HDD can handle. The most likely limited factor would be network bandwidth, which could make a growth rate of 1MB/s too much for people on slower connections (less than 8 mbps). Keep in mind that Monero (and Bitcoin) have growth rates well below these numbers.

Regarding the second point, this is where the argument is that the total size of the blockchain will become a major barrier to running a node. This is a much more legitimate criticism, and Monero has a larger transaction size than Bitcoin and most/all other coins. There are multiple ways that this concern can be put to ease. First, the cost of hard drives continues to fall. Right now, one can buy a 1TB hard drive that should last for the foreseeable future for less than $50 brand new. Secondly, Monero can still look into options such as pruning to reduce the size of the blockchain. There is currently little research in Monero blockchain pruning because the size of the blockchain is not much of a concern yet. In general, the size of the Monero blockchain is not a large concern for the next few years, and even if Monero becomes much more popular, it will still stay at a reasonable size for a while.

One argument is that the larger the block size, the harder it is to run a node and the more centralized the control will be. This is a valid point, but I do not think the size of the blockchain is intrusive enough to cause any real impact here.


Monero Wallet For Raspberry Pi 1? (ARMv6 I think)

As seen on the Monero downloads page, there are no official builds for ARM v6. There are only v7/v8: https://github.com/monero-project/monero/releases

However, Howard Chu has some unofficial builds listed here that include ARM v6: https://www.reddit.com/r/Monero/comments/543euo/monero_unofficial_arm_builds/

FYI, these may not work with the current network, especially after the next hard fork when RingCT will be enforced network wide (Sept 2017).

Edit: Hyc released some new binaries! (v0.10.3.1): https://www.reddit.com/r/Monero/comments/6eg72k/updated_binaries_for_armv6_raspberry_pi_1/


Is it feasible to introduce output key reuse checking?

Answered by smooth_xmr:

  We looked at this but it would add additional permanent overhead and reduce scalability to prevent what is essentially burning coins, which is silly. Someone who wants to burn coins can do so other ways.


The recipient cannot see the sender's wallet address, but can a miner see the sender's wallet address?

No. Neither can see the sender's wallet address because Monero uses one-time stealth addresses in transactions, never the actual wallet address.

  Can the miners see the IP address of the sender?

No. A miner asks a node for a block template to hash. There are no IP addresses linking to a transaction in the block template received from the node.

  Moreover, what information of the sender can the miner see?

Nothing other than transaction data, which a) uses stealth addresses as defined above and b) amounts that are encrypted (hidden). There is however the option to use an unencrypted payment ID, though this is being phased out / discouraged.

A node however can of course see the IP address of the peer that sent it a transaction. It will not know however whether that peer is the original sender or not though, as transactions get relayed around the network.


LMDB conversion vs downloading from scratch

Security wise, it's the same, assuming you do not disable verification on the conversion process (which speeds up a lot, but then if there are problems, they won't be detected).

Speedwise, it varies. Typically, syncing is faster, as this can do some things in parallel. However, if your internet download speed is pretty slow, or if you can't download much (e.g., you have a data use limit on your internet connection), converting might actually be faster or favorable.

Syncing also has the benefit of having known block hashes for the first million blocks or so, and avoids some checking if hashes match the expected hashes. This is safe, due to hash function properties, and also a fair bit faster. You'll also have to sync about 8 months of blocks afterwards anyway if you choose to convert.

So, in a nutshell, I think your're best off syncing from scratch.


Monero Genesis transaction & nonce - clarification

First you need to send yourself some funds on the real Monero blockchain. It doesn't matter how much.

show_transfers in is displaying your transaction id, which is also known as the transaction hash (because the transaction id is a hash of the transaction). This is not the same as the transaction public key.

Look up this transaction id at xmrchain.net. Here is an example transaction: https://xmrchain.net/tx/06576b3b6862818ba23c74a1a40769be695ea417d19c717e3313f6cf1a137eff

The transaction id is 06576b3b6862818ba23c74a1a40769be695ea417d19c717e3313f6cf1a137eff and the transaction public key is 52ac230076b1257cfd12eab526671ab6460656be7f95274450fc78968e64f4fe.

You'll see a list of "stealth addresses". These stealth addresses are also known as one-time output public keys, or output public keys.

You then need to replace the transaction public key and the output public key in the genesis transaction with the transaction public key and the first output public key (first stealth address) listed in the xmrchain.net transaction.

To know how to replace these in the genesis transaction, you need to know the transaction format, which is described here: How can I create a new Monero genesis block?

That description uses the term output #1 key to mean the one-time output public key.


How many hashes does an AMD Threadripper 1950X do on the RandomX Monero mining algorithm?

I haven't seen any results for your specific CPU yet, but looking at a somewhat outdated thread (the algorithm and benchmark tool have had minor changes since), and the details on the project README for other Ryzen processors, I would guess at a minimum yours will achieve 5Kh/s.

It's really not possible to compare to what "high end GPUs" will achieve because the code is not yet finished for GPUs, so there are no benchmarks to compare. The developers have previously signaled at GPUs hashing at roughly the same rate as they do currently though.


How can I change the proxy settings of the official GUI / CLI?

This is down to whatever proxy program you're using.

If you want to proxy through Tor, then use torsocks as described in the README.md file, eg:

  DNS_PUBLIC=tcp torsocks ./monerod --p2p-bind-ip 127.0.0.1 --no-igd --rpc-bind-ip 127.0.0.1 --data-dir /home/amnesia/Persistent/your/directory/to/the/blockchain

If you want to proxy using another method, such as proxychains, look at the proxychains docs (http://proxychains.sourceforge.net/howto.html).

Note that you will usually want to run the daemon through a proxy, then use th wallet to connect locally to your dameon, so without a proxy.


monerod print_coinbase_tx_sum 0 100 Returns Unsuccessful --

Per comments, this was fixed some time ago.

print_coinbase_tx_sum 0 100
INFO  [default] Page size: 4096
Sum of coinbase transactions between block heights [0, 100) is 1759.135559809471 consisting of 1759.135559809471 in emissions, and 0.000000000000 in fees


What changes are planned for the September 2017 hard fork?

The only change from that list which actually requires a HF is the minimum / uniform ringsize. The other 2 can be rolled out at any time. AFAIK, the current list for the upcoming hard fork is:

Only RCT transactions will be allowed
Minimum / uniform ringsize
Range proof size reduction

and the exact date hasn't been decided yet.

The discussion on 2. can be found here.

For 3., I've not yet seen any code or Github issue so hard to tell the progress of this. Luigi1111 (one of "core team") is working on it.

The best way to be on top of things is to monitor the dev meetings which get published on a few places, or just stalk various community channels. There's not something like a "live HF list", but anyone could volounteer to keep track. All it takes is to have a chat with some key contributors, make a list and add a page to the official site repo.

In any case, a version tag will be made on Github prior to HF, and that will happen some ample time before the HF date where everyone will be able to easily see what gets changed.


Is there an example in another language or even curl on the binary daemon calls?

The difference between JSON RPCs and binary RPCs is the format of the data in the HTTP POST request and in the server's answer.

JSON RPCs use strings representing JSON objects.

Binary RPCs use a "portable binary storage" serialization (it starts with the header 011101010101020101 and the data is organized in a kind of tree that can contain sections, integers, booleans, strings, arrays, etc.). The files defining it are in contrib/epee/include/storages/ in the Monero source code (portable_storage.h, portable_storage_from_bin.h, portable_storage_to_bin.h).
The parameters and types used by a specific binary RPC can be found in src/rpc/core_rpc_server_commands_defs.h.

So, to use binary RPCs with a language other than C++, most of the work is in implementing the functions to serialize and deserialize the "portable binary storage" format. Then, for example, to call getblocks_by_height.bin you would use something like:

parameters = serialize_to_binary_storage(array_of_block_heights)
answer = rpc(host, port, "/getblocks_by_height.bin", parameters)
blocks = deserialize_from_binary_storage(answer)

I wrote a lisp library of Monero tools with an implementation (experimental) of the "portable binary storage" serialization. It could be used in addition to the C++ code to help writing implementations in other languages. It can be found in https://github.com/glv2/cl-monero-tools (src/serialization/constants.lisp, src/serialization/storage.lisp). There are also a few examples of RPCs in src/rpc/daemon.lisp.


Whilst Monero is based on CryptoNote, the codebase and feature-set is now very different.

The CryptoNote website and code repository has not been updated in a long time.

So whilst the website and code has not been updated, for historical purposes, I guess it's nice they are still online, even though not maintained.

Arguably the most active development on privacy focused, decentralized and fungible digital money is happening on Monero, with a wealth of information updated regularly on multiple channels.


Monero GUI not recognising my Ledger X anymore...how can I get it to remember?

You should not worry for your assets. Those are kept safely on wallet created from private keys kept on your ledger device. So as long as you have access to your ledger and its seed/pin/passphrase it should be all fine. In your case, restoring the wallet should make it work again. Open Monero GUI App and close any wallet which is opened by default. Choose an option to make a new wallet: "Create a new wallet from hardware". Then you should go with option "Restore a wallet from device". After creation and some wallet syncing is done you should be able to access your assets again. Let us know how it went.


Backup and Disaster Recovery for Monero Fork

Once you have lots of people using your cryptocurrency, you can back up nothing at all (I'm talking about not backing up your seed nodes. If you have a wallet, you'll want to keep the mnemonic seed for that backed up, of course. And you'll want to keep a safe copy of your passwords/private keys that are used for connecting to the server via SSH and for logging in to your server hosting provider and domain name provider).

The whole point of a distributed cryptocurrency is that you all keep a copy of the blockchain, so that there is not a single point of failure.

This means that you could restore your seed nodes from the other nodes on the network. You'd just have to keep a note of some of the IP addresses of other nodes, so that you could reconnect your seed node to them when you reinstall your seed node after a disaster. Or better, you should encourage lots of people you trust to control their own nodes, who are willing to be listed as a seed node. Now you have resilience and don't need to keep your own written notes of IP addresses.

If you wanted to keep a copy of the blockchain on a machine that you want to control, just install a node on that machine, and it will constantly effectively back up the blockchain as it syncs with other nodes constantly during the day.


Is there a coin time lock ability in Monero like the one in Bitcoin?

In monero-wallet-cli you can use the locked_transfer command to send money to yourself and lock it for a number of blocks.


Which directory does monero-blockchain-import, by default, use to store the imported blockchain?

This question basically pertains to where monero-blockchain-import stores the imported blockchain by default. monero-blockchain-import uses the following default directories to store the imported blockchain:

Windows:

C:\ProgramData\bitmonero\lmdb

Linux and Mac OS X:

~/.bitmonero/lmdb

Note that, by default, both C:\ProgramData\bitmonero\lmdb and ~/.bitmonero/lmdb are hidden directories. On Windows, you have to use the explorer to manually navigate to aforementioned directory. On Mac OS X, you can typically use cmd+shift+. to unhide directories. On Linux, you can typically use ctrl+H to unhide directories.

  Where do delete the files that were created during the failed bootstrapping?

Thus, to delete redundant data, you should delete aforementioned directory.

monero-blockchain-import also allows one to import the blockchain to a custom data directory. This is done as follows:

Windows:

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

Subsequently, type the following command in the command prompt:

monero-blockchain-import.exe --input-file path\to\blockchain.raw --data-dir path\to\preferred\data\directory

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

.\monero-blockchain-import.exe --input-file path\to\blockchain.raw --data-dir path\to\preferred\data\directory

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

./monero-blockchain-import.exe --input-file path\to\blockchain.raw --data-dir path\to\preferred\data\directory

Linux and Mac OS X:

Open a new terminal from the same directory as monero-blockchain-import.

Sidenote: On Mac OS X, you probably can only open a terminal from the desktop. As a result, you have to use cd to navigate to the directory of monero-blockchain-import first. For example, if monero-blockchain-import is located in ~/Applications/monero-wallet-gui.app/Contents/MacOS you'd have to type cd ~/Applications/monero-wallet-gui.app/Contents/MacOS to ensure the terminal is in the proper directory.

Subsequently, type the following command in the terminal.

./monero-blockchain-import --input-file path/to/blockchain.raw --data-dir path/to/preferred/data/directory

  Where do delete the files that were created during the failed bootstrapping?

Thus, if you used the --data-dir flag, you should delete the directory you specified to delete redundant data.


Either xmrig-proxy or xmr-node-proxy should suffice.


Simplewallet shows zero balance after recovering XMR paper wallet (using Mac)

After you use --restore-deterministic-wallet and the address loads correctly, type "refresh".


How is CryptoNight variant 4 increasing the CPU to ASIC performance ratio?

At block 1788000, Monero will switch PoW from CryptoNight variant 2 to variant 4

The current naming is a little misleading as we are really on variant 3 right now, with the next being variant 4. This is because variant 2 actually spanned 2 releases in quick succession. Naming aside...

  How is that second goal technically achieved in practice ?

The best answer is probably found in the README from the original proposal. Quoting two pieces:

  It introduces random integer math into CryptonightV2 main loop.

  ...

  Instruction set is chosen from instructions that are
  efficient on CPUs/GPUs compared to ASIC: all of them except XOR are
  complex operations at logic circuit level and require O(logN) gate
  delay. These operations have been studied extensively for decades and
  modern CPUs/GPUs already have the best implementations.

Ultimately, the idea here (and in other similar proposals such as RandomX/RandomJS), is that the hashing function has to execute some random instructions (a program) which essentially means an ASIC/FPGA would need to have the properties of a CPU/GPU - being good at performing general purpose tasks. This defeats the whole purpose of an ASIC (application specific), therefore the idea is an ASIC can't be as good as general purpose hardware like CPUs/GPUs.

It will almost certainly obliterate any current ASICs/FPGAs, but worth noting a comment from hyc:

  CryptonightR is still only intended as a stop-gap. The instruction set it uses is small enough that a very simple CPU could be added to an ASIC to process it. There is no expectation for CN-R to have longer than 6 months effectiveness.


How can I run an open node with RPC restricted only to localhost?

Kind of dodging the question, but it seems to be logically impossible, so...
A way to "kinda" do both is to use a ssh tunnel to connect to your node's host, then connect through localhost, and bind RPC to loopback only.

Instructions on how to use ssh are found all over the internet, and I won't offer guidance there as I'd be more wrong than what you can find.


JS implementation of ge_fromfe_frombytes_vartime

According to the CryptoNote Whitepaper, the hash-to-point algorithm is based on this paper.


How to save the wallet state in monero-core?

Simply type:

save

on the command line, that will save the state of your balance at the current blockheight so it doesn't have to do it again next time it is loaded.


What would happen if monero were to switch to RandomJS mining algo?

The problem with literally every static algorithm is that sooner or later someone will find a way how to build a chip just for that purpose, since every algorithm has its own requirements on hardware and on general purpose machines uses just a fraction of available resources. ASIC manufacturers remove all unneeded stuff and create circuits just for one algorithm into silicone. These chips are pretty dumb and cannot perform anything else than their only algorithm, they cannot even be programmed otherwise and when there is just some small adjustment they become useless.

RandomJS (among other attempts) creates random code which has to be executed and a miner does not even have the time to optimise FPGAs for it, but the best ASIC to run it is an CPU (or GPU). The "problem" currently is that there is no full (optimised) JavaScript interpreter for GPU chips yet, but I'm pretty sure it will ship soon, at least for newer GPU generations.

RandomJS would make manually applied algorithm changes for mining obsolete which is just good for the future of the project and the other aims which do so with the block size or min-fees. Manual protocol changes should be the last option, since every time they are applied they also offer new attack vectors.


If I was to open a US based XMR exchange what laws I need to consider?

At the very least you would have to register as a money services business, which Poloniex and I believe Bittrex both have, and then as a MSB you would have to perform KYC/AML and record keeping to comply with the Bank Secrecy Act to detect and prevent money laundering. IANAL.


Is there any build options that compiles monerod better optimized for x86-64?

Is there any other build options that compiles monerod free of runtime exceptions and better optimized for x86-64?

The exception logs did used to be a bit spammy until the latest release (v0.17.2.0) and almost all of them were one particular issue that had no material impact. If you don't want any logs just launch it with: --log-level 0. Using any build optimization flags different to the ones used by the standard release build aren't going to affact your sync speed.

Do mining pools discover new blocks to be mined using monerod node RPC API or they use another faster syncing tool?

Mining pools use monerod to create block templates (not "discover new blocks"), and to submit mined blocks back to the network. Initial sync speed is not a concern in this regard as once a node is synced, staying in sync uses far less time/resources. Pools do want their node(s) to be well connected to the rest of the Monero network however.

Is there any other better optimized tool apart from monerod that can be used as a Monero public full node?

No. The only full node implementation is monerod, which is already heavily optimized.

For the last question I only found PiNode-XMR but this is for ARM processors like RaspberryPi.

Not sure what your question is there but there are ARM release binaries made available: https://www.getmonero.org/downloads/ and https://github.com/monero-project/monero/releases


How do I build Kovri from source for OpenBSD?

Kovri build instructions are on the main Kovri repository here:

https://github.com/monero-project/kovri/blob/master/doc/BUILDING.md

This document will always be the most up-to-date location for build information, so I will not go into the process here.


How long do I need to mine until I see some coins in my wallet?

The reason you haven't seen a payout is because most pools have a threshold level below which they won't bother sending xmr to you.

Your share per tick is: 160 H/s / 50.53e^6 H/s, with a network rate of 50 megahash per sec, right now.  The previous mining reward was 9.2481 and a tick happens every 2 minutes.

With a threshold of 0.1 XMR we get:

0.1 XMR / [(160 H/s / 50.53e^6 H/s) * 9.2 XMR / tick * 0.5 tick / min] / 1440 min / day = 4.77 days

In other words, if the pool has a threshold of 0.1 XMR before paying out you can expect to mine for almost two days without seeing any returns.  On top of that comes any variance.  Some small pools might not find a block the day you're due for a reward, which would cause an additional day in delays.

Follow up answer: No, you can interrupt, and come back to it later. Your balance shows the amount already won. Every time your balance changes, it's your fair share of the block reward, which the pool holds for you until you cross the payout treshold.

However, note that interruptions affect how much you will win in the first place. There are 2 different pool policies PPS (pay per share) and PPLNS (pay per last N shares).
With PPS, you will always win a piece of block reward proportional to your shares submitted to the pool / total shares submitted to the pool. With PPLNS it's a bit different, to discourage pool hopping.


Is a transaction from Exchange to Wallet to Exchange traceable?

Exchange1 would know the output (call it Out1) that it has given to Adr1. When Out1 is spent, Exchange2 (if sharing knowledge through backchannels with Exchange1) will see that there is a 1 in N chance that Out1 has been spent in a transaction with Exchange2, where N is the ring size that was used.

Exchange1 knows the exact amount of Out1, since it gave it to Adr1. So if it was an uncommon amount, and that exact amount was cashed out with Exchange2 (minus the transaction fee), then it'd be a pretty good guess that Out1 was being spent at Exchange2 if it was referenced in the ring.

Your question does not make clear whether Exchange1 or Exchange2 know about your real world identity. If they do, you've already lost your privacy. If they don't, depending on the scenario then perhaps it wouldn't even matter if you'd used a cryptocurrency without ring signatures at all. What good is it to see funds move on the blockchain, if neither the source nor the destination know your identity?


I dont know about the pull requests specifically, but here you can see overall activity of participants.

  https://github.com/monero-project/monero/graphs/contributors

Moneromooo is the most active with 710 commits, second being fluffyponny with 285.

Moneromooo's work also looks very steady during last year and half.


Scratchpad Initialisation : What is the input to Keccak?

As far as I'm aware, Monero didn't deviate from what was inherited from CryptoNote when it comes to PoW and difficulty.

Input should be the block header, although I'm not sure about all details. It should be according to chapter 4.1 of CNS003.

The winning hash is never recorded to the blockchain. Instead, nodes just hash the header themselves and verify that the resultant hash is above target difficulty for the block height.

The difficulty is evaluated according to CNS010.

Here's some more info:

Cryptonote SHA3 bigger than 64byte? (Scratchpad Initialization)

Keccak vs Keccak-f permutation in cns008

Understanding the structure of a Monero transaction

If you poke arond and get more clear info, please update here (you can answer your own question, as well).


Which multi currency/token wallet exist for ETH, BTC and XMR?

Patients, hold on to your horses... I wish I could have my cake and eat it to.

Until Monero hard forks, occurring roughly semiannually, slow down or until very strong software interfaces exist few wallet vendors have the resources to adequately support Monero. Monero is pushing the envelope for privacy services and everything must be coded from the ground up unlike Bitcoin-based altcoins.

There has yet to be a dedicated production-ready mobile Monero wallet or Monero hardware-based wallet. Jaxx spun their wheels to support Monero until the Ring Confidential Transactions (CT) hard fork occurred. The X Wallet currently appears to be the only viable moble Monero wallet in the pipeline, but is not a multicurrency wallet.  There was a very short period over a year ago the Exodus Wallet supported a now fully deprecated version of Monero after a hardfork.

Similarly, there was a very short period were there was alpha code that supported Monero on a Trezor until Ring CT hit the streets. Monero support on a Ledger hardware wallet is in the pipeline.

However, BIP 32,39,44 technologies used by Jaxx (along with BIP 47) and other hardware wallets can be extended to support Monero, see this libbitcoin Monero example. This leads to two working examples for how BIP 39 seed words can be deterministically mapped the 25 Electrum words used to reconstitute Monero wallets.


There are no hard rules. fluffypony gets on a merge fest from time to time, and will merge any outstanding PR that's had at least a couple days time to be reviewed. There are not many reviewers though, so he will review what isn't, and merge. Some PRs fixing urgent bugs get in quickly, and other more complex ones, or ones attracting review comments, get in more slowly.


Force daemon to a specific hard fork version

You can just remove version 7 and 8 from the testnet fork table near the top of src/cryptonote_core/blockchain.cpp (the last two lines as of this time).
You will have to pop blocks first till v6 with the current binary (monero-blockchain-inmport --testnet --pop-blocks N), then make that change.


How is the Monero network hashrate calculated and how is it different than bitcoin?

Bitcoin uses a different difficulty adjustment algorithm than Monero, which consequently leads to a different estimation of the network hashrate. More specifically, Bitcoin uses a fixed window of 2016 blocks, which should take approximately 2 weeks with 10 minute blocks. After this window the difficulty is retargeted such that, on average, the block time (the time it, on average, takes to mine a block) is 10 minutes. That is, if the window took less than 2 weeks to complete, the difficulty will be adjusted upwards and vice-versa.

By contrast, Monero uses a rolling window of the last 720 blocks. In essence, for each new block the difficulty is being retargeted based on the last 720 blocks. Thus, for example, block 1000720 will take blocks 1000000 to 1000720 for the difficulty calculation, whereas block 1000721 will take blocks 1000001 to 1000721. In addition, to mitigate the effect of dishonest and inaccurate timestamps, 20% of the outliers are cut-off for the calculation¹.

A rolling window will reduce the variance of block time, because the network is able to adjust the difficulty every block. By contrast, with Bitcoin it would be possible to push out 5 minute blocks for a week or 1 hour blocks for 12 weeks until the difficulty retargets.

Sources:

https://cryptonote.org/whitepaper.pdf


GUI build error about "undefined reference"

This is libunwind. It probably was wrongly detected. In the meantime, you should be able to build by removing libunwind-dev (or similar) from your system.

It might also be that you changed your system and cmake kept some cache. A rebuild from scratch (that is, removing all build trees) might fix this, if this is indeed the case.


There is no such ability in Monero. However, grep, sed and awk can be used for this, along with tail -f. Remember --line-buffered with grep.

That should do what you're asking:

tail -f ~/.bitmonero/bitmonero.log | grep -v --line-buffered INC

The grep pattern might need tightening a bit in case it matches other things with INC in the line, though I can't think of one right now.

In the nebulous future, an overhaul of the logging system is planned, which may include an ability to turn on and off different sections of logs.


Post quantum signature scheme integration in Monero

The mnemonic seed is a representation of your secret spend key. It looks like your secret key has a LOT of zero bytes.
There are 3 words for every 4 bytes, so if your secret keys are 2 kB, you end up with 1536 words. Abbey being the first word in the English dictionary, you see that the key you're encoding there is mostly zeroes.
The output format expects only 25 words, so inserts two newlines. The rest is on a single line.


Do coins mined per day scale linearly with computing power?

Well, it's close to linear.  It basically is.  If there are 200 billion hashes per hour on the network currently, and if you are providing 200 thousand of those hashes, then you have a 1-in-a-million chance of scoring a block, right?  If you double your hashing from adding a card, then you have a 2-in-a-million chance.  But that's using rounded numbers (which are most applicable to the real world generally).

But let's imagine that you decide you want to run a million of those 200K hash cards.  You'd be performing 200B hashes per hour.  But the network was already at 200B/h, so now it's at 400B hashes per hour.  So instead of you having a million-in-a-million (100%) chance, you'd only have a 50% chance of scoring any given block.

To address the added concern, the law of averages effectively says that only in appearance will the pools take greater than their share of winnings.  If a pool is mining at 40% of the hash rate of the network, they have a 40% chance of winning a block.  It really is as simple as that.


How does RingCT work with / without coefficients?

The equation is rct = x*G + a*H(G) where * indicates scalar point multiplication in the ed25519 curve, x is the "mask", G is the base point of the curve (group generator), a is the actual amount, and H(...) is a function that returns a point on the curve based on the cryptographic hash of the point G. The "mask" (x) is randomly generated so there is no relationship between the amount and the rct value published (assuming a quality RNG); rct is the result of adding the real value to a random value.

The coefficient comment probably came from the x*G portion, but the masking value is not really a coefficient of the real value.


What is the best way of accepting payments for listings using monero as payment, converted and paid into bank

If you want to get Monero converted to fiat directly to your bank account, you'll want to check out https://globee.com/, which allows your users to pay in several cryptocurrencies and will pay you in your choice of fiat (you can also decide to keep some part of the income in monero if you wish).

Globee offers plugins for various website hosting software (https://globee.com/plugins) but also allows you to use their API directly should you decide to integrate it manually.

For small users, there is a "free" tier, though it will require a $10 minimum price (and will charge 1%, so not actually free, they have to earn somewhere). This might be a showstopper since you mention prices as low as $1.

If this doesn't meet your requirements, then maybe https://github.com/monero-integrations might help, though I think it's Monero only - no fiat conversion.


You probably using a XMR Address with the XMO pool port. Change your port to 45700


How was the official Monero website hacked to deliver malware at the end of 2019?

It was the server hosting the binaries that was compromised during this attack. Luckily signed files with the genuine binary hashes were available on other sources and servers, so the attack was noticed fairly quickly. Here is the announcement on r/monero relating to the compromise: https://www.reddit.com/r/Monero/comments/dyfozs/security_warning_cli_binaries_available_on/ .
Additionally security researcher SerHack published a postmortem on the binaries and the hack itself that goes into some more detail: https://serhack.me/articles/cli-binaries-compromised-monero-analysis/ .


Why is monerod so slow to sync the blockchain?

Access to the database file (data.mdb) can be very slow if you are using a HDD for storage, because of the fragmentation of the database. Using a SSD improves things a lot.


How Monero transactions related with mixins

"Mixins," known more commonly as "decoys," impact the input side of the transaction. They do not have anything to do with the number of outputs.

Each input has the number of decoys included in the ring signature. If multiple inputs are used, then there will be multiple ring signatures, each with their own set of decoys.

Each transaction has a minimum of two outputs, even if there is no change.

If I send 12 XMR in a single input to a single person with 5 decoys (6 ringsize), then the transaction will have 6 total possible inputs and two outputs.

If I send 12 XMR in two inputs (eg: 10 XMR and 2 XMR) to a single person with 5 decoys (6 ringsize), then the transaction will have 12 possible inputs (6 ringsize x 2 spent inputs) and two outputs.


How do you convert the Monero blockchain from Linux to Windows?

As far as I know, the current blockchain is compatible across different operating system as long as they have the same "amount of bits", i.e., 64 bit to 64 bit systems or 32 bit to 32 bit systems would work, but 32 bit to 64 bit systems wouldn't work.

If this doesn't work there is a second option. That is, you can export on your Linux system using the blockchain_export tool. This will create a blockchain.raw file, which you can subsequently import on Windows with the blockchain_import tool. Given that you use your own blockchain, you could do this with the --verify 0 flag (this skips verification) to improve speed.

There are more specific instructions here under "Updating: Blockchain Conversion".


It can take a while to fully start up, especially on lower end machines.


Can cpuminer-multi be used for solo CPU mining?

Wolf0's CPU miner does not contain any code to support the fairly new daemon+tcp scheme, so cannot be used to solo mine.

However, you could setup your own private pool, and connect to it.If you disable payouts, this is as close to solo mining as you can get without being standard solo mining.


Why is the Monero node separate from the wallet?

It's good practice to separate them, here's why:

Security. The node is open to the network and the wallet keeps your private keys. In case some exploit was found in the node sofware, this significantly reduces the risk for your funds
Practicality. You can run multiple wallets all talking to the same node. With them bundled together this becomes messy, if not impossible.
It's easier to focus on improving one aspect of the overall suite.
It's easier to debug
It's easier to maintain
By having a stand-alone node software, you already did half of the work for many other uses like exchanges, mining pools and block explorers without them having to poke out relevant code from a bundled mess of everything.
By having a separate wallet software, you make it easier to write another wallet implementation.
The inner workings of the software will be easier to understand for those new to the code

To take this further, specific parts of each software could be "librarized", so it would become even more modular and allow flexibility in future development and allow to use already built code with other languages etc. In fact, this is also one of the long term development goals.

Suggested further reading on software design and modular programming.


Does Monero (XMR) or Pirate (ARRR) offer better privacy and security?

Let's begin by discussing their backgrounds and privacy technologies.
Monero
Monero was launched in April 2014 under the reference CryptoNote protocol. Upon launch, the privacy protections were still better than comparable solutions at the time, but the privacy was weak by today's standards.
Monero uses ring signatures, RingCT, and stealth addresses to hide the sender, receiver, and amount for all transactions. There is no way to send a public transaction using the blockchain alone. Stealth addresses disassociate outputs from addresses. Ring signatures make the sending outputs (sources of funds) in transactions unclear/ambiguous. Ring Confidential Transactions (RingCT) hides the amount. All 3 are forms of zero-knowledge proofs.
Monero's ring signatures are not perfect at protecting against every possible heuristic, but they are good enough in most cases. If you use Monero to interact in strict thread models against colluding actors (including countries and regulated exchanges), then you may need to take extra precautions to "churn" your Monero to get enough privacy to meet your threat model. However, for someone making typical transactions, Monero provides excellent privacy.
Pirate
This is a new cryptocurrency launched in 2018. It claims to be a more private implementation of Zcash. It takes the same zkSNARK technology and makes it mandatory, vastly improving privacy by decreasing the amount of leaked metadata and transparent transactions.
PirateChain hides the sender, receiver, and amount for all transactions just like Monero. However, it offers even better theoretical untraceability protection. It can better hide the sending output by making it appear to come from a wider set of possible sources (keep in mind neither cases connect these sources to identities), rather than just a dozen or so with Monero.
PirateChain relies on Komodo's dPoW security and a trusted setup.
Comparison
Monero is a much larger network with more entropy. Far more people use Monero than Pirate, so it is much easier to hide in a crowd of other people. Pirate may offer theoretical advantages, but in reality, it is likely that these benefits are outweighed by the size of the network. Pirate may offer better privacy than Zcash; even though Zcash is more widely-used, the fully-shielded portion is less-commonly used. Furthermore, at the time of writing, Pirate does not support Sapling, so it takes a powerful machine several seconds to send transactions.
Furthermore, Pirate is less secure than Monero. Monero uses its own standalone blockchain and PoW system to secure it. Pirate uses Komodo's dPoW system. This system has its own (significantly smaller) set of miners. However, they claim it is secure since they "back up" the blockchain to Bitcoin. The actual effectiveness of this security mechanism has received little to no attention, and this claim has little to no academic support. As a result, we generally assume that Monero's much larger mining network makes it more secure, since we have no good way of evaluating the effectiveness of Komodo's security. Of course, Pirate relies on a trusted setup to provide anonymity, so if this was ever compromised, then they could mint new coins without detection.
Pirate claims to be the best of Zcash (ZEC) combined with the best of Monero (XMR) and secured by Komodo's (KMD) Delayed-Proof-of-Work (dPoW)." Though it takes some of the best components of Zcash, it has yet to include the new, better Sapling code. It has nothing to do with Monero in technology or overlapping community. The security model of dPoW has not been researched extensively, so it's dangerous to take their security claims at face value.


How can I choose addresses to create a ring signature for a transaction

The code that currently randomly selects inputs is here:

https://github.com/monero-project/monero/blob/ebbd001a89ddbe0de1d1af297a04db8911f15e09/src/cryptonote_core/blockchain.cpp#L1666

You can modify this code to instead specify your own choice of inputs.


How can one query the blockchain's database?

If you're using python, the py-lmdb module includes a basic CLI. http://lmdb.readthedocs.io/en/release/

Keep in mind that you'll be getting raw data back, not anything in a human-readable format.


I restored my wallet, and I chose the wrong block height to start scanning. What are my options?

The most straightforward (and probably convenient) way is to, like user36303 said, exit the wallet and restart the process with the correct blockheight. There is currently no command to alter the restore blockheight after you have already entered it. Furthermore, I personally don't think it would be worth to implement such a thing, because the reward is not worth the amount of work that has to be put into it.


MinerGate mining Monero cryptocurrency with ArubaCloud

When mining on a VPS drops, the likely reason is that you either got throttled by the admin, or your VM shares hardware with other VMs which are competing for the CPU time.

If this VPS provider can migrate VMs on other hardware, it might also be the case that the previous hardware had (and exposed to guests) AES-NI instructions, and the new one does not. AES-NI on Intel/AMD are instructions which speed up Cryptonight mining a lot.


What are the differences between incoming/outgoing connections?

Your understanding is correct: outgoing connections are initiated by you, incoming connections are initiated by the peer. You can certainly have a peer syncing from you via an outgoing connection though.

The 800 connections is just a bug in the accounting. They're not all actual connections. You can see that using netstat or similar tool.

When a node is synced, it still needs connections to process new transactions and blocks. The default is to keep 8 outgoing connections, regardless of whether the node is synced.