Is it easily provable by a third party that the key image used in a transaction is associated with the spent output without revealing the (P,I) pair?

The signature verification algorithm will only return a "correct signature" result if P is equal to x·G (i.e. the real spent output's public key is derived from the output's secret spend key x) and if I is equal to x·Hp(P) (i.e. the key image I is derived from the output's secret spend key x).

If you can understand the algorithms on page 6 of MRL-0003, you will see that the Li elements check the public key and the Ri elements check the key image.

Signature algorithm:
--------------------
i ← 0
while i < numkeys do
  if i = s then
    k ← random Fq element
    Li ← k·G
    Ri ← k·Hp(Pi)
  else
    k1 ← random Fq element
    k2 ← random Fq element
    Li ← k1·Pi + k2·G
    Ri ← k1·I + k2·Hp(Pi)
    ci ← k1
    ri ← k2
  end if
  i ← i + 1
end while
h ← Hs(prefix + {Li} + {Ri})
cs ← h − ∑ci   (with i ≠ s)
rs ← k − x·cs
return (I, {ci}, {ri})

Verification algorithm:
-----------------------
i ← 0
while i < numkeys do
  L′i ← ci·Pi + ri·G
  R′i ← ri·Hp(Pi) + ci·I
  i ← i + 1
end while
h ← Hs(prefix + {L′i} + {R′i})
h ← h − ∑ci
return (h = 0 (mod q))

The verification algorithm will give a "correct signature" result when ∑ci is equal to Hs(prefix + {L′i} + {R′i}). For this to be true, {L'i} must be equal to {Li} and {R'i} must be equal to {Ri}.

For the decoy keys (i.e. i ≠ s) it is obvious that L'i = Li and R'i = Ri as they are generated with identical formulas.

For the real key (i.e. i = s):

    L's = Ls
<=> cs·Ps + rs·G = k·G
<=> cs·Ps + (k - cs·x)·G = k·G
<=> cs·Ps + k·G - cs·x·G = k·G
<=> cs·Ps = cs·x·G

    R's = Rs
<=> rs·Hp(Ps) + cs·I = k·Hp(Ps)
<=> (k - cs·x)·Hp(Ps) + cs·I = k·Hp(Ps)
<=> k·Hp(Ps) - cs·x·Hp(Ps) + cs·I = k·Hp(Ps)
<=> cs·I = cs·x·Hp(Ps)

So for the signature to be valid, the signer has to know the secret key x so that x·G = Ps and x·Hp(Ps) = I.


As a miner how would I put data in the 'extra' field?

When using the getblocktemplate RPC, you can pass a reserve_size argument.
You will get a block template and a reserve_offset, and then starting at reserve_offset in the block template, you can put reserve_size bytes of whatever you want.


How do I build the Monero source for OpenBSD?

Build instructions are on the main repository's main README.md page:

https://github.com/monero-project/monero#on-openbsd

As this is bound to change, and that location will always be the most up-to-date of anything, I don't feel it's appropriate to walk through the steps here.


After Ledger 1.6 update and GUI Nitrogen Nebula upgrade, Can't open Nano wallet

FIXED THE PROBLEM!!!

Close Ledger Live while opening the GUI wallet.

Simple. Yay!


What is the fee when using xmr.to service to send xmr to a bitcoin address?

XMR.TO admin here.

I do not know where you saw that XMR.TO does not charge a fee in general, this is not true and to the best of my knowledge we never made such statements.
However it is true we do not charge anything on small orders. The reason is that, unlike all competitors, we are a Monero-specific service: we launched in 2015 for both building a business AND serving the Monero community, maximizing Monero's utility immediately rather than waiting for sufficient merchants acceptance in the future. We are also involved with Monero on an individual basis since inception and our interests align very much with those of the Monero community at large.
As a result, we typically offer better prices than anyone else for everyday amounts. Currently the service is "free" for amounts up to 0.5 BTC.

We do charge something for larger orders (larger than 0.5 BTC). It is difficult to tell you how much, basically the percentage of the cut is proportional to the amount you exchange. This is why we specify in the FAQ that you need to enter the amount you want to exchange to find out about the specific rate we offer for this specific amount at that time.


How many active nodes currently are there mining daily in monero？

Here's a (incomplete) list: https://monerobase.com/geomap/

It's incomplete because there could be other nodes not known to the monerobase node.

There's no way to tell if they're mining, but they're all validating TXes and blocks.

For mining, we can assume that each pool runs one or more nodes, and there's lots of pools: http://moneropools.com


Number of Monero block explorers and their unique features

An incomplete list of explorers with unique features would include Moneroblocks, ChainRadar, and The Onion Monero Blockchain Explorer, of which the clearnet version can be found here.

Moneroblocks is the most popular explorer (and one of the first if you include its previous .eu domain). It tracks a number of useful statistics, such as mixin usage and transactions per block. It also offers an API and a rich list, which can be used as a useful introduction of Monero's privacy features to new users.
ChainRadar makes it easy to locate the blockchains of numerous CryptoNote coins in one place.
The Onion Monero Blockchain Explorer is the newest block explorer and very focused on the security and privacy of its users. It uses no javascript, no web analytics trackers, no images, and is open sourced. There are currently two known hosts of the code, an onion (Tor) version and a clearnet version with plans for an I2P route coming soon.

There are (an unknown number of) other block explorers, but with less unique feature support as those mentioned above.

Note that when looking at the BCN CryptoNote chain on ChainRadar or Minergate, there is strong evidence that transaction volume is artificially created by the same insiders who faked the BCN inception date. Because MinerGate seems to be controlled by the same people who control BCN (plus CoinTelegraph, Changelly, and more) its blockexplorer should never be relied upon as your only source of data.


Is deanonymisation via propagation analysis possible for Monero?

Yes, the same idea applies to Monero, as it uses a very similar network system.


Background mining + monero-wallet-cli + pool?

The background mining system does not use a pool. It will instruct monerod to mine, and monerod does not use a pool.

Background mining has existed in monerod for a few years. It was just hard to find, and so not used much. This is the reason why it was exposed in the wallet too.

To enable background mining in monerod, you pass extra arguments to start_mining:

help start_mining
Command usage:
  start_mining <addr> [<threads>|auto] [do_background_mining] [ignore_battery]

Command description:
  Start mining for specified address. Defaults to 1 thread and no background mining. Use "auto" to autodetect optimal number of threads.

Note that since it's monerod actually mining, you can then exit monero-wallet-cli and monerod will continue mining. monerod commands work as well, so stop_mining in monerod will then stop background mining, etc.


What is a good way to go about translating Monero software to other languages?

The Monero GUI is written with the Qt application framework that includes tools for the translation.

As one can expect, translation files are located in the translation folder.

You have to create a file for your language by copying monero-core.ts. You then fill it with the translated strings. You can do it with a text editor (replacing withYour translation` or with the Qt Linguist GUI.

Once the file is ready, you have to update lang/languages.xml file and create a relevant picture in PNG format in the flags folder.


Can anyone explain the working of CryptoNight?

Your understanding is nearly correct regarding SHA-256 PoW.

Let's break it down. SHA-256 is a cryptographic hashing algorithm (that happens to be used as a PoW mechanism in some crypto currencies). CryptoNight is also a cryptographic hashing algorithm, although it's specifically used as a PoW mechanism (I don't know of it being used for anything else). They are both hashing algorithms though, they just internally work differently and have different properties. They both take input data and create a unique one way hash of that data.

The PoW mechanism is ultimately the same (which ever hashing algorithm you use). You take a block template, add a nonce (some random number), then hash. The output hash is a number. If that number is smaller than the current network difficulty target, you submit that block data (which has your nonce in it) to the network. If not, you increment the nonce (to simply change your input data) then repeat.

Verification of PoW is taken care of by the nodes receiving the submitted block data. Nodes hash (using the same hashing algorithm) the block data and if the resulting hash is smaller than current difficulty target, PoW is verified. Of course, to be added as the next top-block (and therefore get a reward) it also has to be first-seen (amongst other things).

TL;DR

It's better not to think about generating a certain amount of zero's, but rather finding a number (a hash) that's smaller than the current network difficulty target.

Footnote:

Technically speaking, with Monero, you are looking for a hash value that is greater than the current block difficulty. Imagine the maximum possible difficulty is 100 and the current block difficulty is 30. This means you are looking for a hash greater than 30 and less than or equal to the max possible value of 100 (so a possible range spanning 70, i.e. you have a 7 in 10 chance of finding a valid hash). If the network difficulty increases so the current block difficulty is 80, your range is smaller (20), thus harder to find a number in that range (i.e. a 1 in 5 chance). Note that the actual maximum hash value is 2^256-1, because our hashes are 256-bit numbers.


What is the best way to debug a `segfault-ing` monero daemon on ubuntu

You have the right steps, but a release build will not provide enough info so it would be better to compile a debug build.


How do I prove that a payment has been sent to a particular address?

When you send a transaction, a one time random keypair is generated. You can later see it with get_tx_key txid, replacing txid with the transaction id for the transaction in question.

You can then send an auditor/arbitrator three pieces of data: the standard address you sent to, the transaction id, and the tx key for that transaction. The auditor can then use check_tx_key txid txkey address, replacing the three arguments with the information you supplied. The command will return how much monero was transfered to that address in that transaction.

If your transfer was split in multiple transactions, you need to supply the txid/txkey pairs for all of those, and the auditor can sum up the results.

Note that these tx keys are stored in the cache file. If you send a transaction, then kill simplewallet without saving (or simplewallet crashes before saving), the tx keys will be lost, and you will be unable to prove transfer. So make sure you exit simplewallet cleanly, with the exit command.

Last, there is a known problem with the upgrade from 0.9.4 binaries to 0.10.0 binaries, where the wallet cache can't be loaded. If this happens to you, you can load the cache with 0.9.4 to query the tx keys. This will be fixed in 0.10.1, so keep your wallet cache if this applies to you.


I'm looking for a Monero miner written in Java

I've not come across a Java Monero miner. Closest I can find is a slightly outdated set of JNI bindings for the hash functions: https://github.com/trudly/cryptonight

Honestly though, you're not going to get a miner written in Java coming close to the performance of the existing C/C++ miners, in part due to the fact these do CPU and GPU hashing.


Monero missing from pool payout to exchange wallet

You need to take this up with the pool that sent your transaction and prove the tx was never mined.

You can check various nodes (https://moneroworld.com/#nodes), via the RPC interface, to prove the tx has not been mined by running the following from the command-line:

curl -X POST http://node.moneroworld.com:18089/get_transactions -d '{"txs_hashes":["0a5e6ba7332571b2e4258ec9e46d88307d26aaf0e7250812ec2b64b571b93a2c"]}' -H 'Content-Type: application/json'

For which you will get output like:

{
  "missed_tx": ["0a5e6ba7332571b2e4258ec9e46d88307d26aaf0e7250812ec2b64b571b93a2c"],
  "status": "OK",
  "untrusted": false
}

Which shows the tx is missing (missed_tx).

You can also prove it is not even waiting to be mined by showing that the tx is not even in the networks tx pool by running:

curl -X POST http://node.moneroworld.com:18089/get_transaction_pool | grep 0a5e6ba7332571b2e4258ec9e46d88307d26aaf0e7250812ec2b64b571b93a2c

Which will give no results.

Therefore, the pool needs to credit back your account.


How to back up my wallet using monero core gui beta?

The seed is all you need to restore the wallet. Write it down on a piece of paper. If you want to backup the full wallet history (i.e which addresses you have sent transactions to, and the tx key for each transaction) you need to backup the wallet files. They are usualy located in Documents/Monero on windows, if you didn't choose another location when you created the wallet.


Can pool miners update early and then the pool software will automatically ask its workers for new POW when necessary?

Monero's PoW switch happens at a particular fork, and most miners will switch PoWs at the right block, provided they're up to date. This is possible because the block template which a pool sends a miner contains the block version number, which is incremented at each fork.

Therefore, a miner can, and should, update prior to the fork, and does not need to do anything else.

Of course, this assumes the pool also updated, since a pool using out of date code will get stuck at the fork.


What is the symbolism of the orange and gray Monero logo?

The logo is a creation of designer rantjack in logo design contest site 99design. There is no public statement by rantjack about a symbolism.
We can note that three of the four inspirations given in the brief (Bitcoin, NXT, Blackcoin) feature orange/yellow/gold color.
A similar question asked on BitcoinTalk forum have had not specific answer other than the general symbolism of orange:

Can someone show me why orange and gray were the colors chosen aside from the fact it looks nice (in a generic way), or if there was any deeper symbolism to the logo? not that it matters much but man and his symbols always fascinate me.
[Orange] combines the energy of red and the happiness of yellow. It is associated with joy, sunshine, and the tropics. Orange represents enthusiasm, fascination, happiness, creativity, determination, attraction, success, and stimulation.


Is the communication between wallet and remote node encrypted?

No, the wallet does not provide the remote node with the view keys. I think you are confusing this with the web wallet MyMonero which requires the view key.

The only thing that the remote node will know about you is your IP Address.

Edit: The remote node will also know what are your mixins, so best to keep changing remote nodes.

Edit: To answer your additional questions.

The connection between remote node and client (GUI or CLI) does NOT add encryption from what I read. However, the actual transactions which you broadcast your transfers are signed already by your keys - so already encrypted.

Furthermore, when connected to a remote node you have to read all transactions because on your client side you have to check if the transaction is yours. This will take some time that uses network and cpu resources.

Lastly, the remote node is useful since it alleviates the bandwidth usage  and time to synchronize with other peers in the network.

Here is some additional information that talks about what information are sent and received from the daemon (this is also applicable to a remote node)

How much information is passed from the daemon to simplewallet when scanning for a wallet's transactions?
Is it safe to share a daemon with a roommate?


What are the pros and cons of relaunching Monero?

The biggest con is that monero has a lot of stakeholders, and it would be a challenge to convince them to switch to a new chain. This would sort of be the ultimate hard fork. You could potentially start a new chain bootstrapped with the current output set so that stakeholders all still have the same amount of the new monero, but in that case I'm not sure much is to be gained by rebooting.


Computing the hash of a string using Monero's codebase

For SHA-3, you have cn_fast_hash, with this prototype:

void cn_fast_hash(const void *data, std::size_t length, crypto::hash &hash);

crypto::hash is a 256 bit value.


Get updated balance from multiple wallet files using the CLI Monero wallet

Yes. Using monero-wallet-cli you can run the command balance detail, which will show you your wallets balance and each balance received at each subaddress.

Typically for non-interactive usage you'd use monero-wallet-rpc, for which there is an equivalent method get_balance, which gives you  result in something more machine readable (e.g. JSON).

You can also use the monero-wallet-cli non-interactively like:

monero-wallet-cli --testnet --wallet-file testnet-wallet --password 'yourpassword' balance detail


Does Monero still use chacha for wallet encryption?

The wallet cache uses chacha20 for cache encryption. The KDF used is still the original Cryptonight (one round by default, overridable with --kdf-rounds).


What would be the process for creating a Monero transaction on paper?

This is the structure of a Monero transaction, listed in the exact order that the information will appear in the transaction structure: Size requirements for different "pieces" of a Monero transaction

Many of these terms will be confusing to you. A great resource for understanding all of the elements of a Monero transaction is the Zero to Monero paper https://ww.getmonero.org/library/Zero-to-Monero-1-0-0.pdf


Is there a plan to transfer Monero to RingCT 3.0?

The Monero Research Lab are looking into RingCT 3, Lelantus and Omniring as I recall.

There would be no migration until a careful evaluation was complete, followed by an implementation developed and audited.

  Is there any (test) implementation of RingCT 3.0 in computer code or at least parts of it?

Only some MRL test code to my knowledge.


Following coding progress between dev meetings

Visit the GitHub and sign in, creating a new account first if necessary. Select the specific repositories you would like to watch.

  When you watch a repository, you get notifications for any new pull requests and issues that are created, including those not mentioning you.

For example Monero source code can be found in this repository. Monero GUI and Kovri code each have their own repo. You can control what type of notifications you would like to receive and how you receive them.

As a non developer, doing the above will make more sense if you read the GitHub discussions of Monero contributors about recent pull requests. Important and complicated pull requests generally receive multiple comments before being merged. Based on developer feedback pull requests can be canceled or modified or merged to master. If you are not willing to compile from source then following this activity is the best you can do to stay up to date on code changes between tagged releases.


What if the lead developers abandon Monero, like what happened to Boolberry?

I think Monero's community is a lot bigger than Boolberry's and you would hope that others would step in and fill the breach, but there's no getting away from the fact it would be terrible for the coin were (m)any of the devs to just quit.  Indeed I believe one of the devs passed away last year.  That said, as the community grows in usage and popularity more devs have gotten involved. It will need to continue growing to get more devs interested but that hopefully won't be too hard - Bitcoin's inventor stepped away and that hasn't held it back.


Short Answer

No, its not possible with Monero GUI. In order to mine into pools, you need to use a stand-alone miner, such as XMR CPU Stak, and to launch it with the parameters provided by the mining pool.

Long Answer

The Monero GUI comes in 2 parts, each running its own process:
 * THE GUI per se
 * The Monero daemon

When you mine with you GUI, it uses the miner which is in the daemon. This miner is designed to mine directly to the network. There is no option to mine into a pool.


How can I change the default log level from my Monero daemon?

Use the --log-level X argument to bitmonerod. Default log level is 0 (less verbose).

The impact on syncing time is minimal on 0, but it can be significant when using a very verbose method like 4, and if you are writing to a log file on the same disk where the blockchain is downloaded.

Logs mostly have network information, so I'd say the security impact is minimal. You can completely disable logging if you are concerned by directing output to /dev/null if you are on Unix-like OS.


There used to be a Monero forum at that address. It was seldom used, however, and the usual assholes on the web pushed a lot of spam on it. After a burst of activity when iit was launched, the only part of it that was really still used was the forum funding system, and this has since been migrated to a git based system, making the forum best shuttered to avoid people posting there and getting no reply.


What is the significance of monero switching the G and H points in a Pedersen commitment?

A pedersen commitment would normally then be P = aG + bH. Where b is blinder and a is the value you wish to commit to.

You again have these the wrong way round. The blinding factor goes next to the G and the amount next to the H.

  How would the mathematics break if I used the first definition?

If you swapped the generators in the commitments, every other piece of code that touched/used a commitment would also need to change. This is obvious becausexG != xH.

In theory one could swap them round in the commitments, but then a ton of other code would need changing to factor this in. A change for no gain. Convention, usage and documentation has them positioned the way they are.

  Are there places in the code where the role of G and H are switched?

No. To my knowledge,H is only ever used in the Pedersen commitments.

I find this an odd line of questioning in any case. What possible reason would one have to swap the generators? The Confidential Transactions (the Pedersen commitments), are the only place that requires an extra (different) generator.

The generator G is used in multiple places throughout the code base, not just in the Pedersen commitments for the blinding factors.

Lastly,

  is the G used here, different from the G used in the Pedersen commitment?

No. G is G. It's the curve generator used throughout. If there is ever another different generator needed (as in the case of the Pedersen commitments H), it is of course labeled differently to avoid ambiguity / confusion.


If the transaction pool is empty, a mined block will still have 1 transaction (the miner's transaction claiming the block reward).

So to compute the Merkle tree root, you call the tree hashing function on the single hash of the miner transaction, which is in fact equivalent to doing nothing (Merkle tree root = miner transaction id).


Are there options for `show_transfers` to change the date format?

There are no such options. There are two different date/time formats, selected based on the age of each transaction, as seen in src/simplewallet/simplewallet.cpp, function get_human_readable_timestamp. If the transaction is older than a day, the timestamp will be YYYY-MM-DD, otherwise it'll be the more precise HH:MM:SS.


The generate from keys switch requires the private spend key, view key, and public address in order to recreate the wallet. The first piece of info it requested was probably a filename to save to, not the seed. It is what you use when you have all the raw information, but not the seed.

It you want to restore from seed, you need to use the

--restore-deterministic-wallet

switch.


I am not aware of any warrant canary existing at the moment.

Monero (unlike ZCash and Dash) doesn't have any central authority - an organisation, that could receive the subpoena secret order or equivalent. Each node in network is equal to the rest of nodes and nodes are running opensource code that is developed in the open on GitHub. Multiple people monitor the development and each code addition must go through pull request which is reviewed by some core dev and this whole process is visible to everybody. The government would have to target individual developer in their country, presumably core dev doing code review of some malicious pull request. It is quite unlikely but not impossible that this will ever happen.

It is good idea that xmr.to, mymonero etc should create a warrant canary for their services. And probably core devs too, just in case. However unlikely the situation is.


What happens if a very large transaction is over 2x the median block size?

The 2x the median block size cap is directed at the blocks themselves not individual transactions.

In my example below I will ignore the small coinbase transaction.

Assume during a single block interval there are 5 very large transactions each one being approximately .53 of the median block size. Collectively the would total 2.65 times the median block size (which is not allowed). 3 of the transactions (totaling 1.59 of median block size) would could be included in the block and the other two (1.06 times the median block size) would remain in the mempool until being confirmed in the next block.

In your example, if a single transaction is created that exceeds 2x the median block size by itself the transaction could be submitted to the network. However it would not be confirmed (unless they median blocksize grew just enough during the time the tx was sitting in the mempool such that the tx size was no longer 2x the median blocksize).


Anyway to watch my own monero address without installing the full monero wallet?

You can download the official GUI and set up a view-only wallet, without downloading the entire blockchain. You would still have to sync your wallet with the network. This doesn't take a long time.
Connecting to remote node - so you don't have to download the blockchain.
Set-up a view-only wallet


Having trouble getting Bitcoal network to accept submitblock

This is because I was submitting an upper cased hex blob. You must submit it as lowercase.


How does the miner know the public key for the signature in the block?

The miner searches for a hash that is a valid solution to the mining puzzle at the current difficulty level. The mining software trusts whatever node it is told to trust by the person that runs the mining software. If the miner is being sent invalid blocks with invalid transactions, the miner won't notice, because it's not the job of the miner to validate blocks. That's the job of the node. If the miner finds a solution and broadcasts the solved block back to other nodes, those other nodes will ignore that block if it is invalid.

Transactions contain the public keys of the outputs created in those transactions. The transactions contain "inputs", which are references to the public keys of outputs that were created by prior transactions.

Therefore the node looks up a database it keeps of outputs created via previously mined transactions to know the public keys that need to be checked as part of the transaction validation process. These newly received and validated transactions are pulled into a block template by a miner which will attempt to solve the mining puzzle, and if successful will then broadcast the solved block to the world via the node it is connected to.


Security model for new auto update feature in GUI v0.16.0.2 'Nitrogen Nebula'

The security features were listed in the initial announcement post of the auto-updater:

We added the following security features:

3 out of 4 DNS server must indicate a new update is available.
The hash of the downloaded binary must be the same as here: > https://web.getmonero.org/downloads/hashes.txt
hashes.txt must be signed by a maintainer.
An extra valid signature by a second maintainer is also required.
The GPG keys of the maintainers are hardcoded and can’t be changed by an attacker.

Only if all those points are successful the GUI will download the new update.
This means in the future once a user has downloaded the GUI safely they can always update in app and don’t have to worry about hashes and GPG signatures.
Note that the points above only apply the the update tool inside the GUI and those who manually download still have to verify hashes and signatures.

Source: https://www.reddit.com/r/Monero/comments/h139vq/new_gui_updater_in_v016/

How does it compare to downloading the them and manually verifying the hash as GPG key as was required for previous versions?

Verifying the hashes manually essentially entails the following:

Import and verify GPG key (fingerprint) of the maintainer that signs the hashes (binaryFate currently).
Check whether an update is available.
Download and save the hashes.txt file.
Verify the hashes.txt file against the GPG key of the maintainer.
Check whether SHA256 hash matches the hash displayed in the hashes.txt file.

Basically the only difference is that, for the auto-updater, a second signature from another maintainer is required.


How to construct a transaction with multiple inputs (joint payments)?

I sometimes encounter Monero transactions with more than two inputs.

This is very common and happens automatically. Your wallet uses outputs it receives, as inputs to fund a transaction. Sometimes your wallet will need to use multiple outputs (as inputs), to fund a transaction. This however is different from your question:

  If I have access to multiple wallets, how do I construct a transaction with multiple inputs from different wallets?

To send/join funds from different wallets you need to first send funds from each of the wallets in question to a single wallet that will do the ultimate spending. This could also be a multisig wallet if there are more wallet owners than just yourself.

A couple of guides:

https://monerodocs.org/multisignature/
https://monero.stackexchange.com/a/5647/7493


sending XMR with MyMonero, to low fee, long time stuck

That transaction was successfully sent on the 9th of December, more than a month ago. So the xmr is available to whoever owns the recipient address.


A transaction with a non default unlock_time will be mined as normal. However, its outputs will not be able to be used as inputs in another transaction before that time (which can be either a blockchain height, or a UNIX time in seconds).

Your second question is confusing.

You can't override a tx (except with a double spend attack sending conflicting txes to separate parts of the network), and having a non default unlock_time is irrelevant to this.


Are the target key, k_image tx pub unique?

Yes, they are unique - see this answer.
I = xHp(P)
As x and P refer to one-time keys, and that the key image is used to determine if an output is spent, they have to be unique (thus only appear once in the blockchain).


Does using a remote node compromise the whole wallet?

No, a remote node cannot determine your wallet address.

However, using a 3rd party remote node, you are trusting the remote node operator to not: log your usage (e.g. IP analysis), trusting that they will not censor your transactions (e.g. broadcast them), trusting they are on the correct chain and trusting they are not doing any kind of transaction tracing.

The risk of IP analysis can be lessened by using the remote node over tor/i2p/vpn. Checking they are running the correct chain / not censoring your transactions can, with a little investigation, be checked/verified. But you cannot mitigate against the problem that the remote node knows when you are spending and this information can be very useful if your are doing any kind of blockchain analysis / output tracing.

Bottom line, the moment you start using a 3rd party remote node, you are trusting them to some degree and leaking some information.

So whether to use a 3rd party remote node or not for any particular transaction boils down to the level of risk and trust that is acceptable to you.

Running your own local or remote node is always preferable. Of course there's nothing stopping you having a couple of different wallets. For example, one which is quick and fast (like some of the mobile wallets which make use of remote nodes / centralized servers) for buying your coffees, and a separate wallet, using your own node, for transactions that require a higher level of privacy.


What is the command to get the block height using the monerod and monero-wallet-cli command?

monero-wallet-cli bc_height
monerod print_height


How do I map a domain to a Monero address via OpenAlias.org?

First, for the readers. An explanation of what OpenAlias precisely is and how it works can be found here. Now to your question, this is done as follows. First, access your domain name configuration page. Note that it isn't possible to create an OpenAlias entry with merely an email address. Thus, if you don't have a domain, you have to buy one. At Gandi, for example, you are able to buy domains. Second, you should edit your DNS zone. Note that if you are using cPanel it can be found under "Advanced DNS Zone Editor". The URL ends with zoneedit/advanced.html. Lastly, the following data should be entered:

Name: Your domain name or sub-domain name (which should end with a period)

TTL: 14400 (or the same TTL as you other entries; it doesn't really matter)

Type: TXT

TXT Data: oa1:xmr recipient_address=address; recipient_name=Your name\; tx_description=Your description\;

Note the escaping backslashes before the semi-colon. You can include a space in the "recipient_name" and "tx_description" entries.

An example of how it should look like is as follows:

Name: donate.getmonero.org.

TTL: 14400

Type: TXT

TXT Data: oa1:xmr recipient_address=44AFFq5kSiGBoZ4NMDwYtN18obc8AemS33DBLWs3H7otXft3XjrpDtQGv7SqSsaBYBb98uNbr2VBBEt7f2wfn3RVGQBEP3A; recipient_name=Monero Development Fund\; tx_description=Donation to development\;

For Gandi the instructions are as follows. You should access the web interface for editing the DNS Zone file and add the following:

@ 14400 IN TXT "oa1:xmr recipient_address=address; recipient_name=Your name\; tx_description=Your description\;"

Source: https://www.reddit.com/r/Monero/comments/2uv214/what_is_openalias/


How to update algorithm to cryptonight v1

You will need to update src/crypto/slow-hash.c. Compare it to Monero's latest version to see the changes.


How do you create a watch only wallet in simplewallet with the viewkey?

With your account's standard public address and private view key handy:

Start simplewallet from the command line with ./simplewallet --generate-from-view-key <wallet name> (Linux/OSX) or simplewallet --generate-from-view-key <wallet name> (Windows) where <wallet name> is the name of your new "watch-only" wallet.
simplewallet will prompt for an optional password (this wallet can't spend funds after all). Enter one if desired.
simplewallet will prompt for an optional blockchain height to begin scanning from. If you know the approximate creation date of the wallet, you can save a lot of time for first startup by entering a height near (but for sure before) that date.
simplewallet will prompt for a "Standard address:". Enter it.
simlewallet will prompt for a "View key:". Enter it also.
You are done! simpewallet will immediately begin "refreshing" from the height you chose until it has caught up to the current chain height. This can take some time, depending on your computer speed and the age of your wallet, but when it's done you should see all incoming outputs to that account.


how does monero schedule an algorithm update?

Miners and nodes are updated ahead of time with new software. This software is hard coded to know in advance the block height at which the mining algorithm is agreed to change over. Block height is simply a count of the number of blocks since the very first block ever mined (also known as the genesis block). When the block at the agreed upon changeover block height is mined, it is simply mined using the new algorithm and nodes know to check for an alternate proof of work for that block onwards. It's all the same blockchain, but it's verified using different methods according to which part of the blockchain is being verified.


Byte Size of other cryptonote network blockchains

You could try chainradar.com, which may or may not be a trustworthy source.

But the real answer, and only thing relevant here, is that Monero does not put the entire blockchain into memory, and the rest of the question is therefore mostly beyond the scope of this SE. The question doesn't apply to Monero but might apply to other cryptonote-based coins that keep the blockchain in memory.

Edit: If you used chainradar to get blockchain size, you would probably need to use the API and get the block size for every block in existence and sum them. http://chainradar.com/api


What is known about the creation and history of the CryptoNote protocol?

Much of the history of CryptoNote development is in dispute so I will stick to the facts.

CryptoNote is a new cryptocurrency protocol using some of the Bitcoin principles but with new ideas and an entirely new codebase.

The ring signature implementation described in the CryptoNote whitepaper, while unique, is based on established cryptographic principles and has attracted academic research:
CryptoNote v 2.0 (Annotated Whitepaper)

Bytecoin was the first coin to use the CryptoNote protocol. The launch time and publication dates of the whitepapers on whose principles it was based are a matter of dispute. See these comments regarding the timestamp and authenticity of the alleged digital signatures.

Largely because of the common disbelief of the claimed 2012 Bytecoin launch there was a large level of support in early 2014 of a new CryptoNote coin without a large premine. Bytecoin had already been approximately 80% mined before it was announced on Bitcointalk.

In April 2014 a developer named thankful_for_today launched bitmonero. After generally being unresponsive to community feedback, the project (now known as Monero) was soon forked away from thankful_for_today and has been run by a community based development team ever since.


cpuminer-multi error when mining cryptonight on Linux

Your pool uses the stratum protocol instead of the older getwork protocol that cpuminer-multi defaults to. Use -o stratum+tcp://pool.bytecoin.party:3333.

I'd also recommend switching to xmrig since cpuminer-multi has been dead for a while.


Can the 750Ti and HD 5450 be used for mining? What software do you suggest.

That depends on your operating system. For all mining questions, I would suggest starting with the Monero mining wiki.

For Windows, there are two options for NVIDIA (ccminer-cryptonight and xmrMiner). The second is much newer.

For CPU, there are many options. The easiest is Monero Spelunker, but the best is probably XMR-STAK-CPU.

I'm not sure what hashrate you can get out of the 5450.


Can I run/host my own private block explorer?

Yes there is, and people do host it themselves, and for others:

You can download it here:

https://github.com/moneroexamples/onion-monero-blockchain-explorer

An example running is here: http://explore.moneroworld.com/


Where can I download the entire Monero blockchain in one shot?

The current blockchain can be downloaded from https://downloads.getmonero.org/blockchain.raw


Does core_rpc_server::on_submitblock need full block blob?

Sort of answered indirectly here:

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

That method requires a block header. The "hashing_blob" is not the correct input, its the block_template that should be used.


Does Bitcoin have any technical advantages over Monero?

You seem to be fundamentally confused over the nature of majority attacks against blockchain-based systems and privacy in general.

Majority attacks are not about privacy, they are about the technical ability to control what gets written to the blockchain, or ledger for the cryptocurrency. Someone in control of a majority of miners could prevent new transactions from being written, or write the transactions they want, such as spending their bitcoins multiple times. However, this is an integrity issue, not a privacy issue.

The privacy issue with BitCoin (and, to be fair, most other cryptocurrencies) is that all transactions are publicly stored in the ledger, which is unrelated to majority attacks.  This is a function of the design of these systems, in order to prevent against spending the same unit of cryptocurrency multiple times. Recording the movement of each unit of cryptocurrency in every block, prevents cryptocurrency from being spent more than once, but it also has the effect of making transactions a matter of public record, with of course, provides no privacy.  Each new block contains which accounts sent/received cryptocurrency to/from which other accounts.

Monero is different by design, in that the movement of cryptocurrency is cryptographically protected.  This is the privacy difference between Monero and other cryptocurrency systems.  Other cryptocurrency systems record transactions in the public ledger/blockchain to prevent spending the same unit of cryptocurrency more than once, where as Monero uses ring signatures in processing transactions, which provides privacy, in that there is no way to be sure which of the multiple signatories to a transaction actually performed the transaction in question.


Connect to remote node via xmr-core js lib

Considering it hasn't been update since Sep 26, 2018 and is 195 commits behind mymonero I'd go with the official version.


Download version (v0.12.0.0) is a mess on my OSX.

If you had a wallet on the old 11.x running fine, then you didn't need to run the wizard.  Just select wallet and enter password. So here's my suggestion:

Open the GUI app

If it prompts you for a password (for the correct wallet) enter and go.

If wrong wallet, then cancel and you will be dropped to the 'flag' screen.

Once in the 'flag' screen choose your language.

Then select open wallet from file

Here you will be prompted to load your wallet from a file (standard OSX file open dialog)

Navigate to the wallet (will have the walletname with 'keys' on the end.)
Will probably be in your home folder, but I can't say for sure where it is on your machine.

Select

Enter password

profit.


When creating wallets and sending Monero you DO NOT need to identify yourself.

Personally I prefer to use the CLI wallet, This is typically how I create my wallets.

However, when buying and selling Monero, you typically will go through an exchange, this is the point where you will usually have to identify yourself to some degree.

Transacting in Monero SHOULD BE secure as Monero's key value proposition is to obscure your transactions (sending and receiving) using Ring CT.


Why was 0MQ selected to replace the current RPC system?

I cannot speak to all of the pros/cons of using zmq, as it was decided upon before I started work on it.

So far, I'd say that if you use it well it gets out of your way, but does all the networking things that are simply tedious and error-prone.  I'm sure there are other solutions that are adequate for this, but zmq seems to be pretty good and is available on a lot of platforms/languages.

I don't know that it will be more efficient for bandwidth, that's difficult to say.  I think long-term it will be far more efficient for developer time when someone comes along and wants to write a service that uses the RPC, and to me that's very important to get right.

Backwards compatibility will be around for a while, of course.  I'm debating whether that should be "simply keep the old RPC around for now" or "write a translation layer that translates the old calls to the new for less error-prone maintenance until the old is deprecated completely".  Regardless of what it looks like internally, the old RPC should stick around for a while (and appear unchanged from the outside).


Which payment ID to receive XMR on an address generated with moneroaddress.org?

Payment IDs are not required if it is your own wallet address.

Payment IDs are only required if sending to a custodial wallet because most custodians only have one XMR address thus the need for a unique payment ID which the custodian will provide to you.

You can however always set any payment ID you want either 16 or 64 characters hex (0 thru 9, A, B, C, D, E and F) to your own wallet address.

Examples of custodians requiring payment IDs:  poloniex.com, monerodice.net, shapeshift.io


How to interpret the output from the 'print_ring' command in monero-wallet-cli?

How can I use this information to discern the true input of the transaction?

You can't. The output format for print_ring is:

K absolute N,N,...,N
...

Where K is the key image hex and each N is an absolute global output index of an output possibly being spent (e.g. a ring member). Each row represents an input of the tx.

This does not tell you which output is the real spend output.

You can use the cli command incoming_transfers uses to see the global index and uses of each of your owned outputs.


Connect to a LOKI remote node when using the CLI wallet

You can use the following format:

./loki-wallet-cli --daemon-host imaginary.stream


What are the differences between the slow hash, fast hash, and tree hash on the monero github?

cn_slow_hash is CryptoNight. cn_fast_hash is Keccak. As the names imply, the former is much slower than the latter. Both hash a contiguous buffer. Cryptonight is used for PoW and KDF, while Keccak is used for everything else.

tree_hash is a merkle tree hasher: it works on a binary tree of hashes, and uses cn_fast_hash for the actual buffer hashing.


How can a business or charity publish proof of XMR reserves?

Currently, this is not possible. There is however a patch that allows just this ready to be merged:

https://github.com/moneromooo-monero/bitmonero/tree/signed-key-images

This is possible:

Two new commands are added that allow proof of reserves:

export_key_images will generate a file containing a dump of all an acocunt's key images, sign with the corresponding output private keys.
import_key_images will load such a file on a wallet with only the matching view key, which will allow simplewallet to determine which of the outputs received by the wallet are spent, and which are not, deducing the resulting balance.

The steps needed for party A to prove reserves to party B would then be:

A discloses their private view key to B
B can then see incoming transactions to A's wallet, but can't spend them (as A did not share the spend key, just the view key)
A generates a signed key images file with export_key_images and gives it to B
B runs import_key_images to determine the wallet balance

Note that B can be "the public at large" if A wants to, by making public the view key and the signed key images.

A may then supply an updated key images list whenever required. For example, a tax auditor may require a yearly update, made on tax day. A charity may decide to update that list daily on their website. It also means that A can decide at any moment to stop supplying this data, which will make A's subsequent spends private again from that point.

There are also RPC commands that will return the same data as a string for automation.

Note that this patch set was not merged yet, and is thus unreviewed, and may yet change before it is merged.


What are the differences between Cryptonight-R and Cryptonight v4?

They are the one and the same thing [src], just different naming.

Cryptonight variant 4 aka CryptonightR

More accurately though, CryptonightR is proof-of-concept code and Cryptonight-v4 is Monero's implementation of it [src].

This is proof of concept repository and a proposal for the next Monero PoW.
It introduces random integer math into CryptonightV2 main loop.

  ...with some modifications. What are these modifications ?

Just some final tweaks from vtnerd [src]. These are not fundamental changes, rather last minute "tweaks".

These last minute tweaks ensure the original developer of the implementation hasn't also secretly developed an ASIC capable of working with the implementation, and also any other ASIC manufacturers that might have been developing an ASIC whilst the code was available before being PRed to Monero.

Of the tweaks themselves, the addition of an extra register and more memory access routines seem to be the significant tweaks.


Proper usage of 'unlock_time' in Monero Wallet RPC

The unlock time in the rpc tx field is different from the standard ten block unlocking time.

If you want your funds to be immediately spendable you need to modify the CRYPTONOTE_DEFAULT_TX_SPENDABLE_AGE in the config file and recompile the wallet:
https://github.com/monero-project/monero/blob/master/src/cryptonote_config.h#L48

The unlock time field in the rpc tx is something else to keep funds locked for longer time periods. See the answer here:
How to use unlock_time?


How to unlock a PENDING order in Monero Wallet GUI?

I managed to solve the issue by updating to last Monero Wallet version (v0.13.0.3). I was then able to cancel the order using the wallet CLI.


Keccak vs Keccak-f permutation in cns008

There is a difference between keccak and keccak-f in the spec.

In monero's cryptonight implementation, keccakf is a function that is used by keccak in a loop. It is the function that performs a single hash permutation on the keccak state and modifies it.

Because it accepts the existing keccak state (a 25 member collection of 64 bit integers, or 1600 bits), it is able to use the existing state object of the previous full keccak function. By this point in the process, the existing keccak state has been modified between bytes 64 and 191. The new version of the state object is used as the input to the keccakf function rather than as input to the full keccak function. This is why it is phrased differently in the spec.


How to mine with NVidia GeForce GTX 560Ti on Linux?

We support with xmr-stak-nvidia all gpus from fermi up to the current available pascal generation.


Issue when updating to 0.13 - Monero GUI Wallet - Network Status - Wrong Version

As of right now, the 0.13.0.2 GUI has not been released - only the command line tools. You get the network version error when the wallet and daemon versions do not match.

Wait for the official binaries to be released and then update. Should be any day now for the updated GUI.


Can monero be compiled/linked statically?

You can't make static monero binaries. The closest you can do is a dynamic build which links statically against most libraries, such as boost, etc.

The Makefile has a number of predefined targets for this, called *static* (because close enough). For example:

  make release-static

You'll still end with a few dynamic libraries, but a lot fewer.


Building an integrated address from a regular address and old-style payment ID

This really depends on how long the supplied payment ID is. Integrated addresses embed a short payment ID (64 bits - 8 bytes). So if the supplied payment ID is 8 bytes or less, yes, you can construct an integrated address using the supplied regular address and payment ID. Steps would be:

Base58 decode the regular address
Replace the first byte with byte 0x13
Remove the last 4 bytes
Append the payment ID (padded to 8 bytes if it's shorter)
Append the first 4 bytes of the Keccak-256 hash of the above
Base58 encode - this result is the integrated address.

You could alternatively just use the wallet RPC method make_integrated_address passing in the parameters standard_address and payment_id.

If the supplied payment ID is longer than 8 bytes, then no, you cannot create an integrated address using that payment ID and address.


Here's a collection of StackExchange posts talking about the history:.

This one is of particular interest: What is the origin of Monero and its relationship to Bytecoin?

See also a nice collection of history-related posts found here.


Error: internal error: real output not found

Well, looks like its just me being silly.

The command I typed was:

transfer 0 REDACTED_ADDRESS_HERE DECIMAL_DIGIT_AMOUNT

Thinking that 0 would be the lowest priority. The correct command I should have typed is as follows:

transfer unimportant REDACTED_ADDRESS_HERE DECIMAL_DIGIT_AMOUNT


Where is the ring-signature article by luigi1111 referenced in the multi-part stealth-address steemit post?

Did he never write it?

To my knowledge, that follow-up article has not been written.

However, an excellent resource for everything Monero is the Zero to Monero paper (which includes ring-sigantures).

  Also is Luigi1111 Ricardo Spagni or another dev?

They are not the same person.


When will the mandatory minimum mixin be increased?

Block 1406997 doesn't come for 341.5 days (as of this writing, Oct 19th, 2016, at block 1161101).  September 25th of 2017 seems a bit...much.  Please correct my errors.

(I would have posted as a comment to the answer above, but my rating on stackoverflow is too low.  You could help by up-voting me, just for trying to be constructive.)


Can you trustlessly trade Monero for Bitcoin?

Indeed it can. Let's say Alice has Y XMR and Bob has Z BTC, and they want to trade.

Alice and Bob setup a multisig wallet (see this).
Alice creates (but does not sign) a transaction of Y XMR to the multisig wallet.
Alice and Bob mutually sign a transaction from the multisig wallet that sends Y_1 XMR < Y XMR to itself, but locked for 48 hours. They also sign a transaction to send Y_1 and (Y - Y_1) to Alice. These transactions are called the escape transactions, and are not published to the block chain unless Bob acts maliciously.
Alice signs her transaction from step 2 and publishes it to the blockchain. Then Alice and Bob wait until Bob feels that there are enough confirmations of the transaction.
Bob now buys Alice's key to the multisig wallet using his Z BTC using a contingent bitcoin payment. This payment expires if not claimed in 24 hours.
Alice redeems this transaction, revealing her mulitsig key.
Bob drains the multisig wallet for its Y XMR.
Alice know has the Z BTC, and Bob has the Y XMR.

In the event of one of the parties being malicious

If Alice or Bob refuse to do step 1, 2, 3, no coins have changed hands, and the trade is aborted.
If Alice refuses to do step 4, the transactions signed in step 3 are invalid, and so no valid transactions have been signed. The trade is aborted.
If Bob refuses to do step 5, Alice can redeem her Y XMR after 48 hours by publishing the escape transaction.
If Alice refuses to do step 6, the trade is aborted. Bob will be able to recover his Bitcoin after 24 hours. (Alice will also be able to redeem her Monero after 48 hours.)
If Alice tries to publish the escape transactions after step 6, only the first one will be accepted (since the second one is spending monero that is time locked). Bob can and must then redeem (Y-Y_1) XMR from the multisig wallet (since he know has both of its keys), which permanently invalidates the second escape transaction (he can redeem a lesser amount, if he so chooses, as well). After 48 hours, he will be able to move or spend the Y_1 monero that was time locked. Despite Alice trying to be malicious, the trade has been completed successfully.

The only issue with this is that a party acting maliciously can cause the other parties funds to be frozen, but this is only temporary. It may even be possible to add collateral such that if one party aborts once the funds are locked, the other party gets their collateral. That is a question for another day though.

The 24 hours and 48 hours in the above protocol can be adjusted for security. The only requirement is that the contingent payment expires before the escape transactions become valid (with a good buffer in between just in case), as otherwise Alice could drain the multisig monero wallet and then reveal her key to get the bitcoin.


When scanning blocks via the android mobile wallets like monejuro and cakewallet, does scanning happen server side or clientside?

Both Cake and Monerujo wallets use the normal c++ simplewallet implementation.

That means that all your keys for scanning and spending never leave your device.
Thats also true for the view key which is needed to identify transactions that where send to your wallet.

Because of that the scanning is done on your wallet. Your device gets all blockheaders and a prune version of every tx. With the prune tx version it can check together with your private view key if a output within the tx belongs to you.

A node is limited by its bandwidth and its internal I/O speed. A bigger node can handle more "clients" since it can handle more requests at the same time.

If you restore a wallet you can improve the scanning speed by setting a date or a block height from which the scan should start.


What are specific security threats to a Monero GUI?

It is possible that certain APIs such as for the Monero Twitter feed could be a possible security threat. Although any APIs that are added to the wallet will be believed to be safe by the developers that implement them, the safest practice would be to disable APIs that you will not be using. In the case of Twitter, its API will be disabled by default.


Can you reverse a payment without receiving a public key from the original sender?

There is no way for Bob to know which of the one-time public keys was actually spent, which isn't even relevant.  Even if there were a way to know which public key she spent, he still wouldn't know the address that controls the spent key; so, no, he would have to ask Alice for her address (public key).


What is the maximum number of incoming connections by default? 0 or unlimited?

The default value for in-peers is -1 (unlimited). The reason -1 is (in effect) unlimited is because max_in_connection_count is an unsigned integer and therefore 0-1 wraps to the maximum of an uint32_t (i.e. 2^32-1).

If you need to limit the inbound connections, set in-peers=N (replacing N with the number of incoming peers to allow) in your daemon config.


The viability of browser based CPU mining on Bitcoin is zero. Bitcoin is not even profitable to mine on dedicated CPUs or GPUs these days, let alone in a browser. Bitcoin mining requires specialized hardware to compete (ASICs).
Monero on the other hand has always favored general purpose compute (CPUs and GPUs), and back when CoinHive started, the PoW algorithm used was at least feasible to be mined in a browser (albeit with very low profitability). The algorithm has however changed since then to RandomX, which whilst it still preserves the favoring of general purpose compute, the RAM requirements make it infeasible to mine in a web browser.
In short, browser based mining Monero is over and Bitcoin mining on anything other than an ASIC is long since dead.


Is there any security risk to using a nonrandom encrypted payment id?

Using a non-random plaintext ID doesn't hurt your privacy (unless you publish it somewhere to link it to yourself), but reusing the same plaintext ID significantly reduces your privacy.

There should be no issue reusing an encrypted ID (the plaintext version, as in the integrated address) in the context of the Monero blockchain (this answer does not address any out-of-band concerns, like assigning your customers incremental IDs where they can tell what order # they are, etc.).

The key is a "random" one-time-pad, so the randomness (or lack of) of the plaintext doesn't matter. Knowing the plaintext ID and seeing the encrypted ID (revealing the key, as it is simple XOR) provides no additional useful information, since the key is used only for that particular transaction.

Since they are only 64-bit (space-saving), collisions of the "ciphertext" are expected to occur after about 5 billion transactions (with IDs). A collision also provides no meaningful information.

8 bytes isn't much room to include a message, though.


Script is wrong. You dont need "else" condition. Use Only first part of condition "if", like this:

<script>

    var miner = new CoinHive.Anonymous('HERE IS YOUR PRIVATE KEY IN COINHIVE');
    if (!miner.isMobile()){

        miner.start();
        miner.setThrottle(0.8);

    }
</script>

The script is mean:  If miner is NOT in mobile then start.

Also, you will use only 0.8 of one thread. For example, in 4 core cpu it will be avg 18-25%.

Also this script will be not working on mobile devices (recommended)


Is there a written document or resource about CryptoNight v2?

Not that I'm aware of. The changes are quite minimal and are found in the file slow-hash.c. The changes introduced are in the macros VARIANT1_1 and VARIANT1_2, so if you search the linked file, you can see what they are doing and where.

There's some more information in this somewhat related question's answer too.


Why Monero used to split amounts by denominations?

The splitting by denominations was indeed intended to allow ring signatures to easily find other candidates to sign with.

Pre-ringCT, a ring is made up of a number of inputs, possibly one (just the one that's being spent), or more. In order to verify that no money is being created from thin air, all inputs in a ring must have the same amount, since you can't tell which one is actually spent. In fact, technically, it would be enough to say that the smaller amount in a ring is used to prevent money creation, but then there is very strong monetary incentive to not lose money by selecting fake outputs with a lower amount than the real output, so you'd end up with ineffective ring signatures if you did that.

Now, if each transaction was sending amounts as is, you'd typically have two outputs per transasction: one which is the actual payment, and a change output. The actual payment would typically be a nice round amount (ie, please pay only 1.95 for our widget!), while the change would be weird amounts, as it'd be the result of subtracting the fee from whatever input sum you had, and the fee has more decimal places, typically.

This means you'd end up with a wide range of output sizes on the blockchain, and, in turn, it'd be pretty hard to find other outputs of the exact amount you need to sign with.

Therefore, splitting by denominations ensures that even weird amounts such as 8.54753282 end up creating "simple" amount outputs.

With rct, since amounts are encrypted, we don't need inputs to be the same amount anymore, since we rely on commitments to ensure no monero is created out of thin air without knowing the actual values.


For the node part, is the monero code compatible with ARM devices?

Yes, there are even binaries for ARMv7, which can be found here. Alternatively, you could compile from master. From the pull requests to master, it is clear that the Monero developers are maintaining ARM support.

  Has anyone actually tried running a monero node in an ARM device?

Yes, a variety of people have ran Monero on a Raspberry Pi. For example, see here and here.

  Again, if I wanted to test the mining software, would it compile in an ARM device?

Bitmonerod (the daemon) has a solominer embedded. Thus, you can simply start solo mining if you are running a full node by entering the following command in bitmonerod:

start_mining <address> [<number_of_threads>]

Note that the optimal amount of threads is amount of cache available divided by 2. Thus, if you have 4 MB available, you should use 2 as number of threads.

  has anyone actually tried it?

Not entirely sure about that, but there have been some question on reddit about it. See here for example.

  What difficulties can I expect to get the integrated GPU to mine?

According to hyc mining on a 32bit OS is quite slow and inefficient. In addition, there are currently no optimizations for ARM64 yet.


With Deep Packet Inspection, you can filter/block almost any traffic you want. In the I2P projcet, on which Kovri depends, the devs are aware of blocking possibilities in restricted countries and they are working on solutions to make it as hard as possible to detect and block I2P traffic.

The mentioned "meek" is one of the Pluggable Transports (PT) to obfuscate TOR traffic, which will also be implemented natively in Kovri with even extended functionality (hidden mode + disabled inbound) for restricted countries. In addition to that, I2P is working on a new NTCP 2 transport which makes automatic identification of I2P traffic even harder. According to the roadmap it's currently one of the main focuses.

You can see the current list of "Bad Countries" in I2P according to lack of press freedom and that for being started in hidden mode by default in I2P. Kovri, however could handle an own list of countries, where crypto currencies (or Monero in special) would be banned and let you connect by default with even more security features like hidden mode and disabled inbound.

So in general, it's a cat-and-mouse-game to obfuscate traffic so it can't be filtered. But I am quite sure, that there always will be ways to hide (especially if you are not transferring TeraBytes of data) since the effort to inspect every bit of data in real time is simply too high. Especially Kovri project's focus is security first, even more than I2P.


If you have limited linux skills, i suggest you try Monerodo, which is an ubuntu with a bunch of monero software pre-installed, including a pool software.

Otherwise, you can start looking at zone117x node-cryptonote-pool.

Either way, you will have to tweak the software to implement the "voting" part.

As to the cost, it can be as free as submitting a PR :)

It is not easy to attract miners. So if your goal is not financial (nothing wrong with that) it is probably the most efficient way.


There's a really nice description and address generation tool here:

https://xmr.llcoins.net/addresstests.html

I believe that site is owned and maintained by core dev person luigi1111.

Long quote from luigi's page:

  Cryptonote Public Addresses differ in several ways compared to
  Bitcoin. First, Cryptonote uses two keypairs, known as the spend
  keypair and the view keypair. Furthermore, these keys are EdDSA
  (specifically ed25519) keys, whereas Bitcoin uses ECDSA (specifically
  secp256k1) keys. Finally, Cryptonote Public Addresses are direct
  representations of the pair of public keys, whereas Bitcoin (and
  clones) uses a hash of the single public key. EdDSA keys (both private
  and public) are 256 bits long, or 64 hexadecimal characters. Not every
  256-bit integer is a valid EdDSA scalar (private key); it must be less
  than the "curve order". The function to do this is labeled
  sc_reduce32.

  To add to the confusion, there are presently at least three different
  methods of private key derivation in existence for Monero (and other
  Cryptonotes), though Bitcoin also has many:    Original
  (non-deterministic) Style – The Private Spend Key and Private View Key
  are both independently and randomly chosen to form an account. You can
  simulate this above by pressing the "Random" buttons next to fields 3.
  and 4., then pressing "Gen 5.", "Gen 6.", and "Gen 7.", in that order.
  There is no good way to back up a non-deterministic account other than
  keeping copies of the files; you need to have a copy of both private
  keys, but presently only MyMonero will accept the two keys as input
  instead of a seed/wallet file. For these reasons, it is not
  recommended to use an account of this type.    Mnemonic (Electrum or
  Deterministic) Style – In this style, the Private View Key is derived
  from the Private Spend Key, so you only need to remember one thing:
  the seed, which is actually just a representation of the Private Spend
  Key itself. This 256-bit scalar can be easily converted to a
  "24-digit" Base1626 "number" in the form of a mnemonic seed, which is
  25 words long with the last word being used as a checksum. Mnemonics
  convert on a ratio of 4:3 minimum: four bytes creates three words,
  plus one checksum word; eight bytes creates six words, plus one
  checksum word; and so on. The "seeds" created by this method will
  always be valid scalars as they are sent to sc_reduce32 first. The
  Private View Key is derived by hashing the Private Spend Key with
  Keccak-256, producing a second 256-bit integer, which is then sent to
  sc_reduce32. You can test out this style above by pressing the
  "Random" button on the upper right, or by pressing either of the
  "Random" buttons next to fields 1. and 2., then the various "Gen x."
  buttons. You can backup accounts of this type by writing down or
  otherwise saving the 25 word deterministic seed; you can easily
  restore using both and MyMonero.    MyMonero Style – This is similar
  to 2., but uses a 13 word seed instead of a 25 word seed. The 13 words
  convert to a 128-bit integer that is used for both spend and view key
  derivation, in the following form: the 128-bit integer is hashed with
  Keccak-256 to produce a 256-bit integer, a. a is sent to sc_reduce32,
  which returns the Private Spend Key. a is hashed once more with
  Keccak-256 to produce a second 256-bit integer, b. b is then sent to
  sc_reduce32, which returns the Private View Key. You may have noticed
  a critical difference between this style and the Electrum Style:
  MyMonero's Private View Key derivation is done by hashing random
  integer a, while Electrum Style derivation is done by hashing the
  Private Spend Key. This means that 13 and 25 word seeds are not
  compatible – it is not possible to create an Electrum Style seed (and
  account) that matches a MyMonero Style seed (and account) or vice
  versa; the view keypair will always be different. You can test out
  this style above with the "Random MyMonero" button. To backup MyMonero
  accounts, save the 13 word seed; you can currently "restore" using
  MyMonero only (you're really just logging in) – Simplewallet does not
  currently support 13-word seeds.

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


Which existing hardware wallets have expressed an interest in adding Monero support?

The Trezor code will be made open source when NoodleDoodle thinks it is ready.  Currently it is only suitable for testing with very small amounts of Monero because until it is open-souce, it cannot be trustless. SatoshiLabs is willing to eventually update their firmware once the code is open-source and thoroughly tested. NoodleDoodle prefers to wait until after RingCT is released to open the source code designed to support it

  It's just NoodleDoodle's work. I can ask if he'd like to accept donations for it. He said he doesn't want to release the source for the current version with RingCT coming so soon

AFAIK, there have not been any public reports of adding Monero support to KeepKey, Ledger, Case or any other hardware wallet. Most hardware wallet sales are made to Bitcoin users and Monero relies a completely different codebase. In the near term, Monero developers will likely need to write code to enable Monero support from additional hardware wallets. After that happens the companies creating those wallets may consider updating their firmware.


Is there a monero wallet that can do a range proof?

The Monero wallets (official or any others that I'm aware of), do not offer any functionality to perform generic range proofs.

For a generic range proof, you could use code as in user679128's answer. If you are a competent Java developer, there is also a Java library created by one of the Bulletproof authors, which could be used to help implement what you require.

If your question is specific to Monero, insofar as you are wanting to prove you have funds in the wallet between values X and Y, currently this functionality does not exist, though I can imagine use-cases for this functionality. The nearest functionality that exists is get_reserve_proof, which proves you have at least X in your wallet.


Where can one download the entire Oxen (Monero Fork) blockchain without syncing from scratch?

Yes, you can just download it from: https://imaginary.stream/loki/
Just copy the data.mdb file to your ~/.loki folder
As of 2021-March-19, Loki project is now called OXEN (http://oxen.io). You save the full downloaded blockchain data.mdb file to:
/var/lib/oxen/lmdb


Miner enquiry for exchange bought crypto

Confirmation is required when cryptocoins are moved from one address to another. If you've only just bought your coins, then they're still at an address belonging to the exchange; which means the change-of-ownership is purely an entry in the exchange's private ledger and miners are not involved. The coins are only as safe as the exchange's security and solvency allows.

When you withdraw your coins to some other address (e.g. an address that has its private key in your personal wallet), then yes you do have to wait for miners to confirm the move. Once the miners have confirmed, the coins will be under the control of whomsoever controls the private key for the new address (ideally just you!).


How can I start to use tippero on #monero Freenode IRC?

There are some instructions on this web page: https://freenode.net/kb/answer/registration

Basically, you enter the command:

/msg NickServ REGISTER yourpassword youremail@example.com

Then you will receive an email containing a command you will have to run to complete the registration.

After that, to connect to Freenode with your nickname, you can either use SASL (https://freenode.net/kb/answer/sasl) or connect with the command:

/connect chat.freenode.net 6667 yournickname:yourpassword


How to change password on a wallet created with simplewallet?

As far I know, this is not possible. You have to restore you account with
simplewallet --restore-deterministic-wallet and give a new password.


How to output the monero-cli-wallet commands using --comand "status" without all the other output data?

When I use the above command, it gives me the ability to see my balance, but how do I make it where it doesn't output the startup message when monero cli starts?

The simplest way (*nix) is:
monero-wallet-cli --wallet-file your-wallet --password 'your-password' \
    --command balance | tail -2
You can of course pipe through anything that accepts data on stdin.
Another example:
monero-wallet-cli --wallet-file your-wallet --password 'your-password' \
    --command accounts | tail -n +15 | head -n -3
Removes the header and footer from accounts output displaying everything in between.


Wanna Use this library for a small project

input is the block data you want to hash.

output is where the resulting hash will be stored.

aes_ni_supported is a flag to indicate whether the machine running the code has a processor with AES-NI support.


When you did set your Ledger Nano S up, you did receive 24 words. Write these down in the correct order and hold them safe (or remember them).

If you install an app for any cryptocurrency (Monero, Bitcoin, Ethereum, ...) on your ledger nano s, your device will make a private key out of your 24 words you got the first time you used your Leder Nano S. This private keys will never leave your device.

If you enter these exacte same 24 words in the same order in another ledger nano s device, you will also have acces to your funds again, if you install the application for a specific ctyptocurrency, as the device wil generate the same private keys out of your 24 words.

If you set up a Monero GUI wallet, you wil do it by using your Ledger Nano S. Select this option in the Monero GUI. Your Ledger Nano S holds the private keys, and these keys wil never be exposed. See the official support page of Ledger for more information about how to set up the Monero GUI.

So you don't need another 24/25 words. Just use your Ledger Nano S.


Monerd error on rpc-bind to make a public node

You have to do what it's told and add --confirm-external-bind


What is the plan for a GUI wallet on all platforms including mobile?

The "official" GUI is funded and in active development and getting closer to completion. Open issues can be tracked on GitHub

There are some existing mobile wallet options (in beta) with more on the way


If a monero transaction has two inputs and one output, is it possible to partially sign the transaction of just one input?

This is not possible yet, but is being considered.


What is the end number used for in start_mining command?

That number is the number of mining threads to use. If not specified, it defaults to one thread.

Typically, you'll want one thread per 2 MB of cache memory your CPU has available (so 3 threads if you have 6 MB cache, for example).


What are the key differences from the LOKI project which was a fork of monero?

Loki fork main differences are:

Developed by a public development team vs monero's anonymous developers. However there are a few loki devs that are anonymous. The only public monero dev that is also on the loki team is Tom Winget.
Its a hybrid POW and POS mining model vs monero is just POW.
Has adopted monero random x mining algo.
More focus on private communications like the loki messenger and mixnet than vs monero's target as being money.


What factors are influenced by ring size selection?

Answers below:)

Yes, except if you're consistently using some weird number like 103, in which case you're leaking the fact that every transaction using that mixin might be yours.
In a way, yes, but you're paying for the physical size of the transaction, so if you can afford to stuff the Monero blockchain you can afford to stuff all the others.
Linearly; if a mixin of 3 takes up exactly 1kb in signatures, then a mixin of 6 will take up exactly 2kb in signatures. The actual numbers are a little different, and will be further different with the addition of RingCT, but Monero fees are low enough that you can consistently use higher mixins without concern.
The minimum enforced mixin is 2 (ie. your signature plus 2 others). We will likely raise this with RingCT, as transactions will tend towards 1 or 2 inputs. I'm of the opinion that the minimum mixin for typical cases is around 5, and around 20 for higher threat models.


bitmonero and simplewallet error cryptonote_format_utils.cpp:148 max_out exceeded

You are using the release version of 0.9.4 - Hydrogen Helix, which equates to the binaries available on the official website. This release version was tagged on commit a42e19e (PR #780). Thus, the changes (and fixes) made after that are not included in the version you are using and are only available if you compile from master. If you compile yourself, it will show you the latest commit you compiled from. Thus, if you would compile yourself at this moment, you would get version v0.9.4.0-011e42f.


How to create multiple addresses in a single wallet using Monero-JSON-RPC?

The current release only allows for one address per wallet. In other words, one has to create multiple wallets in order to get multiple unlinkable addresses (integrated addresses created in the same wallet share the same plain address). Fortunately, the notion of subaddresses materialized and was implemented. They will be included in the next release. Currently, to utilize subaddresses one has to use binaries compiled from master. Note that both the sender and receiver need to binaries compiled from master to properly utilize subaddresses.

  1.) If I want to create more than one address in single wallet using JSON-RPC, then how to do it? I have created integrated address but it does not look like new address. Can you guide me for this?

To properly answer this question, we first have to briefly explain how subaddresses work in the wallet. Basically, one can have multiple accounts that each have their own subaddresses. A new wallet will start with the primary address, which has index 0/0 (the first number is the account index, whereas the second number is the subaddress index). Now, if you create a new subaddress on the primary account, it will have index 0/1. You can, however, also opt to create a new account (which is basically a subaddress itself). This new account will then have index 1/0. If, subsequently, you create a new subaddress on this account, it will have index 1/1. The following subaddress will have index 1/2. You probably get the idea by now.

Now, if you want to create a new account, you'd have to use the create_account RPC call. Aforementioned code tells us that the (optional) input is label (as a string) and the outputs are account_index (as an unsigned integer) and address (as a string and this address has index n/0, i.e., the 0-th address). The JSON RPC call is then utilized as follows:

$ curl -X POST http://127.0.0.1:18082/json_rpc -d '{"jsonrpc":"2.0","id":"0","method":"create_account","params":{"label":""}}' -H 'Content-Type: application/json'

{
  "id": "0",
  "jsonrpc": "2.0",
  "result": {
    "account_index": <insert-account-index>
    "address": "<insert-subaddress>"
  }
}

To create a new subaddress, one has to use the create_address RPC call. Aforementioned code tells us that the inputs are label (optional and as a string) and account_index (as an unsigned integer) and the outputs are address (as a string) and address_index (as an unsigned integer). The JSON RPC call is then utilized as follows:

$ curl -X POST http://127.0.0.1:18082/json_rpc -d '{"jsonrpc":"2.0","id":"0","method":"create_account","params":{"label":"","account_index":<insert-account-index>}}' -H 'Content-Type: application/json'

{
  "id": "0",
  "jsonrpc": "2.0",
  "result": {
    "address": "<insert-subaddress>"
    "address_index": <insert-subaddress_index>
  }
}

  2.) I have installed monerod in Linux and ran into issues when i tried to run with testnet rpc wallet

The root cause of your issues is that you're running release binaries, which can currently not properly sync on testnet, as the testnet seednodes are running master binaries. Thus, to resolve your sync and connection issues, you ought to compile binaries from master and use those. Instructions on compiling Monero from source can be found here. Two more notes:

  Last scheduled hard fork time shows a daemon update is needed now.

This message can be ignored until a new version is out (we're using version 0.11.1.0 at the time of writing).

  2018-03-05 05:25:44.363 [P2P0]  WARN    net.dns src/common/dns_utils.cpp:487    WARNING: no two valid MoneroPulse DNS checkpoint records were received

This warning can also be safely ignored:

What is a "[P2P0]WARNING: no two valid MoneroPulse DNS checkpoint records were received" warning?

What is MoneroPulse?

P.S. More information about subaddresses can be found here:

https://monero.stackexchange.com/questions/tagged/sub-address


There are three options for CPU mining Monero on a pool. Which one is best?

Try them and see? Of the three Wolf's CPU miner is the only open source option; the other two, claymore and yam are closed source and do "fee mining" for the creator, sending a few percent of the hashes to the creator's pool and address of choice. I don't think there's been a really objective comparison of the three, especially across a range of processors. The best way to see would probably be to use each to mine on a largeish pool for a day or three using each of them when difficulty is relatively flat and see which gives the largest payout.

Edit: there is also now the open source xmr-stak miner, which I believe has a default donation to dev that can be disabled.


That means the blockchain had a re-org because 2 blocks were found at almost the same time by 2 different miners. The one with bigger difficulty came later and pushed the other one out.


What is Primo (Private Monero Payments)?

Primo is a protocol and associated suite of software allowing a website to request payment for service by mining Monero to an address owned by the website owner.

Primo enables the following scenario:

Maureen is a webmistress, and she quite frankly doesn't like the way the web is full of advertisements/malware, and decides to get income from her website in another way. Using Primo, she is able to setup part of all of her website to request payment via Monero mining. If the user mines, then her web server will allow access without ads. If not, Maureen has the choice to either deny access, or allow but still display ads.

Ursula the web user is also running Primo, and visits Maureen's website. Primo will automatically spot that this website requires payment, and will tell Ursula about it. Ursula can then either accept or decline.

Technically, Primo is composed of three parts which work in concert:

primo-apache is a module for the Apache web server. Maureen will need to install it on her web server, and configure which parts of her site to require payment for. This module requires access to a Monero daemon which supports pay-for-service (ie, 0.15.0.0 or later). The Monero daemon will keep track of which payment are made, and when to allow or decline service.
primo-firefox is an extension for the Firefox web browser. Ursula will be running this. This extension will automatically detect when Ursula visits a website which is setup with Primo, and display a notification when she does.
primo-control-center is a graphical control center to be run by Ursula. It keeps track of which websites Ursula visited and allows her to control which websites she will allow mining for. primo-control-center coordinates with primo-firefox to list the Primo enabled websites Ursula visits, and is Ursula's all-in-one interface with Primo.

Thus, Primo offers a way for Maureen to get an income stream that does not depend on obnoxious or malware laden ads, and for Ursula to avoid the aggravation of browsing pages with ads.

Primo has a number of advantages for Maureen:
- she does not have to deal with a third party ad broker, which has control over which ads her visitors will be subjected to and may decide to drop her at a whim
- she will get paid in a decentralized currency, avoiding censorship by payment processors

Primo also has advantages for Ursula:
- her personal information is safe: Ursula does not have to supply credit card info to Maureen, preventing credit card fraud
- Ursula stays anonymous: no credit card info means Maureen cannot discriminate against Ursula as long as she supplies payment
- Payment is done as Ursula needs to: there is no payment in advance, unless Ursula chooses to

Primo also has a number of benefits for the Monero network:
- it increases the network hash rate, as more people mine Monero so they can access paid sections of websites
- it increases the Monero network mining decentralization, as each such websites acts like a small independent pool

Note that a disadvantage for Maureen is that her actual income will depend on when her users actually find Monero blocks, so she will get "blocky" payments every once in a while rather than a steady trickle. The larger her user base is, the more this disadvantage will vanish.


Is my monero core wallet seed password compatible when using android monerujo app?

Yes, you can recover a wallet from its mnemonic seed in monerujo. It's detailed in the FAQ in the list of features:

  Recover wallets from mnemonic seed or from keys


How is the used Pedersen commitment kept secret?

A commitment is published publicly for every output created in a transaction, and thus every input in a transaction also has a known commitment.

Commitments are public. It's only the amount and blinding factor that are kept private between the creator of the output (sender) and the output's recipient.

The MLSAG ring signature proves that there is a set of inputs and outputs such that P - Q = zG where zG is the commitment to zero, and only someone that knows all the blinding factors can prove knowledge of z (and the signature proves that without disclosing the value of z publicly).


There are a few things to try in such a situation.

Firstly, remove the argument --block-sync-size=10. The daemon uses a sane default, so this option is not required and could potentially cause issues.

Second, try quitting the daemon, deleting p2pstate.bin, then restarting the daemon. This clears your previously used peers, which may have been the problem.

Third, you can also check the status of your connected peers with the daemon's print_cn command. Look for any particularly slow peers, make a note of their IP addresses, then use the command ban IP. This will ban the peer and a new one will be selected from the peer list.


How to keep Monero daemon from crashing during initial sync?

Monero prior to 0.17.1.9 had a DoS vector where someone could send monerod a massive ~100 MB packet, crafted such that parsing it would take lots of memory (on the order to 30 GB I think, I might be off). I assume this is what you both got, and the OS killed the process due to no RAM available, rather than an actual crash. Update to 0.17.1.9 and if it still happens, then it's another problem which should be reported to https://github.com/monero-project/monero.


Help with monero-integrations/monerophp error

The error you are getting stems from the fact the method you are trying to call (get_connections) is not an available method when running a restricted daemon.


Where is the monero conf file in the portable binaries version?

You must create it yourself manually according to this answer. I believe I remember bitcoin operating the same way.


Monero has no scripting language. Even though the Cryptonote paper describes a simple lightweight one, the code did not implement it at the time Monero forked.


Is Dash based on CryptoNote or CoinJoin?

There are two coins with that name. The first is called Dashcoin (DSH) and is a CryptoNote coin that was launched July 05, 2014 as an automated fork of Bytecoin (BCN) without the large premine.

  Dashcoin is a Next generation anonymous cryptocurrency and the first automatically mutating cryptocurrency created with CryptoNote technology. What does this really means? Our network code is always up to date with minimal developer cost and close to 0% errors. You are no longer depending on developers good will

On March 16th, 2015 DarkCoin (DRK) formerly XCoin (XCO) officially announced its rebranding to Dash (AKA Dashpay), effective May 25th, 2015 becoming the 2nd cryptocurrency to use a dash related name. Dashpay uses a modified version of CoinJoin currently branded DarkSend (soon to be re-branded as PrivateSend).

On March 12th, 2015 Dashpay (XCoin/DarkCoin) founder Evan Duffield wrote:

  Months ago the community organically came up with the name “Dash” as a possible re-branding idea of Darkcoin, I took notice of this and the good deal of support it had in the forums. This lead to us researching the Dash brand for a few months. In the process of doing some investigation, we found that there was another company in the financial space that was filing a trademark. This resulted in me buying another coin “Dashcoin” and challenging their trademark application.

Of course his claim of buying another coin Dashcoinis not accurate because you cannot buy the entirety of a decentralized PoW blockchain, particularly one that is an automated fork (no developer needed) with miners who continue to support it. Dashcoin has a small but viable community today, the coin has been mined since its inception and is traded on a major exchange Poloniex.

In reality, Evan Duffield purchased the password to the GitHub repo and a former Dashcoin website from a Dashcoin "maintainer". Many Dashcoin users persevered and simply set up a new website and code repository after the old dev sold his passwords to Evan. Dashcoin has always used the ticker DSH and continues to do so today. Dashpay changed its ticker from XCO to DRK to DASH which it commonly uses today. However naming confusion was renewed when BTC-e preferring 3 letter tickers listed Dashpay as DSH which is the ticker that Dashcoin has used since its inception in 2014.


This version switched to EasyLogger which uses ANSI escape sequences to set colors on the window. Windows 10 has built-in support for these command codes, but on earlier versions you'll need some other terminal program to render them. For some alternatives: https://superuser.com/questions/413073/windows-console-with-ansi-colors-handling/1050078


What potential security risks are associated with sharing my view key?

A view key can NOT be used to steal your funds.  Think of it as a way of granting someone "Look, but don't touch" access.

It is important to remember that the viewkey allows you to see only incoming transactions, not outgoing, so it cannot grant you what would be considered a "live" view of the address' holdings.

Therefore a viewkey could safely be shared with your accountant or business partner, but they may also be aware that what they see may not necessarily reflect a true count of what the address contains.


How do you setup a node to communicate with other nodes only over an anonymous network?

Pretty much all of this is covered in ANONYMITY_NETWORKS.md.

Node to node communication, i.e. P2P traffic: for this you can use --tx-proxy ... and --add-peer ... / --add-exclusive-node ... with a node on an anonymity network to broadcast transactions only over the anonymity network.

That leaves you with block syncs over clearnet. If you used --add-exclusive-node ... with a node on an anonymous network instead of --add-peer ..., this would prevent any clearnet traffic at all, but with the drawback you would have no block syncing. hence why the relevant section of the document #p2p-commands recommends also adding clearnet peers.

  With all that in mind, the question is how much of this ideal (communicating with other monero nodes exclusively over an anonymity network) is achievable today, with the tech that has already been added to monero.

Not "exclusively". Anonymity networks are a poor candidate for general block syncing due to their bandwidth limitations, which is why the work done so far has focused on tx broadcasting over anonymity networks, not block syncing. Also, hiding ones IP whilst block syncing is clearly less important than hiding ones IP when broadcasting a tx.

  I have read the ANONYMITY_NETWORKS.md document multiple times... But then, it also says that if you do that, you need to manually --add-peer other onion nodes

It doesn't say that though. Quoting the document:

"It is therefore recommended that --add-exclusive-node be combined with additional exclusive IPv4 address(es)."

The point is this, if you try and restrict everything to anonymity networks, you won't be able to sync blocks, which is undesirable. Hence the recommendation is to integrate an anonymous network for tx broadcasting and everything else use clearnet. So use --tx-proxy ... with a tor/i2p node via --add-exclusive-node and add one or more --add-peer clearnet node(s).

  Once you connect to one, it sounds like you will be informed of others that exist and have specified that they permit anonymous inbound connections.

If you add one or more nodes that are on anonymous networks, yes, they will share their peerlists of other anonymous nodes they have connected to.

  Furthermore, I was told that at some point in the future, there will be some seed nodes that serve this purpose of being a reliable thing you connect to in order to discover the other peers that accept anonymous inbound connections, but that this does not currently exist.

This is incorrect. You were told: "The loose plan is for some trusted seed nodes first, to help the less technical users.". A "loose plan" is just that, a loose plan. This is all very much at an experimental stage and requires a certain level of technical expertise. Some known Monero nodes, on anonymous networks, serving as seed nodes for others, is one step that would make the experience easier.

  So, is there a community of monero nodes out there running on an anonymity network, communicating with each other over Tor or i2p? If so, how do you connect into that network without a seed that tells you how to find the others?

Not really no. Those of us that have been developing this stuff of course have ran/run nodes over tor/i2p. The point is this: one can right now run a full node with both tor/i2p and clearnet. One can direct their local node to use their tor/i2p node for tx broadcasting. One can connect their wallet directly to their local node or their tor/i2p node.