What programming language(s) are used in building Bitmonerod, Simplewallet, Kovri, and the Monero GUI?

bitmonerod/simplewallet are written in C++, with some C too. C libraries are used (unbound, lmdb, etc). Some C++ bits are pretty intricate. Wallet code is simpler.

Kovri is C++. I've not looked at the code much to say what level is needed.

The GUI is Qt/QML, and C++. I've not looked at it much, but it's way smaller than core, so easier to get to grips with.

Best way to help out is to look for open issues, or something which you find not working, or not working well enough, or not working as you think it should, and go about fixing that issue. Simple things first, and soon you get the hang of it.

https://github.com/monero-project/bitmonero/issues

https://github.com/monero-project/kovri/issues

https://github.com/mbg033/monero-core/issues


Is there any exchange that offers a Monero/Aeon trading pair?

Currently there are two exchanges that offer direct XMR/AEON conversion each with its own limitations/warnings. The third option would be direct OTC trades (optionally with an escrow agent to reduce risk).

Cryptopia offers the most XMR trading pairs of any exchange including an XMR/AEON pair. Its current limitation is very low trading volume compared to the Poloniex (first exchange that offered Monero trading pairs including XMR/AEON previously).
Changelly operates in a manner similar to Shapeshift but unlike Shapeshift offers Aeon trading and direct XMR/AEON conversion. It receives a large level of distrust within the Monero community due to its connection with Minergate
There is a Bitcointalk thread designed to connect buyers and sellers hoping to arrange OTC trades. IRC trading at #monero-otc is another option
LocalMonero also provides an OTC platform for XMR/AEON trades.

The centralized exchange with the most Aeon volume is Bittrex. It was not mentioned in my answer above because they do not offer a XMR/AEON trading pair. Bittrex does offer both a BTC/XMR trading pair and a BTC/AEON trading pair.


Miner is waiting a long time for new jobs

after submitting a share the miner does not always get a new job instantly

The pool will not send you a new job for each share you submit. You keep working on the same job until the pool sends you a new one.


How long will Monero mining remain profitable?

If the profitability of Monero goes down, less people will mine, meaning the profitability will go back up until it reaches an equilibrium. Ignoring hardware improvements, your profit after paying for electricity will be roughly the same now as it would be in a year.


After Kovri arrives will some full nodes need to remain on clearnet?

There will be three modes:

I2P only: all traffic goes through I2P
Clearnet only: all traffic goes through clearnet
I2P/clearnet bridged: blocks go through clearnet, transactions go through I2P

Since everyone will not be able to use I2P, it will be necessary that some nodes run in mixed mode to avoid the network partitioning. Since the blocks aren't secret, they're a good match for clearnet (faster, which helps miners avoid orphans). Transactions benefit more from privacy, since you can't tell where a transaction originates (which would give a large network adversary a fairly good clue to which node(s) could have created it).


Comparison of Monero and Bitcoin Money Supply and Block Reward schedules

Amichateur made a very informative post on Reddit with graphs making this comparison and an explanation of how FreeMat was used to calculate the data.

  9.4 min Bitcoin block time (de-facto avg. time since inception)
  For comparability, Monero block reward shown relates to 9.4 minutes intervals.
  The vertical line indicates the start of Monero's tail emission end of May 2022 (rate of 0.3 XMR each 1 minute).

  9.4 min Bitoin Block Time - Zoomed in
  Monero's block reward falls below Bitcoin's block reward for ca. 9 years from beginning of 2019 till end of 2027. For all other times, Monero's block reward is always higher than Bitcoin's block reward.

  10 min Bitcoin block time (but actual Bitcoin block time is more like 9.4 min)
  For comparability, Monero block reward shown relates to 10 minutes intervals.
  The vertical line indicates the start of Monero's tail emission end of May 2022 (rate of 0.3 XMR each 1 minute).

  10 min Bitoin Block Time - Zoomed in
  Monero's block reward falls below Bitcoin's block reward for almost one decade between mid 2019 and end of 2028. For all other times, Monero's block reward is higher than Bitcoin's block reward.


There are two operations at the operating system level that can be perform to improve performance in some cases but require the software to be run as superuser (root).
This is mostly useful for a user who want to mine while using their computer intensively for other tasks (see comments by Gilles and hyc below).

Setting niceness

Niceness on Unix systems is a level of priority for a task relatively to others. It is enforced by the kernel.
If priority is the same as other tasks, the access to the CPU is not optimal.

Niceness is set to 6 instead of the default 20 (the lower the niceness is, the higher the priority is)

Locking memory

If the system does not have enough RAM, part of it might be moved to the swap space when not used and then moved again to RAM when needed. This cause CPU time to be spoiled.
The system call [mlock][3] allows to lock a variable in RAM.
Variable persistentctx (of type cryptonight_ctx) contains the context of Cryptonight algorithm and is protected.

Is it safe ?

You must be careful when running a software as root on your computer. There is however no risk here is you've download the mining software from the official repository.

Note that these optimizations are not in lucasjones original software but have been added by wolf9466 (however it tried to change niceness regardless of user but was not advising to run as root).


How does XMR compare to ZCash in terms of transaction fees, mining, coin supply?

Do Monero and ZCash have different transaction fees?

This is largely going to depend on the price, which is currently unknown because Zcash hasn't launched yet. However, on testnet the fee seems to be approximately 0.00005 TAZ (Zcash tesnet coins) per kB, whereas Monero currnetly has a fee of 0.002 XMR per kB.

A more interesting comparison is transaction sizes. The average transaction size for Monero is currently approximately 1 to 3 kB. By contrast, the anonymous Zcash transactions seem to be approximately 2 kB, according to one of their engineers, namely Sean Bowe.

  Do Monero and ZCash have different mining algorithms?

Yes. Monero uses CryptoNight as PoW algorithm, whereas Zcash uses Equihash as PoW algorithm. Both are aiming for ASIC resistance. However, one could argue that the CryptoNight algorithm is more vetted, because it has already been used in Monero for over two years. The Equihash algorithm, however, was until Zcash's implementation purely theoretical.

  Do Monero and ZCash have different coin supply curves?

Yes. Zcash uses the same supply curve of Bitcoin, whereas Monero uses a faster supply curve. A comparison between both emission curves can be seen here.

There are two things to note. First, in Zcash 20% of the mining rewards will go to the Zcash Electric Coin Company, which is a US based company, in the first four years. This company subsequently distributes the so-called "Founders Reward" to its shareholders. These shareholders are founders, scientists, engineers, advisers, outside council, and investors. They can be seen here. In addition, the "Founders Reward" is depicted here. Secondly, in contrast with Monero, Zcash doesn't have a tail emission, which may lead to disincentivized miners in the future.


Can't transfer Monero coins, strange error message (Error: not enough outputs for specified ring size = 5:)

This error message:

Error: not enough outputs for specified ring size = 5:

Is saying there aren't enough outputs of the matching denomination on the blockchain to make a ring signature of size 5, which means your ouput and 4 others. You have at least one output of a denomination that's rare.

To spend these, use the sweep_unmixable command. This will gather those outputs without enough "siblings" on the chain and spend them at ring size 1. Once that's done, you can sweep_all again at ring size 5.

This is mostly a legacy thing, since the currently used ringct encrypts amounts so you don't need matching denominations anymore, but for older, pre-ringct outputs, this can still happen, as it does here.


How do I create a Monero testnet wallet address and account?

You could do something like this (Linux shell):

export NETTYPE=testnet
export WALLET=my-${NETTYPE}-wallet

monerod --detach --${NETTYPE}

monero-wallet-cli --${NETTYPE} \
    --use-english-language-names \
    --generate-new-wallet ${WALLET} \
    --create-address-file \
    --password 'secretpassword'

Your public address will be in a file my-testnet-wallet.address.txt

Don't forget to copy your mnemonic seed words to a safe place


Transaction not showing in my wallet, it's been two days. Failed to connect to seed peers error

You need two things:

a synced daemon ("status" in monerod should show 100%; using a remote daemon should normally be fine)
a refreshed wallet (it'll scan the blockchain monerod downloaded/verified in order to check whether any changes in your account occured)

The seed connection error is only fatal on the first connection. If it manages to connect once to a seed, it'll learn of other peers on the Monero network, and then be able to connect to them. If this is your first connection, then a seed is needed to bootstrap. Check you have internet connectivity on the VM/machine running monerod, and check port 18080 is usable (sometimes firewalls block ports which aren't known to be needed default).


The seed is a way to encode a bitstring using words that will hopefully be easier to remember.

In this case, the seed is composed of a number of words picked from a 1626 entries list. Each triplet of words can then represent a value between 0 and 4298942375, which is a bit above 2^32. So every 32 bit part of the seed can map to a word triplet, and back to the original value. Instead of remembering a 32 bit number, you remember three words. The monero seed is 25 words: 24 words for the seed (256 bits) and one word as a simple checksum. The name "Electrum" comes from the fact that Monero used Electrum's system.

I can't say anything about the difference with other types of seeds. I'm guessing there's a very large number of variants.


What are the risks/benefits of mining on a pool using SSL/TLS encryption vs mining on pools with non-encrypted connections?

It's less about the security of the data moving across the connection than about the authentication of the remote server. When you have the TLS fingerprint for the pool server set up in your miner configuration, such as with XMR-STAK, then you can be assured that the pool is the same one as last time you connected, and nobody has hijacked the domain name or some such in order to steal your hashrate.


Monero OpenAlias vs Boolberry blockchain aliasing system

BBR aliasing system has many problems, being linked to your address what happens if you lose your private key? There is no way to recover your alias that you could have shared with your friends and family, there is also another problem with the variants, you will run out of simple aliases at some point and it will starting becoming confusing (Alice1, Alice2, Alice3, therealAlice...) at some point its simpler to have a personal address book with Alice's BBR address next to her name. OpenAlias does not requires mining, its a simple system that requires only a few extra settings in your Domain Name Registrar and you could use any cryptocurrency with it even Boolberry. You could maintain any domain and add/remove a Monero address associated with it at any time, all the person sending Monero to you need is the domain name. It already works within the simplewallet through the transfer command.


Probably a corrupted file.
Make sure your daemon is synced 100% and create a new wallet, using your mnemonic seed.

Maybe, create the new wallet files in another location than the original.

monero-wallet-cli --restore-from-seed --generate-new-wallet new-filename \
    --electrum-seed "your seed words..." \
    --mnemonic-language English \
    --password "some optional new password"


Can a remote node know my wallet address?

No.
The only leaked data is your IP to the first node as you connect to it. This can however be prevented by the use of VPNs or Kovri once available.


Offline transaction signing. What are the details?

On the internet-facing computer:

You can have a hot wallet (or many) in addition to your cold signing wallet. You will need to have a watch only wallet matching the cold wallet (ie, same keys, the view wallet just didn't get told about the spend private key).
The "cold transaction-signing wallet" is not on the internet facing computer. The view wallet is. The difference between the two is the lack of a spend private key in the view wallet. There is no difference between a view wallet with a corresponding signing wallet and a view wallet without one. The view wallet does not know whether it will ever receive signed transasctions to relay.
The hot wallet does not know to know per se. If you try to transfer from a view wallet, it will save the file for cold signing, since it cannot sign itself. You can either create it with monero-wallet-cli --generate-from-view-key (you will be prompted for data, which you can obtain from the full wallet via commands such as spendkey, viewkey, seed), or use save_watch_only in the main wallet, which will save a keys file withouth the private spend key, which you can then copy to your internet facing computer and name appropriately.

On the air-gapped (not internet-facing) computer:

The cold wallet does not need to have a blockchain. It will get the necessary data in the file the view wallet generates.
n/a, due to the previous point.

See How do I use cold transaction signing? for the list of steps involved in signing a transaction on the cold wallet.


Monero RPC send transaction from address

Each account in a wallet has a number, and each subaddress in an account has a number.

You can add the account_index and subaddr_indices options when calling the transfer method to indicate from which subaddress (or subaddresses) the coins will be taken.

For example to use subaddress n°3 in account n°2 as source of the coins:

{"jsonrpc":"2.0",
 "id":"0",
 "method":"transfer",
 "params":{"account_index":2,
           "subaddr_indices":[3],
           "destinations":[{"amount":100000000, "address":"9wNgSYy2F9qPZu7KBjvsFgZLTKE2TZgEpNFbGka9gA5zPmAXS35QzzYaLKJRkYTnzgArGNX7TvSqZC87tBLwtaC5RQgJ8rm"}],
           "get_tx_key":true}}

The documentation of the transfer method is here.


Normally, just running a full node (i.e. a node that contains a full copy of the blockchain) just entails keeping your copy of the blockchain up-to-date, and also relaying new transactions. These transactions are then included in the blockchain by the process of adding a new block to it, know as mining. However, to get the privilege of editing the blockchain by augmenting it by this new block (which will include the new transactions), the user's software has to perform intense computations in the hopes of beating the other nodes to solving a puzzle. If he does, then he gets the block reward, which is currently around 10 XMR per block.

So you can think of mining as a race to win a lottery that has a prize of about 70 USD every 2 minutes, and the odds of winning this lottery will depend on the hardware and energy the user decides to invest into it.

Mining is optional, and there isn't a reward for just relaying transactions or keeping an up-to-date copy of the blockchain; not in Monero at least.


There is a problem with the seed nodes at the moment.
This is fixed in the coming release, hopefully in the next day or two: https://github.com/monero-project/monero/pull/1879

In the meantime, you can supply a node to start from:
./monerod --add-peer 107.152.130.98:18080 --add-peer 212.83.175.67:18080 --add-peer 5.9.100.248:18080
(this is simply adding the first three fallback peers to the command line)


How does one prove that a user has locked Monero for X blocks?

You can prove a) that a tx has locked coins by providing the tx hash of the tx which has the locked funds and b) prove you created the tx.

To prove a tx has locked funds, simply give the user the txid so they can inspect it on the blockchain (using either their own local daemon or a blockchain explorer). E.g.

$ monerod print_tx 6cd029...bf8c34 +json
Found in blockchain at height 1991755 (pruned)
{
  "version": 2,
  "unlock_time": 1991815,
  ...
}

Which shows that this tx is locked until block 1991815.

To prove you sent the tx, use the wallet command get_spend_proof:

[wallet]: get_spend_proof 6cd029...bf8c34
signature file saved to: monero_spend_proof

Then send the resulting file and txid to the user so they can verify with the wallet command check_spend_proof:

[wallet]: check_spend_proof 6cd029...bf8c34 monero_spend_proof
Good signature


This issue was fixed in a minor point release 0.10.3.1:

  The 0.10.3.1 point release disables a portion of the server-side hash
  cache that was preventing a small subset of nodes from syncing.

https://github.com/monero-project/monero/releases/tag/v0.10.3.1


Yes, tx-extra can be of any length, as long as the transaction as a whole is not too large to be accepted into a block.

Only the parts of tx-extra that need to be encrypted are encrypted. For example, the transaction public key does not need to be encrypted, so that's just directly in tx-extra. But (the newer style) payment ids do need to be encrypted, so they are encrypted with the transaction shared secret that only the sender and recipient will know, before being put into tx-extra.

If you want to create your own tx-extra subfield and put sensitive information into it, then you'll have to decide for yourself how to encrypt it. If it's a bunch of text, then you'll need some kind of stream cipher. Perhaps use TweetNacl https://tweetnacl.js.org/ to encrypt what you need to store.


Buying Monero Privately in Toronto Canada

Popular places to buy without KYC are Bisq and LocalMonero.


Why does md5sum of .keys file change with each restore from mnemonic seed?

The encryption used by the keys file is randomized. It uses a key derived from your password, and an IV (initialization vector) which is randomly selected. This is designed to prevent an adversary from determining which parts of the file are the same, and which are different, if you encrypt two files (or two versions of the same file) with the same password. So even if the contents of the file were 100% the same, you would still get a completely different (well, ideally, 50% different) file.


Terminology clarification: stealth address

If we look how the term "stealth address" is used outside of Monero, for example in bitcoin ecosystem:

  The concept was invented Peter Todd based on earlier work by ByteCoin,
  and with feedback from other developers.
  It’s a powerful tool for allowing one to accept Bitcoins using a
  public Bitcoin address while preventing passive observers from knowing
  your transaction history.

or:

  Stealth address means that for an external observer of the blockchain
  is not possible to identify what payments were made to you, because
  your address is not recorded in blockchain.

So in my opinion, correct is stealth address = "Monero standard address" ie your point 1. I would also say it is OK to use the term to describing the overall process.

Sources:

https://www.codeproject.com/articles/775226/nbitcoin-cryptography-part
(This is actually very good explanation of the principles how stealth address works. It uses different terminology than is used in Monero e.g. "ephemeral key" but principles are same)
http://sx.dyne.org/stealth.html
https://bitcoin.stackexchange.com/questions/20701/what-is-a-stealth-address


Use official binaries or compile master myself?

To answer part of your question, the Monero devs recommend that you stick to tagged releases. So compiling from the head master branch is never recommended unless you are testing or really know what you are doing.

However, you've missed a third option that really is the best of both worlds when it comes to being both paranoid and wanting stability. Namely: compile from source from the latest tagged release.

Doing so is as simple as compiling from the head master, with one extra step. After you get the source and change to that directory

$ git clone https://github.com/monero-project/bitmonero

$ cd bitmonero

you can choose to switch to a tagged release

$ git checkout tags/<tag_name>

For example, if you wanted to switch to v0.9.4, you would do

$ git checkout tags/v0.9.4

If you aren't sure the latest tagged release, you can view all releases with

$ git tag -l

For more information about checking out tagged releases, check here: https://stackoverflow.com/questions/791959/download-a-specific-tag-with-git


How to get an external wallet to work on monero-wallet-cli?

If you've imported it by running the monero-wallet-cli --restore-deterministic-wallet, it should be ok. To check, just type in the address command while your wallet is running and compare the address vs. the one you used. If they match (and there's no reason they wouldn't) you will be able to see your balance after refreshing the wallet and spend your Monero.

However, note that for the correct balance to show, your wallet needs to search the entire* blockchain for Monero belonging to you. The command to do it (if not done automatically) is refresh. This is because Monero is private and you can't just look up the balance of an address like people are used to doing with Bitcoin, because your address never actually appears on the blockchain.

*To make syncing the wallet faster, and if running version 0.10 of the sofware, you can start the CLI wallet with --restore-deterministic-wallet --restore-height <h> arguments, where <h> is the block height from which it will start the refresh.

You can follow these steps:

Start the Monero daemon and keep it running. This is your node which needs to be synced with the network before you can make any transactions. You could connect to a remote one to avoid this if you need to, but then refreshing will be slower and it is less private.
Find out the block height from when you created your wallet. You can do this by filtering the blocks by date on a block explorer, and writing down the block height of a day before you created the wallet or received your first Monero to it.
Start the CLI wallet with --restore-deterministic-wallet --restore-height <h> arguments, where <h> is the block height from which it will start the refresh. Note that if you specify a block height which is after you first received Monero, you will not see those because the wallet will not be aware of them.
If your daemon is running, the wallet should start to refresh automatically (to make it refresh manually, just type in the refresh command), and shortly after, you will see your transaction appear and the wallet will show the correct balance. From there, you can use the transfer command to send your Monero.


Is there a way to import the extra info of outgoing transactions to a restored wallet?

I think you know the answer to that one, since you say "because they are neither stored in the blockchain nor computable from blockchain data, but only kept locally in the wallet cache".

The answer is: make backups.

Backups can be stored on inexpensive write once media, and both encrypted and signed.

Of course, make sure your only copy of the keys isn't on the backed up data :)

As for an external export/import of this, there is none. This would need to be encrypted also, since it's private data. And if the cache gets corrupted or erased, then why not the exported file ? True, it's a brittle format, due to different boost versions used in binaries, but this will be solved in the near/medium future (and there are workarounds, see https://github.com/monero-project/monero/issues/1106).


Does the CONOP definition exclude pruning branches from its node definition?

By definition pruning branches cannot be considered full nodes because they are missing the data that has been pruned. Pruning branches are not full nodes according to the definition of CONOP.

This explanation explains why full nodes (in addition to pruning branches) are necessary.

  Pruning data makes a node unable to supply the pruned data to other syncing nodes. That data is necessary to fully validate the blockchain in a trustless manner, so while a client may decide to trust a pruned node, there should be at least a few "full data" nodes on the network, keeping the entirety of the blockchain, in order to keep the ability to re-verify the whole thing from scratch.


How to configure two daemons to use the same database?

With 0.11 (and possibly 0.10.3.1, though I'm not 100% certain this was ready then), there is no particular precautions to take in order to share a database between two daemons. Pointing the daemons to the same directory using --data-dir should be safe. I'm not sure this has been tested a lot, however, so if anything like corruption should happen, please report it to https://github.com/monero-project/issues.


Is it possible to attach a message to monero transactions?

Current software supports embedding arbitrary 256-bits or 64-bits into a TX. The 256-bit "payment ID" will be unencrypted on the blockchain (unless you encrypt before submitting). The 64-bit "payment ID" will be encrypted with the "shared secret" before bein written into the TX. This can easily be decoded by the recipient as it uses a scheme similar to how outputs are made (ECDH).

Since it allows any "hex" string of 64 or 16 chars, you could use this functionality today.

As TX-extra field is not subject to consensus rules (it's fundamentally a message field - it can be anything), you could make your own wallet implementation to put whatever you want in there. It would, however, be restricted by the max TX size and the receiving wallet would need to be able to recognize it as well.


Using the monero cli or gui, how do you sweep all the coins from a private key into your own address?

If you have a paper wallet which you received funds to, you don't need to sweep the funds to use them (sweeping means sending all funds to some address), you just need to restore the wallet.

A paper wallet may be a 25-words electrum-style seed (supported by the official wallet), or it can be the two private keys (spend+view).

Restore wallet using the CLI

Restoring from a 25 words seed:

monero-wallet-cli --restore-deterministic-wallet --electrum-seed <your_seed>

Restoring from private keys:

monero-wallet-cli --generate-from-keys <wallet_name>

Then you will be asked to enter your address and both private keys.

Restore wallet using the GUI

Restoring with the GUI is very straightforward. Open the GUI, choose your language, and then choose the option 'Restore wallet from keys or mnemonic seed' (something like that, depends on your language). Then choose between seed/keys and fill the necessary fields.

___

  Then a few weeks pass, this account has coins again. Do I do the same
  process again?

If you just plan on receiving funds to your wallet, without using them, you shouldn't do anything. Receiving funds does not require any action from your side. You should restore your wallet only when you want to spend your funds.


What does "Can't create transaction: internal error: Known ring does not include the spent output..." mean?

This isn't an excellent answer, but for now, you can get around this by deleting the .shared-ringdb folder.

For Windows, this located in C:\ProgramData\.shared-ringdb

For Mac OS X and Linux, this is located in ~/.shared-ringdb

Note that ~ is typically short for home/<user-name>

Restart the GUI, and you should be able to send a transaction.


Monero with Trezor - does the seed phrase provide enough bits of security?

A Monero private key is any 256 bit number mod l and the seed phrase is deterministically derived from this private key. 24 words (the 25th is a checksum), from the dictionary in Monero, gives enough bits (257) to encode/decode from the 253 bit random private key.

As noted, the Trezor Model T uses a 12 word phrase with a dictionary which is only good enough for 128 bits (plus a checksum). This essentially limits the possible range of private keys.

Longer bit ranges are of course more desirable.

It's worth pointing out that both Trezor devices can be initialized with longer phrases [source]:

  Note For advanced users: It is possible to generate 12, 18 or 24-word
  seeds on both Trezor devices. If you want to generate recovery seed
  with different length than default (e.g., 24 words on Trezor Model T),
  please see initialize device with trezorctl command.

Generating 24 words will give enough range to cover all possible Monero private keys.


What would the space saving difference be if MLSAG was applied over all inputs?

I'll restate your question for clarity:

Currently, it's the case that for transactions with multiple real inputs, multiple RCTTypeSimple MLSAG signatures are used. This is to prevent the leakage of the position of one real input in the ring from leaking the ring position of other real inputs (because they'd all be at the same ring index).

In an m real-input transaction with a ring size of n, what would the space saving be if a single RCTTypeFull MLSAG signature was used to sign the transaction instead of multiple RCTTypeSimple MLSAG signatures? The Zero to Monero paper says:

  Our perception is that the decision to limit RCTTypeFull transactions
  to one input was rather hastily taken, and that it might change in the
  future, perhaps if the algorithm to select additional mix-in outputs
  is improved and ring sizes are increased. Also, Shen Noether’s
  original description in [61] did not envision constraints of this
  type. At any rate, it is not a hard constraint. An alternative wallet
  might choose to sign transactions using either scheme, independently
  of the number of inputs involved. We have therefore chosen to describe
  the scheme as if it were meant for multi-input transactions.

The space requirement for an RCTTypeFull MLSAG signature is:
 32*(n*(m+1)+m+1) bytes of storage for the signature including key images (no pseudo outs are required).

The space requirement for multiple RCTTypeSimple MLSAG signatures is:
32*m*(2*n+3) bytes of storage for the signatures including key images and RCTTypeSimple-only pseudo out commitments.

Therefore, for the examples you gave, for mixin 7 (ring size 8):

1 input: RCTTypeFull = 576 bytes, RCTTypeSimple = 608 bytes. Saving = 32 bytes.

2 inputs: RCTTypeFull = 864 bytes, RCTTypeSimple = 1216 bytes. Saving = 352 bytes.

The savings at our current ring size of 11 are:

1 input: RCTTypeFull = 768 bytes, RCTTypeSimple = 800 bytes. Saving = 32 bytes.

2 inputs: RCTTypeFull = 1152 bytes, RCTTypeSimple = 1600 bytes. Saving = 448 bytes.


How to send monero from my cold storage?

The currently easiest way is to restore your seed using the CLI wallet, spend what you want to spend and immediately send the remainder to a newly created cold storage. See here for some more considerations.

To make syncing the wallet faster, you can start the CLI wallet with --restore-deterministic-wallet --restore-height <h> arguments, where <h> is the block height from which it will start the refresh. If you know the approx date when you sent the first funds to it, use a block explorer to find the No. of block that was a bit before the time you sent the funds and use that number as the starting height. While this will speed up the initial sync significantly, be absolutely sure you use a block height from before your funds came, otherwise you won't see them in that wallet.

PS easier methods are soon to be avaliable. The Trezor firmware is in testing phase, and the new point release will provide option for offline signing, meaning you'll be able to spend from cold storage without ever exposing it to an online computer.


How do I export my transaction history from wallet CLI in a usable format (.txt, .csv, etc.)?

You can do this:

monero-wallet-cli --command "show_transfers" --wallet-file=/path/to/wallet --password 'password' >> my_txns.txt

The output is not CSV though.

Here is a bit of commandline hacking to make into CSV:

monero-wallet-cli --command "show_transfers" --wallet-file=/path/to/wallet --password 'password' | egrep '^ '| sed 's/^ //g'| sed 's/ \+/,/g' >> my_txns.csv

(only tested with a watch-only wallet)


How to change the total coin supply in monero?

This does not control the money supply, contrary to what you might expect. If you want to cap it, you need to change get_block_reward (in src/cryptonote_basic/cryptonote_basic_impl.cpp) and stop emission when your chosen amount of coins is reached.


Monero wallet's daemon monerod initially and when all recent peers are offline tries to connect to one of the hard coded seed nodes, currently these are:

seeds.moneroseeds.se
seeds.moneroseeds.ae.org
seeds.moneroseeds.ch
seeds.moneroseeds.li

If it peers with enough regular network nodes, these nodes are not used any more unless all known peers are offline.


Sending Monero to multiple integrated addresses

When you send funds to an integrated address, what you're actually doing is sending funds to the recipient's underlying Monero wallet address and simultaneously attaching an encrypted payment ID to the transaction.

According to the current specification, there can only be one payment ID specified in the tx_extra field. Because of this, only one integrated address can be sent to per transaction.

Unless you can convince the developers of Monero wallets to allow a new tx_extra format that allows multiple encrypted payment IDs to be specified, you're going to have to find a different way of achieving the result you're looking for.

One solution is to "dice up" your outputs ahead of time. If you have one large output of value 100 XMR, then when you spend 1 XMR you'll have to wait for 10 confirmations before your 99 XMR change is available to be spent in a subsequent transaction. But if you do:

transfer your_wallet_address 20 your_wallet_address 20 your_wallet_address 20 your_wallet_address 20

Then you'll end up with 4 outputs for 20 XMR in your wallet and 1 change output of slightly less than 20 XMR in your wallet (because of the transaction fee).

Therefore you'll be able to send several transactions in a row, each to a different integrated address, and you won't have to wait because you'll be spending from your unlocked balance in future transactions instead of from your locked change balance.


Why does the num_unspent_outputs decrease to 1 in Monero wallet?

The monero wallet will try to use two inputs to each transaction, in an attempt to have most transactions look like each other (two inputs, and two outputs). Since in a typical transaction you will get one output back as change, it means that you spend two outputs, and get one in return (the second output going to whoever you're paying). Thus, over time, you will coalesce your own outputs, which leads to the problem you're describing.

There are two settings in monero-wallet-cli which can control this and avoid coalescing outputs down to too few: min-outputs-count and min-outputs-value. They're viewable and settable using the set command: just running set will show all settings, including those.

Those settings control when a second output will be added onto your transactions when it is not necessary (ie, when it's just in an attempt to make your transaction look like a typical 2 -> 2 transaction). monero-wallet-cli will only include such an output if it wouldn't cause the wallet to have less than min-outputs-count outputs of value at least min-outputs-value monero. Of course, if using two or more of your outputs if necessary to meet the payment+fee amount, this will be done regardless.

For example, you can run:

set min-outputs-count 5
set min-outputs-value 1

This will cause monero-wallet-cli to try to use only one input for a transaction once you have only 5 outputs left over 1 monero.


Why does the Bulletproof prover always have T1 = rct::scalarmultKey(T1, INV_EIGHT)?

For security reasons, input points should be multiples of 8. While there is no known exploit if they're not in this case, having them be multiples of 8 means we can rule those out in the first place. The obvious way to ensure this is to check whether input points are multiples of 8 in the verification code. However, this is slow. Multiplying a point by 8 turns out to be much faster, so the prover will multiply its final points by 1/8, then the verifier will multiply by 8, thereby restoring the original points.
This allows the verifier to ensure its input points are all multiples of 8 while still being fast.


Quite honestly, mining on a Raspberry Pi is never going to give a good hashrate. The processor just doesn't have enough cache (you need 2MB cache per thread/core) for optimal hashing. You can't even add a graphics card (as there's no PCIe slot).


How to send funds with a watch-only and cold wallet set up?

This SE post asks questions about cold transaction signing that may or may not lead you to your answer.  That post links to another SE post, which describes the process of cold transaction signing.

It appears you may already know much/all of the information from those two posts, so maybe you're just using not the most recent version of monerod.  Did you download prebuilt binaries, or did you build yourself?  If you didn't build yourself, you may need to.  If you did build yourself, you may need to update, which can be found in this SE post.


Please help noob to start monero wallet recording deposit or withdrawal events

To monitor a wallets activity you can make use of the monero-wallet-rpc program which exposes a JSON RPC interface. Once you have this running, you'll want to call the get_transfers method as documented here.

Currently there is no notification system so you will simply need to poll requests to this at a frequency that meets your requirements and check for changes since you last called the method.


Download Link Monero 0.11.0 (Helium Hydra) broken

The GUI links on the download page were temporarily broken on purpose as the prior Beta 2 GUI was about to be updated in advance of the v6 fork. The Helium Hydra command line release became available before the graphical user interface. As of the time of this edit, the GUI links on the download page are now available too.

The now outdated GUI Beta 2 release files are still available here just like other archived links to prior major releases.


When generating a random payment id, why doesn't the integrated address also change in the receive tab in the gui wallet?

The address looks like its not changing because the first part of the address is the same for all integrated addresses. Its only the last part of the address shows the unique payment id add on.


How to install/use MoneroPHP on my site?

The README details how to use the library (which is itself well documented).

What is the first step to installing this on my site?

The first step is to install and run the Monero daemon and wallet RPC applications.
Note, you really don't need to use the library; it largely just wraps the daemon and wallet JSON RPC interfaces. So if you are comfortable making web requests directly in PHP, no wrapper library is needed.


Is the upcoming release of the Monero GUI v0.14.2.0 or v0.15.0?

At the time of writing, the current release is GUI v0.14.1.0, which can be found here:
https://www.reddit.com/r/Monero/comments/c8eg6k/gui_v01410_boron_butterfly_with_ledger_nano_x_and/
The next release, which is expected to be out soon, is GUI v0.14.1.1. Thereafter, the next release will be GUI v0.15.0.0.

I downloaded v0.14.1.0 and the zip only has a subset of the files/folders that v0.14.0.0 has.

That is expected. The total amount of files was reduced to improve user experience. Put differently, monero-wallet-gui.exe was compiled statically such that the other files did not have to be present in the folder anymore.

Do I copy/paste these files/folders into a folder containing the v0.14.0.0?

No, simply extract the GUI v0.14.1.0 .zip file to a new and separate directory / folder.

Is there a release notes file for this release?

Yes:

Release notes

White theme
Addressbook redesign
History redesign
A check update feature that notifies the user (in the GUI) of a new release
Trezor Model T and Ledger Nano X support
Blockchain pruning
Fiat price conversion
macOS fullscreen support
Various UI/UX improvments
Bug fixes and major performance improvements


Recently there was a post on Reddit asking almost the same question which generated quite some additional discussion (although without much positive outlook). Here's a comment by me giving an answer to the original question:

I asked moneromooo about this on IRC, and he said that what's mentioned by u/fluffyponyza in the presentation probably refers to an idea that was discussed on IRC a very long time ago and implemented in moneromooo's viewkey-R branch. The basic idea seems to be to generate the tx pubkey somehow deterministically with some nonce such that a view-only wallet (i.e. an auditor) can recognize outgoing transfers. This approach is however quite problematic and unreliable as the wallet owner needs to follow a specific procedure when creating a tx so that the auditor can see outgoing transfers; i.e. there needs to be trust between the two parties for the scheme to work. As such, the development was abandoned.
Here's the log of IRC on 2017-April-10: https://paste.fedoraproject.org/paste/hnmDKpT5U~kJyCHi0NP4BV5M1UNdIGYhyRLivL9gydE=


Use bip39 mnemonic to generate monero keys

There is an option called --generate-from-spend-key in the monero-wallet-cli program to generate a wallet from a private spend key.

To avoid having to rely on tools via web sites which may not be around in the future, you can use the following Linux/MacOS command to generate a Monero private spend key from your BIP39 Mnemonic:

echo "ibase=16;obase=10;"`read line && echo $line | shasum -a 256 \
| tr '[:lower:]' '[:upper:]' | awk {'print $1'}`" % \
1000000000000000000000000000000014DEF9DEA2F79CD65812631A5CF5D3ED" | bc

What this does is take your BIP39 mnemonic (or other suitable key with sufficient entropy), and produce a SHA-256 hash from it (SHA-256 hashes are suitably uniformly distributed). Monero private keys must be lower than 2^252+27742317777372353535851937790883648493 (which is 1000000000000000000000000000000014DEF9DEA2F79CD65812631A5CF5D3ED in hex), and so the command reduces it accordingly. This is equivalent to the Monero sc_reduce32() function.

Beware that input to this command is case sensitive, in order to allow it to be used with any kind of source input.


It's rather long. Skip to end if you want only to see some good practice :)

Also, to clarify one important thing first - anonimity and privacy are different things. If you're buying from exchange A, obviously the exchange knows your ID and that you're buying Monero so you're not anonymous. However, exchange can't tell what you're doing with the monero, so you keep your privacy and can later do anonymous shopping. Privacy is what enables you to be entirely anonymous, if you want.

Brief Overview of Monero Transactions

This is just for better understanding how transactions work. Imagine that every transaction creates brand-new one-time-use "pot" from which the owner can draw only once. Before you draw, you arrange yours together with some number of others' random pots (belonging to other, unknown wallets) and announce you're about to take from one of them. You approach each one and put your hand inside. At the end, you show your hand, and it contains a certificate (ring signature) saying you own something from one of the pots, and a key image saying you didn't draw from that pot before. All this without revealing which one of the displayed pots is yours. The network verifies that you have rights to take from 1 of them (but not which) - that's the ring signature.

Then, you make some brand-new ones, and distribute the value of your old one into them, usually 1 for the destination and 1 for the change back to yourself. You use invisible paint to mark some secret code on the pots. The recipe for the paint is given to you by the recipient, encoded into his address. Only the recipient has the special lens (view key) letting him find the pot. Without this, it is just some random pot. You gotta have the lens to be able to find it. For anyone else, it's an ordinary-looking pot, nothing special about it, no markings whatsoever. With the lens, he sees the secret marking, and that combined with his spend key lets him produce the certificate and draw from that pot when he's ready to spend.

I will not go into details how the amounts are hidden, but just accept it as fact that the secret marking tells you the amount as well and everyone else is able to verify you didn't cheat even though they can't see the amount.

So, only the sender and recipient know the amount and the secret code written to the pot. Sender knows because he's the one who wrote it (he could forget it forever, though) and the recipient knows because he can always look at all the pots with his special lens and see which ones light up as his (wallet scanning).

So, a wallet is just a collection of pots (one-time keys) from which you can spend exactly once. They all look like any other, but only the receiving wallet is able to identify which ones it has the rights to draw from. Only the spending wallet is able to identify which ones were used. The network would be able to tell if you try to use the same one again, but until you actually try. If it appears in a transaction, it will remain unknown if it was actually used, or it was someone else just putting your pot for display when spending from his.

Sending Directly from Exchange A to Exchange B

If you send directly from exchange A, then it's not you sending but the exchange. You only make the request via your browser. That means the exchange A is the actual sender (and not you) and knows both the amount and destination address, since you type it into exchange A interface.

If exchange B address is publicly known (and it usually is*) then A knows you want it to send to some exchange B. It can't tell whether it's to your own acconunt, or someone else's, unless it asks exhcange B "Hey, who's the user with payment ID XY?". Payment ID's are normally encrypted over "the wire", but since you practically gave it away to exchange A when using it's web interface, exhange A could tell if you repeatedly ask it to send to the same account at exchange B.

*even if B is using integrated addresses for deposits, it doesn't hide the underlying address, that's not the purpose of those.

The takeaway is: don't send directly from exchange to exchange.

Using Your Own Wallet Between Exchange A and Exchange B

You ask exchange A to send to your wallet and it does. Exchange A can't tell whether it's your wallet or not if the info is not publicly available. It just makes the "pot" with the paint (address) according to instruction. Since it made the TX, it knows what's written with the paint, even though it's with invisible paint.

Ok, but now you send to B. Firs, you have to source the funds. You arrange the pots for display, including the one A gave you. A is watching, and sees someone arranged 5 pots for display, and yours happens to be there. It could be someone else drawing from another one, or it could be you drawing from yours. A can't really know for sure. The destination is some other brand-new pots. Since A doesn't know which paint you used, it's just a random ordinary-looking pot. So, A has no idea to where the transaction was sent.

From A's point of view: maybe it was you who made the TX, maybe it was someone else. Regardless, the destination will be unknown, as well as the amount since there are 2 pots created, and A can't know how the amount was split or what it was.

So, the transactions are

A --> You (into pot P1) --> B (into pot P2).

Transaction spending P1 to make P, as it appears on the blockchain (notice no address :))

P1
X1
X2  ?   ---> P2
X3
X4

Ok, so looks like you're good, and achieves what you're asking in the question.

Problem is only if A and B are sharing user data between them, or some adversary has user data from both of them. Then, A would know P2 is the result of transaction you made because it it has your account info at B, and it also appears in a TX using P1 as input.

The takeaway is: this is probably acceptable for daily commerce and average user, but not if you're getting monero from A and buying forbidden books from B, while E has infiltrated both A and B. In that case, E can get you.

Use Your Own Wallet, With Extra Distance

What if you make some random TX-es before sending to B?

A --> You (into pot P1) --> You (into pot P2) --> B (into pot P3).

Suppose both A and B are monitored by E, so it's really:

E --> You (into pot P1) --> You (into pot P2) --> E (into pot P3).

And the possibilities?

P1
X1
X2  ?   ---> P2  --|
X3                 |
X4                 |
                   |
Y1                 ?----> P3
Y2                 |
Y3  ?   ---> Z1  --|
Y4           ...
Y5
...

So now B(E) doesn't know whether P2 is yours or someone else's. Also, E knows that maybe P2 came from P1 which she knows is yours. Maybe means there are 25 other possibilities (2TX-es, 5x5=25) which could also be true. Even if you never did a transaction to B, it could happen that B gets a false alarm that you could have. Any TX can include any "pot" so it's plausible.

So this is way better, don't you think?

For extra paranoia, do extra transactions beteween, and you're golden.

You can send to yourself as many times as you want, without anyone knowing you're actually doing it. Every such transaction (called "churn") puts you in a bigger crowd of possible senders. The more distance between any 2 TX-es, the more possibilities there are. At the same time, it increases the chance of others picking up your "pot" for display, and making even more fake trails without you having to do anything.

I think it's good to have 2 wallets. One you use to receive from A, and one you use to send to B. When moving your money from W1 to W2, be sure to send to yourself a couple of times whenever you're topping up W2, like:

A -> W1 -> W1 -> W2 -> B

You can spend repeatedly from W2 -> B. Just for topping up from A, it's good to do extra TX-es. If you're sending something from B, again do the intermediate cleaning, and use some W3 for sending back to A, like:

B -> W2 -> W3 -> W3 - A.

You can use any combination you want. If really careful, even one wallet will do, but it's easier to keep track what you do if you have more. What's important is to put some distance between A and B, that's all there is to it.

If you do some other transaction to some other party, it also counts as increasing distance between A and B, so if you're using monero regularly at various places instead of only A->you->B, maybe you don't have to do this extra steps


Can Monero recover from an inflation bug event?

History shows that Monero community is very careful and alert. The key image malleability bug (which could have allowed double spending) was fixed before anyone could exploit it.


What flags should I run with monerod to be the most helpful to the network?

The p2p interface doesn't require port forwarding at the router but the RPC interface does for remote access. Therefore if you wanted to help users needing a public remote node (e.g. for using a light wallet), you'd need to port forward to whatever RPC port you decide to listen on (--rpc-bind-port, the default being 18081). If you're going to do this, I suggest also using --restricted-rpc.

Now the p2p traffic, there are a couple of settings you can tweak which affects both the usefulness of your node to others and your bandwidth:

--out-peers arg (=-1)                 set max number of out peers
--in-peers arg (=-1)                  set max number of in peers
--limit-rate-up arg (=2048)           set limit-rate-up [kB/s]
--limit-rate-down arg (=8192)         set limit-rate-down [kB/s]
--limit-rate arg (=-1)                set limit-rate [kB/s]

For example, if the node is exhausting all your bandwidth, lower --limit-rate-up; if you have plenty of spare bandwidth, up it.

If you have significant bandwidth to share, and are opening up RPC, and you are going to maintain the node, you could also list your node on sites like moneroworld.


How to check payments and process new deposits

Take a look at get_transfers. It has many options for filtering your transfers.


As far as I know, the only other coin with working RingCT at this time is Lubecoin, a joke (I assume) coin forked off Monero very recently. I don't know where it is, but the forker was on IRC asking various questions about Monero for this.


How to get components of m (message) for verifying

Consult to the Varint description and transform from decimal to variant format for key offsets and transaction fee.

[1.] What is the format of key offsets?

799048 -> c8e230
782511 -> afe12f
1197717-> 958d49
216704 -> 809d0d
841722 -> faaf33

So the key offsets should be c8e230afe12f958d49809d0dfaaf33

[2.] What is the format of transaction fee?

Same as [1.] transaction fee should be 8088e2ed60

[3.] What is the range proofs?

I am not sure but I think the range proofs in MLSAG verifying is the concatenation of all asig and Ci. If it's wrong please correct me. Many thanks!


You are trying to hash a hex string not binary data.

Working example:

import pyrx
import binascii
import struct

def pack_nonce(blob, nonce):
    b = binascii.unhexlify(blob)
    bin = struct.pack('39B', *bytearray(b[:39]))
    bin += struct.pack('I', nonce)
    bin += struct.pack('{}B'.format(len(b)-43), *bytearray(b[43:]))
    return bin

seed = binascii.unhexlify('154eb7a21cd32a597f985644187297607bad491650091620550877239c4178e1');
nonce = struct.unpack('I',binascii.unhexlify('38870000'))[0]
blob = "0c0ccdb490f2053f393023bdc102f7bf4c63be5c64569dc0b57ab94e9881fd66157995b679adc700000000767cb11fc62b2bde9fb8eae21058d99ad317482bfdbcc1956d766888dd4d475709"
bin = pack_nonce(blob, nonce)
height = 2032062
hash = binascii.hexlify( pyrx.get_rx_hash(bin, seed, height) )
print(hash)

Which results in: f54a858a87f0f5bc9f3e75fba670a11cfdaf87b650d4189f50601597c8650200


You don’t connect monero-wallet-cli to monero-stratum, but general pool mining software such as XMR-Stak and XMRig. You specify the wallet address to receive your solo mining block reward in monero-stratum’s config file. You need to run monerod as well, and let monero-stratum connect to it.


Why is it faster to synchronize from the network than to import from a raw data file?

Mainly it's a question of available RAM and I/O bandwidth. When you're importing a raw file, reading the raw file takes up disk bandwidth as well as RAM in the filesystem cache. This competes with the disk bandwidth (and RAM) needed to write out the database file. When you're syncing over the network, this extra disk and RAM overhead isn't present.

Note that you can get some of the speed back by using a separate device for the raw file (separate from the device holding the database file). And if you have enough RAM to hold both the raw file and the entire database file, then the import can be done with no speed penalty at all; it will in fact be faster than syncing over the network.


Withdraw XMR from exchange EXMO, and deposit to Monero GUI

You can use the command line wallet (monero-wallet-cli) to create an integrated address.

[wallet 45xxxx]: help integrated_address
Command usage:
  integrated_address [<payment_id> | <address>]

Command description:
  Encode a payment ID into an integrated address for the current wallet public address (no argument uses a random payment ID), or decode an integrated address to standard address and payment ID

So launch the cli like:

./monero-wallet-cli --wallet-file path/to/your/wallet

Then run the command:

integrated_address

Which will then print out an integrated address with a random payment ID.

Alternatively, you can use xmr.llcoins.net/addresstests.html to create an integrated address as follows:

In the dropdown at the top left, select 'XMR integrated'
Paste your standard public address in box #8
Click 'Check Address'
Copy the output in the boxes next to 'Decoded:' and paste them into boxes #5 and #6 respectively
Click 'Random' next to the 'Payment ID:' box
Click 'Gen 7.'

You now have an integrated address in box #7. You can double check you have done this all correctly by then clicking 'Sent to 8.' followed by clicking 'Check Address'. The boxes next to 'Decoded:' should not change if you have done all this correctly.

Note that integrated addresses are being phased out in favor of subaddresses. So consider using an exchange that properly supports Monero.


Is there a `--language` flag for cli wallet?

There is none.

This is a good candidate to open a bug on https://github.com/monero-project/bitmonero/issues. It's also a good first task for a new contributor, and if none pick it up, it'll get done by an existing one.


How to sweep the contents of a specific output?

The TX would only link those 2 outputs together if they come from same TX. If they come from different TX-es, no problem - that's where ring signature has you covered as it will be ambiguous from which TXes are the outputs getting spent.

Even if in 1 TX the ring is "broken", just make another TX after it and already the trail is fuzzed. 2nd output is usually the change so it shouldn't belong to your wallet anyway. I think that even when you send to yourself there will be 2 outputs (2nd one of 0 value, but can tell which one it is)


Is there a risk that cold storage wallets containing non RingCT outputs will be unspendable in the future?

Theres no need to move arround your funds after any fork, even with updates like min mixing and the future RingCT the transactions will allways be compatible with the old ones


What is the Monero testnet? How can I participate in it?

From what I know about testnet, you can run a sort of "fork" of a code with other people to test if it's works or not before you put it into an actual fork. For example, people have recently been testing Ring CT on test net to work out any bugs and then correct them.

You can connect and help the testing in the network by still using the same daemon and simplewallet program you already have downloaded. You can start syncing with the testnet daemon and wallet by using

./monerod --testnet

And

./monero-wallet-cli --testnet

There are other options you can use when regarding testnet, and you can check them out using.

./monerod --help

This is just a basic intro of just what I know, but I hope this somewhat helps.


Can't create transaction: unexpected error: Call method failed

To workaround the problem I just had to close my other wallet (Exodus),  then it worked fine. Exodus has a Trezor integration and probably this blocked the Trezor device somehow.
Thanks to debruyne for giving the hint!


How can I use monero-blockchain-blackball to improve my privacy?

monero-blockchain-blackball was created to allow a line of defense against other people using Monero with low regard for privacy. In the simplest sense, this tool allows you to ignore others' outputs (containers of money) that are known to be spent in a certain transaction. If you would include these in your transaction as decoys, these decoys would provide little or no protection.
To use this tool, you need to specify the Monero blockchain location and the fork blockchain location. Your Monero download location may be different, especially if you specifically specified a non-default location.
Run the following commands depending on your operating system. Once this command is finished running, you can send transactions that will purposefully avoid using these outputs. Make sure to run the tool before sending sensitive transactions. You must run a full node to take advantage of these benefits at this time.
You can append --check-subsets to run a more verbose scan at a cost to performance. You can search only the recent outputs by appending --rct-only to save a lot of time and space. You can use --blackball-db-dir to save the database to a different location.
Linux / MacOS
monero-blockchain-blackball ~/.bitmonero/lmdb /path/to/other/blockchain/database
Example: monero-blockchain-blackball ~/.bitmonero/lmdb /home/monero_fork/lmdb --rct-only
Windows
Open a command prompt in the location of the monero-blockchain-blackball file and type in the following, or create a .bat file in the same folder and add the following:
monero-blockchain-blackball.exe C:\ProgramData\bitmonero\lmdb \path\to\other\blockchain\database
Example: monero-blockchain-blackball.exe C:\ProgramData\bitmonero\lmdb C:\ProgramData\monero_fork\lmdb --rct-only

This tool will create a LMDB database with the blackballed outputs in a data.mdb file. Unfortunately, you need to convert this file to be read by the wallet software. You will need to follow these steps to convert the database to a list of outputs that the wallet can read.
In order to extract the data, you need to build the LMDB tools. Follow the instructions on GitHub to make the LMDB binaries. Then navigate to ~/monero/external/db_drivers/liblmdb and run the following:
./mdb_stat -a /folder/with/blackball/database
This will show the hash of the database that you have created. Take a note of the database name (eg: blackballs-418015bb9ae982a1975da7d79277c2705727a56894ba0fb246adaabb1f4632e3). You will use it in the next step.
You now need to extract the outputs that need to be blackballed. Use one of the following:
./mdb_dump -s blackballs-<hash> /folder/with/blackball/database/ | awk '/[0-9a-f]{64}/{print $1}' > /output/path/file.txt
./mdb_dump -s blackballs-<hash> /folder/with/blackball/database/ | grep ^.................................................................$ | tr -d \  > /output/path/file.txt
The resulting .txt file can be imported into the official GUI and CLI.


There's a daemon (monero core) running on the MyMonero server. When you go to mymonero.com and make a new webwallet, there's a script in the browser that sorta functions like wallet software.

The browser script creates a new set of keys (spend and viewkey). The viewkey is transmitted to the mymonero server. The server uses the viewkey to find out which outputs on the blockchain are yours. It transmits that output information to your browser.

To create a transaction, the browser script creates and signs a transaction using your spend key.

I think the browser script also uses your spend key to find out which of the outputs received from the viewkey-identified outputs from the mymonero server are spent.

As you can see, the MyMonero server only ever gets your view key. Your spend key is created and stored locally when you login with your mnemonic word seed.


Dash uses a modified version of coinjoin to enable its users to mix their outputs with each other. Coinjoin was originally proposed by Gregory Maxwell, and has been available for use in Bitcoin for some time.
There are a number of services which connect Bitcoin users looking to mix their outputs, the most popular of these being JoinMarket.

Dash's privacy feature, called PrivateSend, is a series of chained coinjoins. To use PrivateSend, you must first allow the Dash client to "mix" your coins. Once this feature is enabled by a user, the client will start looking for other users with whom to mix. Depending on the number of "rounds" selected, this process can take anywhere from half an hour to several hours.

Each round refers to an individual coinjoin with at least 2 other users.  These individual coinjoins are then chained, which simply means that multiple coinjoins are performed one after another, ideally with different users participating in each coinjoin. According to the Dash developers, a higher number of PrivateSend rounds increases the privacy of a user's transactions.

PrivateSend does have a potentially serious flaw. Each coinjoin requires a server to facilitate the mixing. This requires users to trust that the server is not recording details on where each user's outputs are ending up. Dash attempts to mitigate this risk by using what they call "masternodes".  Masternodes are the servers which coordinate PrivateSend. These masternodes require a deposit of 1000 Dash to run. In theory, this collateral prevents someone from creating an arbitrary number of nodes for the purpose of recording coinjoin details.

Does this really mitigate the risk of coinjoin details being recorded, enabling transactions to be traced? Not reliably. The reality is that the majority of masternodes are hosted by a small number of VPS providers. These VPS providers could easily record the transactions being facilitated  by any masternode that they host.

Monero uses a cryptographic primitive called ring signatures. As implemented in Monero, a ring signature joins a user's transaction with other transactions, such that an observer can not tell which transaction in the ring is the "real" one. These other transactions do not need to occur simultaneously with the one that a user wishes to create. Monero can use any transaction in the blockchain as a participant in a new ring, assuming the correct outputs are present.

This is superior to coinjoin for a number of reasons. First, there is no need to trust a mixing server. Valid transactions are created by a user's client and then submitted to the network. Second, the privacy afforded by Monero is ensured through cryptography. Ring signatures have gone through decades of peer review in academic journals. This is time tested cryptography, which means a significantly higher degree of reliability.

Finally, Monero is one of very few cryptocurrencies which have actual cryptographers working on them. If you visit the Monero Research Labs page on Monero's website, you can view some of the research that has been published. These cryptographers are actively working on identifying and correcting any flaws in Monero.


What is the difference from monero-blockchain-prune-known-spent-data and monero-blockchain-prune commands?

monero-blockchain-prune-known-spent-data (an older tool) prunes specific pre-RCT known spent outputs and monero-blockchain-prune prunes the whole blockchain (a newer tool). You only need run the newer tool.


8 is the number of peers that you are connected to. 0 is the number of peers that are connected to you. if you want to allow others to connect to you, you need to open port 18080 on your firewall/router.


Could recent DoS attacks be avoided if Dandelion was not implemented?

The referenced blog post is a little misleading insofar as it wasn't the actual introduction of Dandelion++ that enabled or started the recent DoS attacks, merely that the attacks ramped up around the same time as Monero performed a major release, for which amongst other things also happened to include Dandelion++. Anecdotally, major releases are of course ideal times to launch such attacks.
The blog post does however give a good timeline and links to the PRs that have been plugging the holes used in the various and changing attacks and one should note that only 2 of the PRs even mention Dandelion++; many of the weaknesses this attacker has been exploiting preexisted this latest release (v17).
Luckily these attacks, whilst annoying, are fairly harmless (i.e. no funds are at risk and the network is still operating), so the net result is actually strengthening Monero. So whilst of course responsible disclosure would have been preferred, better to have manageable attacks now than left to exploit another day, possibly with greater impact.
Lastly, I'd caution using Bitcoin as a reference as to why something is or isn't added to Monero. Many things proposed and rejected for Bitcoin have found a place in Monero (privacy for starters). That said, it's worth noting that it was Dandelion, not Dandelion++, that was originally proposed for Bitcoin and there were various objections, most unrelated to possible DoS attack vectors.


Syncing Monero blockchain and get error not sure that the problem is. Error posted below

Your errors indicate that your blockchain is most likely corrupted. To resolve this issue you need to resync from scratch. This is done by deleting data.mdb from C:\ProgramData\bitmonero\lmdb (Windows) or $HOME/.bitmonero/lmdb (Linux and Mac OS X), which will trigger the resync.

To avoid corruptions make sure to always gracefully exit monerod. In addition, make sure you are running the latest version, which is 0.10.3.1 currently.


Do I need to sync the entire blockchain before I can send a transaction?

I will try to combine the above answers and my own information into one answer.

  After recovering my wallet with my mnemonic seed, do I need to synchronize the entire blockchain before I can send a transaction?

Once you have your wallet, all you need is access to a monero blockchain with the proper data to send a transaction. Access to a monero blockchain with proper data can occur in three ways, the first of 2 are practical (as in, they exist) and the 3rd is theoretical (as in, it hasn't been created yet).

Possible Now

You synchronize with the network on your own device and connect your simplewallet instance to your own blockchain (the daemon). This means downloading the entire blockchain.
You connect your instance of simplewallet to a remote daemon using --daemon-host host:port, or --daemon-port port, and --daemon-ip ip when you load simplewallet (i.e., these flags are entered on the command line directly after the word simplewallet. For example, in windows the command would look like simplewallet.exe --daemon-host host:port. This allows you to use someone elses blockchain data. There are privacy and security risks when using a remote daemon that are not relevant to your question.

Possible in future, pending implementation

You connect your instance of simplewallet to a light version of the blockchain (includes outputs you own and some random outputs from the chain). Again, this is theoretical, because this type of blockchain data reduction has not been created yet. This is more-or-less what you refer to in the second part of the question, "If I know the block-height when I received my first Monero payment, is there a way I can save time by synchronizing only past that point?"


Can I run my simplewallet node from an external hard drive?

Couple things... is it eating away at your memory (RAM) or storage (disk space)?

If you mean RAM, the answer is no. The computer memory used to run simplewallet and the daemon are not dependent on where things are being stored, at least in any measurable sense.

If you mean disk space, yes, kind of. What I mean by this is that you should still "run" bitmonerod and simplewallet from your primary disk, but specify a data directory on your external hard drive for bitmonerod. On macOS, this involves running the daemon like dEBRUYNE said, as such:

./bitmonerod --data-dir /Volumes/<my external HDD>

Note that you should run this command in the Terminal from the directory where you've save the bitmonerod executable.

To figure out what goes in <my external HDD>, open a Terminal and type

ls /Volumes

This should display a list of all connected volumes. Find your HDD (say, MyHDD), then do

./bitmonerod --data-dir /Volumes/MyHDD

Note that if you have already synced a blockchain in a previous location, you may need to move it or resync.


How is Monero's network less secure than Bitcoin?

The security of a PoW network is basically the amount of money needed to attack it. Bitcoin has had a lot of money poured into miners, and Monero nowhere as much.

As an idea of how much money would be needed to attack Monero via a 51% attack, see this post: How much money would be required to cloud mine 51% of the network hash rate?. The network hash rate was 21 MH/s at the time of that calculation, so the cost should now be 50% higher since we're now at about 31 MH/s. That gives you about 90 thousand dollars a day.

For Bitcoin, mining is performed by ASICs. We can find rough estimations of the total energy used by the Bitcoin network at http://www.allied-control.com/publications/Analysis_of_Large-Scale_Bitcoin_Mining_Operations.pdf, about 250 to 500 MW. Let's use 400 MW as a high middle ground. In a day, at a cost of, say, 10 USD cents a kWh (https://en.wikipedia.org/wiki/Electricity_pricing#Price_comparison) for the US as an example, we get 400e6 * 0.1 / 1000 * 24 = 960 thousand dollars a day.

Now, these are very back of the envelope calculations. Using one's own GPUs for Monero (same as is assumed for Bitcoin) probably decreases the cost to attack Monero, and the numbers for Bitcoin may be out of date. But it shows how the relative security of two PoW networks compare. Incidentally, take particular attention to how the hash rate of the two networks can't be compared, as they use different hashes (the very fast SHA256 vs the slow Cryptonight).


Monero are always sent to the one-time destination (public key) P. In the CN whitepaper, the corresponding private key is referred to as x.

When you're spending, you're combining your P with a couple of other ones in a ring signature and signing with the x. Only one of the Ps will be spent, but the ring signatures hide which one. In other words, the signature is verified by all of the Ps, and it looks like any of their corresponding private keys could have signed the transaction, thus obfuscating the sender. But how do we know you're not double-spending? We need a way to prove that the private key used to sign was not used before, without revealing which one it is. That is where the key image comes in:

I = xHp(P)

Let's also take a look at how the one-time key-pair is derived:

P=xG

Since I is a one-way function of x this means that:

Nobody can recover the public key from the key image and identify the signer;
The signer cannot make two signatures with different I’s and the same x which in effect means you can spend your P only once.


Generate an integrated address from a different wallet's standard address

The only way, via RPC, is to load a wallet with monero-wallet-rpc and call the make_integrated_address method. This accepts either no address or a supplied address, and a payment ID.

However, depending on your use-case and with a little code, it is fairly simple to create an integrated address from a given standard address and payment ID. The format is described in this answer.


Should we synchronize blockchain from scratch after every scheduled hard fork?

I think generally just update the binaries and sync from where you left off. I believe the resync from scratch with the most recent binaries (v0.10) were due to significant changes to the database format, and resyncing was generally faster than converting the old one.


Edit:  Seems the question has been answered by dEBRUYNE in comments above.  Therein lies the answer.

Use your XMR seed with the XMO client to get your funds back.  You can still exchange them to XMR at Changelly, but I wouldn't count on that being the case forever, as XMO is not, as far as I know, used by anyone, at all, for anything.

XmanXU has posted on github the fork, though I would not recommend using it.  The person advertised the publication on reddit as well, to near-universal disapproval, by the way. It seems to be a scam coin that actually hurts the privacy of XMR itself.


Problem Restoring Wallet from the Monero GUI, Right Arrow Greyed Out

I had this same problem. When I unclicked both "stagenet" and "testnet" the arrow became available.


Can I copy my pruned blockchain .bitmonero folder to another computer and start syncing?

After pruning the monero blockchain, can I copy this pruned blockchain from the .bitmonero folder to another computer and just start syncing from there?

Yes.

  What are some disadvantages of pruning the blockchain...

This is a good question. Let's first take a step back and understand what happens with pruning. When your domain is fetching and validating blocks, after it's done, it can prune various data it is unlikely to need again. For example, once we have validated a txs signatures, we can discard them. To keep our node useful to the rest of the network, we maintain sections/slices of our blockchain unpruned. Therefore, if everyone has a pruned node, a new participant can still download and validate the whole blockchain - they'll just be grabbing separate sections (unpruned sections) of the blockchain from different peers.

I suppose the main disadvantage is less redundancy. Imagine someone in a rural location, poor internet connection etc. They ideally sync their whole blockchain from the nearest fastest full node, but, if the nearest/fasted peer is pruned, they are then reliant on using more distant, thus slower, peers.

  ...or where one might want the entire 71GB blockchain?

If disk space is not a concern, there is simply no need to prune. ~70GB is
certainly not huge by todays standards - a lot of mobile phones have
this space available even.
If you want to optimally help the rest of the network by providing the maximum  redundancy, as detailed above.

I'm sure there are other reasons too, but those sprung to mind first.


Does a Monero wallet require payment id by default?

A payment id is optional, however in some cases it is very important otherwise the receiver may not realise you've sent money to them.

Cases such as sending Monero to an exchange, or situations where someone uses one address to receive many payments, a payment id is going to be necessary.

Generally though, unless the person/website specifically requests a payment id, it's not going to be necessary. General usage shouldn't require one.


Could a blackballs list be used maliciously?

A blackball list is a set of outputs which are known to be spent - or so the claim is. As you surmise, if that list lists outputs which are not known to be spent, but does not list outputs which are known to be spent, this will indeed cause the wallet to use a weaker ring.

If you do not want to scan the blockchains yourself, a way to mitigate this is to ge lists from two different sources and compare them. At the moment, sgp is planning on making such a list available in the near future.

Last, txids aren't blackballed. The blackballing process is done at the output level, since an transaction might create an output which is later known to be spent, and another which is not. For reference, there are currently about 29 million outputs, and 4.9 million transactions on the Monero blockchain. This makes the 16 million txid number highly suspect.


You have to be fully synced in order to solo mine. More specifically, you mine on top of the last (consensus) block, which is only possible if you are fully synced or, in other words, in sync with the network.

If, however, you're mining on a pool, you don't have to be fully synced (nor have to run monerod technically). Furthermore, you'd need one of the miners listed here:

https://www.reddit.com/r/MoneroMining/wiki/index

  Very slowly

The initial sync can take quite some time. However, thereafter, catching up every few days (or every few weeks) only takes an insignificant amount of time.


Check the Balance of Cold Storage Address - Block Explorer

Monero isn't like Bitcoin, so you can't just go to a block explorer and enter in your wallet address and ask the block explorer to tell you what funds you own.

Monero needs to perform computation on every single transaction in the blockchain to scan for incoming transactions. The block explorer won't do this for you, so you don't be able to use it to see your balance.


Is there anyway to calculate how much privacy is gained by increasing the ring size of a transaction?

A mixin of 4 means there are 4 decoys in addition to the real input, which means the ring size is 5.

No ring would be needed at all if your output could never be associated with you. However, the exchange or person that gave you the output does know you control it  if you told them who you are.

Therefore a ring size of 5 means that when the person that gave you your output sees that the output has been used in a transaction, then when you spend it they can see there is a 1 in 5 chance it was actually you that spent the output. That's until someone else uses the output you were given as a decoy in their own transaction. Then the chances it was you is 1 in (total number of outputs that exist in ring signatures that include your output as a possibility).

Of course, due to stealth addressing, the person that gave you the output in the first place gains nothing from knowing there is a possibility you spent it, because they can't tell whom you spent it with.

So increasing the ring size beyond the default only really matters if someone knows which outputs you were given, and the vendor you spend your outputs with is hacked or otherwise leaks information about what outputs they've received.

If someone that gave you an output can see that you could have spent that output with a compromised vendor because the vendor has been hacked, then they know that the probability that it really was you that transacted with that vendor is 1 / 5, or more generally, 1 / ring size.

Bottom line: I don't see any reason to not use the default ring size.


What will Enable monero to scale where Bitcoin failed?

Monero will scale where bitcoin failed because Monero is hardcoded to scale to the network infrastructure (a real variable), whereas Bitcoin is hardcoded to scale to a decision made by humans (the 1 MB block cap).


Can auditor restore transaction dates/times/amounts?

Viewkey only shows in which TX you received something so time, date and the amount you received. It can't possibly reveal source address because it's never actually written inside the TX.

Spendkey additionally reveals whether what you received above has been spent or not and in which TX it was spent and how much. It will tell you the destination one-time key but these can't be tied to addresses. Spendkey can also be used for this in a cold setup or to export the data to auditor without actually revealing the spendkey.

None will reveal destination addresses of your funds because it's never written in a TX. Think of addresses more like instruction to sender, and not as something which itself holds the funds. Funds are always sent to brant-new one-time keys rolled at random for each TX you or someone makes.

The only way to know the destination address is to record it locally when you send and your wallet does that. If you delete the wallet file or lose the password, the information is lost forever.


I am missing (not seeing) a transaction to (in) the GUI (zero balance)

First and foremost, to put your mind and ease and to verify that your transaction was correctly sent to your address, use this guide to verify your transaction:
How do I, as a recipient, verify that my transaction actually arrived?
It should show that you have one output with output match? = True for the amount you expect to receive. If this checks out, you can proceed with the rest of the guide.

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

The following assumes you're using a local node
First, you can check whether you are using a local node by going to the Settings page and looking at the daemon address. It should state localhost (or 127.0.0.1) with port 18081.
Now, the most common "problem" is that people are not fully synced yet or their GUI wallet is erroneously stating that it's fully synced. If you're not fully synced yet, the GUI will not be able to "see" your transaction. To confirm your fully synced, perform these steps:
[1] Go to the Settings page of the GUI.
[2] Go to the Log tab.
[3] Type status into the command + enter (e.g. 'help' or 'status') box.
[4] An output will be displayed that looks like:
Height: 1456425/1456425 (100.0%) on mainnet, not mining, net hash 290.20 MH/s, v6, up to date, x(out)+x(in) connections, uptime xd xh xm xs

Where x is simply an integer. For example, you could have 8 outgoing connections and 2 incoming connections. The Height can be explained as follows. The first number is the height you (personally) are currently on, whereas the second number is the top height (most recent block on the blockchain). The first number can be lower than the second number if you haven't completed the initial sync yet.
[5] Now to verify that you're actually fully synced, compare the first number to the height displayed on a blockchain explorer like, for instance, XMRchain. You're fully synced if your height matches the height displayed on a block explorer.
[6] If the GUI is stating that you're fully synced (100.0%), but your height doesn't match the height displayed on a block explorer (and is off by a large number), it is erroneously reporting that you're fully synced. This is, fortunately, easily resolved as follows. First, exit the GUI and make sure to stop the daemon as well. Second, restart the GUI + daemon. Third, use the status command to verify that it's now correctly displaying the top height.
[7] If the GUI is correctly stating the top block height, but is stuck on a particular block, perform these steps. First, exit the GUI and make sure to stop the daemon as well. Second, restart the GUI + daemon. Third, use Show status to verify that it's now syncing past the block it was stuck on.
[8] On the 9th of March (block 1788000) a scheduled network upgrade occurred. If you are still running a v0.13 version, you can be reasonably certain that you're on the wrong (alternative) chain. Intuitively, the GUI will not be able to see a transaction sent to your wallet if it's on the wrong (alternative) chain. Fortunately, this is easily resolved by following this guide
Note that after the daemon is fully synced, the wallet will start refreshing. In addition, in Monero, there's two "syncs". First, the blockchain sync, which is basically downloading the blockchain from other nodes / peers. Second, the wallet sync, which is the wallet "refreshing" / scanning blocks looking for transactions belonging to your address / wallet. You should see your funds once both syncs have been fully completed.
Now, if you're fully synced, the wallet fully refreshed and you don't see your funds yet, perform these steps:

Exit the GUI, but keep the daemon running.

Browse to the directory your wallet files are located (Documents\Monero\<wallet-name> on Windows | home/<username>/Monero/<wallet-name> on Linux | Users/<username>/Monero/<wallet-name> Mac OS X).

Rename <wallet-name> (the file without extension) to <wallet-name>-old

Restart the GUI. This will trigger a wallet refresh from scratch, which shouldn't take longer than 30 minutes.

Once it states Connected (in the left bottom) you should see your funds.

Still not seeing your funds? Your wallet may, for some reason, have an erroneous Wallet creation height. You can resolve this as follows:

Go to the Settings page of the GUI.

Go to the Info tab.

Change the Wallet creation height to 1940000

This will trigger a wallet refresh from scratch, which shouldn't take longer than 30 minutes.

You should see your balance once it completes.

Still not seeing your funds? It might be that a small part of your blockchain is corrupted and it's, coincidentally, the part that contained your transaction. Perform these steps:

Go to the Settings page of the GUI.

Go to the Node tab.

Switch the wallet mode to Remote node

In the address box enter node.moneroworld.com

In the port box enter 18089

Click in another empty box on the page to ensure your settings are properly saved.

Again browse to the directory your wallet files are located (Documents\Monero\<wallet-name> on Windows | home/<username>/Monero/<wallet-name> on Linux | Users/<username>/Monero/<wallet-name> Mac OS X).

Rename <wallet-name> (the file without extension) to <wallet-name>-old2

Restart the GUI. This will trigger a wallet refresh from scratch, which shouldn't take longer than 30 minutes.

Once it states Connected (in the left bottom) you should see your funds.

The following assumes you're using a remote node
If you're using a remote node, you're basically using someone else's public node / blockchain. Therefore, it's unlikely that an uncompleted sync is the issue. Thus, perform these steps:

Exit the GUI.

Browse to the directory your wallet files are located (Documents\Monero\<wallet-name> on Windows | home/<username>/Monero/<wallet-name> on Linux | Users/<username>/Monero/<wallet-name> Mac OS X).

Rename <wallet-name> (the file without extension) to <wallet-name>-old

Restart the GUI. This will trigger a wallet refresh from scratch, which shouldn't take longer than 30 minutes.

Once it states Connected (in the left bottom) you should see your funds.

Still not seeing your funds? Your wallet may, for some reason, have an erroneous Wallet creation height. You can resolve this as follows:

Go to the Settings page of the GUI.

Go to the Info tab.

Change the Wallet creation height to 1940000

This will trigger a wallet refresh from scratch, which shouldn't take longer than 30 minutes.

You should see your balance once it completes.

If you, after all these steps, still don't see your funds (but verified with this guide that they were correctly sent to your address), it'd be best to either open a new issue the GUI repository or contact me on Reddit.


Does a tool exist to monitor multiple Monero miners?

Although im not a big fan of this exact web-portal, personally i'd rather see something built with Symfony for example and have a lot more flexibility, but it does fit your intended purpose i think;

https://getminera.com/

You can customize it to monitor/manage and even build/compile multiple monero miners, but it currently only has examples built-in for other currency miners.


How much arbitrary data I can embed in a transaction?

An arbitrary amount of arbitrary data can be added in a transaction. The extra field contains data with a high level structure. Several fields are predefined, such as public key, or extra nonce. In order to add custom data there, you would need to define another data type, and store it in that extra field. Minergate recently did just this, adding 32 bytes of data with unknown semantics.

Note that since Monero has transactions fees which depend on transaction size, the more data you add to the extra field, the more you will have to pay in fees (currently 0.01 monero per kB).


The difference is likely the availability of AES-NI:

grep aes /proc/cpuinfo

Some VM configurations may not allow use of the underlying AES-NI instructions by VMs.

Less likely, it could be the lack of L3 cache memory (Cryptonight needs 2 MB cache per mining thread for good performance).


How to parse TX_EXTRA_TAG_ADDITIONAL_PUBKEYS from extra

The structure of your whole extra field is:

01 - TX_EXTRA_TAG_PUBKEY (1 byte)
49fa9fbadf1c1a4d054c6cbf918778f869ad02103501d8da7eec8762eb2202e6 - the tx pubkey (32 bytes)
04 - TX_EXTRA_TAG_ADDITIONAL_PUBKEYS (1 byte)
04 - the number of tx additional pubkeys that will follow (varint)
23a7b09c4078f5c9ea571e3db6e5406de7c27f5e9ec27c84575ce7ad247baf03
c9b9152925ec1a3cb3afde3ba43d42581f032bfd39badb178058f654c74b860d
f4f3a6d5c3bd7abf9b4c183c5db3d4ae34cd2ebfe77be112ff28f869dc2e5600
35136f206595a6777ba3be8eda6baf036d425fffe0b8678c4ca5cc853f705694
 - the 4 additonal tx pubkeys (32 bytes each)

Note that if you try to parse the tx extra tag and it is 00, that is padding and you can skip forward a byte. If it is anything other than 00, 01 or 04, then after you read the tag, read a varint next, and then skip that number of bytes (as indicated by the varint) to get to the next tx extra tag id to read.

The varint integer representation is defined in section 1.2 of https://tukaani.org/xz/xz-file-format.txt


Is it possible to reset the blockchain with a new genesis block for efficiency?

In Monero, it is impossible to distinguish between spent and unspent outputs. Therefore no one could create a new blockchain with just the unspent outputs from the current blockchain, because the unspent outputs are unknowable.


Why is the payment ID specified on a per TX basis?

From my understanding, the payment ID is not associated with a specific output. It is included in a different portion of the transaction, near the transaction hash and public key.

There is no practical reason to use more than one payment ID. Its only purpose is for merchants and exchanges to verify which person sent the funds to them. There is a direct harm to the network with the substantial additional transaction size if a per-output method was chosen.

I do not believe that there is any risk of leaking which inputs and outputs are the "real" ones when using a payment ID. It should be computed separately. Even if it is not, I would suggest adding 1 to the default mixin, which would provide the same security improvement with less additional bloat.


How long should the GUI wallet take to synchronize?

It is significantly slower with an HDD compared to an SSD. Bandwith is also a significant factor.

Yes, if you clicked on the defaults, then you are downloading the entire blockchain. See this exchange for details on the necessity, and this one for light clients (like Electrum).

A very vague approximation would be 24h ( ~80% margin of error :) ). Currently, the blockchain size is ~10GB.


It is impossible for a miner or any other blockchain observer to know whether any transactions are destined for a particular wallet address (or wallet account). This is because wallet addresses do not appear on the blockchain at all.

Monero instead uses stealth addressing, which encrypts the destination of the transaction such that only the recipient can scan the blockchain to see that any particular transaction is destined for them.

When outputs (which are amounts of Monero) are sent to an address, the sender will know which outputs are sent. So an exchange, for example, will know what outputs were sent by the exchange to the wallet address you told the exchange about.

It could theoretically be possible that miners could decide to censor transactions that attempted to reference those outputs in any ring signature, thus preventing those particular outputs from being spent in the future.

It is most likely, however, that not all miners would agree to censor those outputs. This would lead to a blockchain fork, where one group is recognizing certain transactions as valid and others are considering them invalid due to their decision to censor.

In such a circumstance, the outputs would only be spendable on the fork of the blockchain that did not decide to censor.

Because Monero miners are spread across the world in many different legal jurisdictions, it would be very difficult to force miners to perform any kind of censorship.


What do I need to change/add in order to add a field to the block struct?

You would edit the block struct in https://github.com/monero-project/monero/blob/master/src/cryptonote_basic/cryptonote_basic.h by adding the extra variable and specifying the serialization field correct to the type of your variable.


How do I import a large number of private keys into a wallet?

Most of the time associated importing keys will be the sync requirement before those keys can be used to sign a transaction.

I am not aware of any official script that can be used to important many keys at once. Even if such a script existed you would still need to sync each account before funds could be spent. simplewallet can only sync one account at a time. You could run multiple instances of simplewallet in order to speed up the sync process.


Firstly, Kovri is an abandoned i2p router implementation. There are plenty of other actively developed i2p routers (such as i2p-zero), all of which can be configured to work with Monero via the various Anonymity Network options.

Second, when discussing anonymity of transactions, there are multiple threat models that need considering. By default, Monero transactions on the blockchain hide the sender and recipient wallet addresses and the transaction amounts. However, this alone does not cover all possible threat models. A simple example could be a regime that outlaws cryptocurrencies. Simply running a node then becomes a threat. One also needs to consider various deanonimization attacks. If a vendor/exchange/ISP is coerced or compromised, transactions could be linked to IP addresses, and IP addresses link to actual identities via the network providers.

This is why it's soo important to consider all possible places that data can be leaked and all types of adversaries. Hiding the sender and receiver wallet addresses and the transaction amounts from the publicly visible blockchain covers some threat models, but not all.

What tor/i2p aim to do is hide network usage. If a transaction is broadcast over i2p/tor, it's considerably harder to tie that transaction to an IP address and thus a real world identity.

It's also worth noting that tor/i2p are not silver-bullets here, which is why other techniques have also been under development, such as adding network "noise" and some kind of Dandelion++ implementation.


What are the bandwidth and latency requirements of a miner? What is the total data usage per week?

Assuming you refer to pool mining...

This question was partially answered here: Does mining use a lot of bandwidth?

  20 Mb/day download and less than 5 Mb/day upload

So over a month, that's ~750 MB combined. So a 1 GB 4G plan would be more than adequate.

As for latency, the general rule is that you want the minimum latency possible. Any latency in your connection results in losses in mining efficiency. That being said, 4G connections quote latencies in the low 100s of milliseconds, which is probably good enough. This assumes a strong 4G signal, at the least. It's possible you would be okay with a 3G plan as well, as that tends to only ~double the latency. The size of information being transmitted between your miner and the pool at any given time is quite small (much less than even a fairly simple webpage) and so many of the benefits of 4G vs 3G are likely to not be as noticeable.


Generating one time use 2FA accounts error

By putting "random" in box 10 and your address in box 11, it successfully generate a new address.
Do you still have the problem? Are you filling the same boxes?

By the way I was using the site online, which is absolutely to avoid when using the redeem function.