What does ask-password = 1 (action) mean for the monero cli wallet? I set ask-password = 1 (action). What does action mean? 2 means always ask password for everything you do right?

0 means do not ask for things like transfer, etc. The password will still be needed to change settings, since this requires writing the keys file, which is encrypted with the password.
1 means ask for things like transfer. The password is checked, and the command only proceeds if the password is correct.
2 means ask for things like transfer, but the spend key is actually encrypted in RAM, so that it can only be read again with the password. This is basically like 1, except the check is not only a "is the password correct", but "if the password is not correct, I don't even have the spend key". This guards against a memory dump of the process exposing the spend key. Monero takes steps to avoid core files or swapping of sensitive data, but this is just another layer of defense.


Why not include a README.TXT in the GUI Wallet Beta zip file? Consider adding a README.TXT to the Monero GUI wallet that contains some helpful hints on getting started, it could even just be a handful of URLs.

It'd be a bonus if it explained some of the executables in the package and which does what.

I'm coming to this because I've installed the GUI wallet in Windows and imported a wallet but can't get the daemon to start.  I'm thinking that the dameon is equal to monerod.exe but went looking for a README to verify.

No particular reason. It'd need... someone to write one, someone to PR one, someone to include it in the release. fluffypony can take care of the third. The first one is the most time consuming. I think the release notes that are already published on github could be usefully included. But anyone's free to add a "my first few steps with the GUI" introduction to the GUI and PR it to https://github.com/monero-project/monero-core. If you dream of being a Monero contributor, now's your xhance :) And if not, somebody else will do it eventually. But yes, a good idea :)


Why the syncing of the wallet is very very slow? I am new in Monero, I created a wallet address with Monero GUI, and someone transferred a little bit Monero to my address. However, I cannot see any transferred Monero in my wallet and the wallet just shows me a message about daemon syncing, after a week there is still 250000 daemon blocks to synchronize?!!! I really do not understand whether it is normal for the all wallets? Or there is a problem with my wallet?

The Blockchain is huge. If you don't have a very high speed internet connexion, it's usual do need a week and a half to download the 55G Blockchain in a peer-to-peer manner with monerod.
Mine took that time to download.


Monero Javascript Library It is my first time working with Monero, since it is a coin based on blockchain I guess it follows similar principles than BTC and ETH.

Is there a javascript library like bitcore or web3 to interact with it?
Is there a testnet?
Is there a test faucett?

Thanks in advance

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


Would another node client be valuable to Monero environment? Ethereum seems to have good experience with alternate node clients, would having another one for monero be a good idea or is it still just to early and would maybe slow devs detracting from more progress. thanks all :DD

The propensity for Eth's multiple implementations to fork unexpectedly is a double edged sword. That said I think once Monero is largely feature complete (probably after multisig is rolled out) there's great value in embracing alternative implementations.

So, I guess to answer your question, yes, there are benefits, but it's better for various reasons to focus on making one client as complete and robust as possible before working on new implementations.


Does Bitcoin have any technical advantages over Monero? Having a far larger network hashrate makes Bitcoin much more resistant to 51% attacks than Monero. Bitcoin also has the advantage of being accepted at many more merchants than Monero (when the purchased item is over the xmr.to and Shapeshift transaction limits).

Ignoring the greater expense to launch a 51% attack, are there any other technical or unique feature advantages Bitcoin has over Monero?

How does Bitcoin price volatility compare to Monero? Can lower relative volatility be considered a technical advantage for a currency that is often help for a period of time before being spent.

Would a privacy focused user of both Bitcoin and Monero wanting to purchase an item costing 2BTC or less from a BTC merchant have any reason to pay with Bitcoin instead of Monero (other than for the purposes of saving the exchange fee charged by xmr.to)?

Can the Bitcoin protect the privacy anything that Monero cannot with regard to transaction or metadata?

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

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

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

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


How do I restore / recreate my Trezor Monero wallet? I have lost my Trezor device and/or cannot access the system with my Trezor Monero wallet files. How do I restore / recreate my Trezor Monero wallet?

I've noticed some confusion lately on how to restore one's Trezor Monero wallet. I have therefore written this guide.
In case you have also lost (access to) your Trezor device, you first have to restore the 12 or 24 word Trezor mnemonic seed in another Trezor device.
Restoring / recreating a Trezor Monero wallet is fortunately fairly trivial thereafter.
GUI:

Basically you ought to follow this guide with one minor tweak to recreate / restore the Trezor Monero wallet. That is, the Restore a wallet from device option has to be selected (in step 8). This allows you to set a Restore height that is in advance of the first transaction to your Trezor Monero wallet. A detailed explanation about the Restore height parameter can be found here. For convenience, I've added a table with restore heights to the appendix.

Note: Use this work around if you cannot access the Restore height box:

There is a fix for the time being: You can access the restore height window by selecting the wallet location and pressing tab once.

CLI:

Basically you ought to follow this guide with one minor tweak to recreate / restore the Trezor Monero wallet. That is, you have to append the --restore-height flag (with a proper block height as value) to the command that is used / executed to recreate / restore the Trezor Monero wallet. A proper restore height is set by choosing a value (block height) that is in advance of the first transaction to your wallet. A detailed explanation about the Restore height parameter can be found here. For convenience, I've added a table with restore heights to the appendix.

Appendix:
My wallet was created in | Restore Height I should use
November  2020           | 2175000
October   2020           | 2155000
September 2020           | 2135000
August    2020           | 2115000
July      2020           | 2095000
June      2020           | 2075000
May       2020           | 2055000
April     2020           | 2035000
March     2020           | 2015000
February  2020           | 1995000
January   2020           | 1975000
December  2019           | 1955000
November  2019           | 1935000
October   2019           | 1915000
September 2019           | 1895000
August    2019           | 1875000
July      2019           | 1855000
June      2019           | 1835000
May       2019           | 1815000
April     2019           | 1795000
March     2019           | 1775000
February  2019           | 1755000
January   2019           | 1735000
December  2018           | 1715000
November  2018           | 1690000
October   2018           | 1665000
September 2018           | 1640000
August    2018           | 1615000
July      2018           | 1590000
June      2018           | 1565000
May       2018           | 1540000
April     2018           | 1515000


Why are the Monero GUI components (exes) flagged by AV as malware? I was able to get around this by disabling my Comodo AV but it makes me wonder what code is/are in these exes/binaries that is making the AV see them as malware? I code, so I'll be fine discussing this at the code level (specific functions, calls to the OS, etc.)

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


How could Monero enable instant transactions? Some cryptocurrencies offer a feature for instant confirmations of transactions. What is required for these instant transactions to take place, how do they happen, and what is required for them to be implemented in Monero (if possible)?

Daughter chains are one of the development goals for Monero. One of these daughter chains could theoretically be used to allow for instant/micro/etc transactions. The idea would be to allow super-fast transactions (or whatever other feature) on the daughter chain, and then settle back to main-chain once a day (or some other interval).


Accidently send funds to non-hardware wallet (GUI desktop). Would like to move them to hardware wallet I purchased some monero and successfully sent my funds to my GUI desktop wallet. Stupidly, I created the hardware wallet account on the GUI desktop AFTER I had already sent the funds to my "regular" GUI wallet. It seems as if it is possible to essentially send the funds "to myself" via transaction from non-hardware wallet account to my hardware wallet account. Am I correct in utilizing a transaction in this way to secure the funds on my hardware?

It seems as if it is possible to essentially send the funds "to myself" via transaction from non-hardware wallet account to my hardware wallet account. Am I correct in utilizing a transaction in this way to secure the funds on my hardware?

Yes.


Why there are four parameters for hard fork? static const struct {
  uint8_t version;
  uint64_t height;
  uint8_t threshold;
  time_t time;
}

It is easy to understand version and height, but it is hard to understand threshold and time.
And how time is determine?

Explained in the Monero source code comments.

 * @param version the major block version for the fork
 * @param height The height the hardfork takes effect
 * @param threshold The threshold of votes needed for this fork (0-100)
 * @param time Approximate time of the hardfork (seconds since epoch)


How to call get_hashes.bin RPC method? From the documentation: https://ww.getmonero.org/resources/developer-guides/daemon-rpc.html#get_hashesbin
The description is not clear:

block_ids - binary array of hashes; first 10 blocks id goes sequential, next goes in pow(2,n) offset, like 2, 4, 8, 16, 32, 64 and so on, and the last one is always genesis block
start_height - unsigned int

Can you give an example?
What does block_ids and start_height do?

I believe the documentation maybe slightly outdated / misleading. Looking at the source code, the vector of block hashes, block_ids, would have the hashes (in binary form) starting with your local most recent few block hashes and ending with the genesis block's hash (so in reverse chronological order). start_height is used to specify the height of your most recent block hash.

Let's assume you have the block hashes in block_ids of [B10, B9, B8, B0] and start_height set to the height of B10 (where Bn is the hash of block n).

If the remote node you are calling the method on has blocks B0 through B2000, it would return, in m_block_ids, the hashes for blocks B1010 through B10 and return start_height as the height of block hash B1010. As you see, only a maximum of 1000 hashes are returned (think of it like a page of hashes), so you can then call the method again but this time with block_ids of hashes [B1010, B0] and start_height as returned from the last call's response start_height (so the height of block hash B1010).

Note, this method, and the other .bin methods, are binary encoded, not JSON.


What sort of deanonimization attack could someone controlling the majority of nodes pull off? In the era of Docker containers and how easy it is to spin up potentially thousands of nodes in a minute, what kind of attack could some malicious actor pull off if they performed this? Would Dandelion fail, assuming a single entity could temporarily be the link between the majority of nodes? Would remote nodes become very risky, as these nodes could all serve malicious blockchain info? Would different attacks be possible depending on the % of malicious nodes run, i.e. 50%, 75%, or 90%?

In the era of Docker containers and how easy it is to spin up potentially thousands of nodes in a minute,

I wouldn't agree it's as easy as you allude to. Each node needs to use a blockchain (storage) and sync (bandwidth). Thus costs and effort are not as negligible as may seem.

  what kind of attack could some malicious actor pull off if they performed this?

Transaction censoring, linking transactions to IP addresses, selfish mining, forking the network... all sorts of mischief becomes possible if one controls a majority of the network. In practice it's far from simple however.

  Would Dandelion fail, assuming a single entity could temporarily be the link between the majority of nodes?

That's getting a bit specific to a generalized problem. If a single entity controls a majority of the network, Dandelion or not, linkage is going to be one of the possible attacks we'd face.

  Would remote nodes become very risky, as these nodes could all serve malicious blockchain info?

Using a public (which is what I assume you are referring to) remote node is always "risky". You are trusting that the remote node operator is not logging your IP and times you are transacting. You are trusting their view of the blockchain they serve you. So if you're inclined to use (and trust) random unknown nodes now, of course it becomes more risky if there are more malicious nodes.

  Would different attacks be possible depending on the % of malicious nodes run, i.e. 50%, 75%, or 90%?

Without you defining a specific attack, in general, any eclipse style attack becomes more effective the more of the network is controlled.


Mymonero and simplewallet mnemonic seed compatibility Mymonero and simplewallet use different numbers of seed words.

Are they compatible?

Can seed words created by Mymonero be used to recover a wallet with simplewallet?

Can seed words created by simplewallet be used to recover a wallet with Mymonero?

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

return 0;

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

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

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


Problems with creating name and regularly accessing view-only wallet for cold storage Thanks for taking the time to help me out.  I've created a couple view-only wallets using https://getmonero.org/knowledge-base/user-guides/view_only , and have been coming across some problems:

1) When I actually do create the wallet that has my cold wallet address associated with it, it saves the wallet name as "WalletAddress:ViewKey:NameIWantToGiveIt", instead of just "NameIWantToGiveIt".

2) When I go to refresh the wallet, it works perfectly; but the problem is, is when I save it by typing "save" and/or "exit" it will save,  but then I'll shut it down and turn it back on the next day without being able to access my wallet.  It's not a problem with the password, it's that it says that it won't recognize the name and will generate a new one for me even though I put "WalletAddress:ViewKey:NameIWantToGiveIt" for the name.

3) I don't know if this part is mostly my fault; but sometimes in the past when I created the wallet providing the address and viewkey (it would ask me me again for it after I did   –generate-from-view-key yourAddress:yourViewKey:nameOfTheViewOnlyWallet) the address associated with the wallet would completely change regardless, as if generating another wallet for itself.

If you guys could give me some pointers as to what I might be doing wrong, please let me know. Thanks

I just looked into this, and it seems the method for generating from an address and view key has changed. I am using simplewallet from v0.9.4 and can create a view-only wallet, save it, and then open it again using the following command  (I am showing the Monero Developer's donation address and view key here):

simplewallet --generate-from-view-key monerodevaddr.bin --password xxxx

Simplewallet then prompts you for the address

Standard address: 44AFFq5kSiGBoZ4NMDwYtN18obc8AemS33DBLWs3H7otXft3XjrpDtQGv7SqSsaBYBb98uNbr2VBBEt7f2wfn3RVGQBEP3A

followed by the view key

View key: f359631075708155cc3d92a32b75a7d02a5dcf27756707b47a2b31b21c389501

I then can save and exit

exit

and reopen the wallet

simplewallet --wallet-file monerodevaddr.bin --password xxxx

Note: I did not test this method with refresh after creating the wallet because 1) I don't think that should matter as to whether things are working and 2) the Monero Developer's donation address has a ton of inputs and refreshing would take a long time.

Note 2: This change in creation method seems to have been made sometime between v0.9.1 and v0.9.4, and it is possible that it will change again in the next version (v0.10). As far as I am aware, I do not think the simple command you said above works anymore...


How can I achieve over 1 million hash rates with minergate? When I check minergate top 5 miner list for monero, it says the top miner has 1,976,941 H/s speed whereas I can only get ~270 H/s on CPU.

I also read somewhere that GPU mining for cryptonight algorithm makes it x2 faster or so but not like x100 faster so I don't think it is because of the GPUs that miner may have. (Also it can be some bad information but I'm not sure)

So my question is how to achieve that kind of speed? With what kind of hardware and which miner? I think the answers from the last year are not relevant anymore.

First of all: Please avoid Minergate, since they are stealing some of your hash rate.

You will probably never be able to achieve 1MH/s on Cryptonight with a single machine, but multiple mining rigs or a botnet with dozens of hijacked machines mining into your account. But better avoid that, too.


Tippero usage instructions Is there a Tippero user guide? Where can I find a list of Tippero commands?

Specifically, how can I:

Give a Monero tip to one person on Reddit?
Give a Monero tip to everyone currently active on the #Monero IRC channel?
Check my Monero Tippero balance?
Deposit to, or withdraw from, my Tippero account?

Tippero contains its own instructions, which can be queries with the !help and !commands commands (send a message to the bot with this command). The latter gives you a list of modules and their commands. To view a one liner description of what each command does, try !commands NAME, replaving NAME with the module you want, eg !commands dice.

The canonical tip command is !tip thisnick 1.1, which tips thisnick 1.1 monero, but Reddit also has a more convenient syntax: +2.5 /u/tippero, which will tip the author of the comment you're replying to.

If you're going to use IRC and Reddit, you may want to link your Freenode and Reddit Tippero accounts, so you can use a single balance: see !linking_accounts, which will explain how to do so.

Last, for each of your specific questions:

Tip someone with !tip NICK AMOUNT
Tip everyone in a channel with !rain AMOUNT
See your balance with !balance
Deposit information is available via !deposit (don't forget to use the payment id this gives you), and withdraw with !withdraw ADDRESS


In the beta GUI wallet, what levels of mixin are offered by the sliding Privacy bar? In the GUI wallet, under the "Send" tab, does the sliding bar labelled "Privacy" refer to the level of mixin? If so, what level of mixing is provided by the "Low", Medium" and "High" options?

Yes, the "Privacy" sliding bar allows you to choose the level of mixin.

Mixin levels are: 4,5,6,7,8,9,10,11,12,13,14,15,20,25

The GUI wallet presets represent the following mixin values:
Low = 4, Medium = 8, High = 25.

At the time of writing, the minimum enforced mixin is 2, but the GUI wallet uses 4 as its minimum.


Where does Curve25519's limit occur? While informing myself on the inner-working of Monero, I stumbled on Curve25519.

The CryptoNote White Paper states:

  l: a prime order of the base point; l = 2^252 + 27742317777372353535851937790883648493;
  [...]
  private ec-key is a standard elliptic curve private key: a number a ∈ [1, l − 1];

Another Stack Exchange answer states the following:

  All you need protocol-wise is a private spend key and a private view key, where a private key is just some number smaller than l where l is a prime order of the EC curve basepoint l=2^252 + 27742317777372353535851937790883648493. Anything bigger than that will get wrapped around ie a and a+l are equivalent.

From my understanding this means that a private key a has the same derived public key as private key a+l.

I've however been unable to reproduce the said "wrapping".

Using a very random a=0x1111111111111111111111111111111111111111111111111111111111111111 I calculated a+l=0x2111111111111111111111111111111125f00aefb408ade76923742b6e06e4fe.

I then tried to use a and a+l on llcoins as Hexadecimal Seed, as Private Spend Key or as Private View Key. They never generated the same results.

Does the wrapping occurring on a ,when greater or equal to l, occur at another step? Does it only occur sometimes?

It will get wrapped around because it's later passed through sc_reduce32 function which performs mod l operation on the input.

See below example using silent Matt's big int library which is loaded with llcoins. Easiest to just open the developer tab and type stuff into JS console.

To calculate 2^252 + 27742317777372353535851937790883648493:

l = JSBigInt(2).pow(252).add(JSBigInt.parse("27742317777372353535851937790883648493",10));

To print out the number in base16:

l.toString(16);
"1000000000000000000000000000000014DEF9DEA2F79CD65812631A5CF5D3ED"

That's the l. If you swap byes and feed it as seed to llcoins, you should get 0x0 as seed. Try inputting EDD3F55C1A631258D69CF7A2DEF9DE1400000000000000000000000000000010 (little endian) as seed and you'll get 0000000000000000000000000000000000000000000000000000000000000000 as private key.

Now, we can also do the addition from your example:

a = JSBigInt.parse("0x1111111111111111111111111111111111111111111111111111111111111111");
BigInteger {_d: Array(11), _s: 1}
c = l.add(a);
BigInteger {_d: Array(11), _s: 1}
c.toString(16);
"2111111111111111111111111111111125F00AEFB408ADE76923742B6E06E4FE"

Performing mod l will give you:

c.remainder(l).toString(16);
"1111111111111111111111111111110FC3217326E19743AB8FEADF6B41B3D24"

observe how you don't get the value of a because a itself is bigger than l:

a.remainder(l).toString(16);
"1111111111111111111111111111110FC3217326E19743AB8FEADF6B41B3D24"

so adding l to this will give you the original number:

a.remainder(l).add(l).toString(16);
"1111111111111111111111111111111111111111111111111111111111111111"

If you swap endian of c and feed it as seed to llcoins, you'll get the same remainder but with little endian byte order:

seed=FEE4066E2B742369E7AD08B4EF0AF02511111111111111111111111111111121

privSpend=243d1bb4f6adfeb83a74196e321732fc10111111111111111111111111111101


My wallet won't connect to the daemon, re downloading doesn't help either. Can't reach my funds! The monerod crashes when I click it and the gui version tells me there is no connection daemon

I don't know if solution was found but mine was :
- Delete the folder %programdata%\bitmonero
- Run monerod.exe
- then launch monero-wallet-gui.exe if needed

Hope it helps :)


Genesis transaction explanation? If we decrypt the actual genesis of the XMR, we can get 2 parts :

the pubkey : 9b2e4c0281c0b02e7c53291a94d1d0cbff8883f8024f5142ee494ffbbd088071
the tx : 7767aafcde9be00dcfd098715ebcf7f410daebc582fda69d24a28e9d0bc890d1

So I tried to find this on an explorer, and effectively, this is the first block and first transaction (https://moneroexplorer.com/tx/c88ce9783b4f11190d7b9c17a69c1c52200f9faaee8e98dd07e6811175177139)

But now the question is ... how can you predict the genesis before you start the blockchain.

At first, we don't have any wallet.
So, how can you make a transaction to the wallet "9b2e4c0281c0b02e7c53291a94d1d0cbff8883f8024f5142ee494ffbbd088071" ?
How can you get the transaction id ? How can you predict the wallet address ? Are you supposed to create a wallet before you start the blockchain ? Or maybe this wallet is fake and "locked", and the amount inside is "lost" ?

The genesis block is not predicted. The genesis block is decided upon in advance, and then hard coded as the first block that must appear in the blockchain.

You can see it hard coded in the codebase here:

std::string const GENESIS_TX = "013c01ff0001ffffffffffff03029b2e4c0281c0b02e7c53291a94d1d0cbff8883f8024f5142ee494ffbbd08807121017767aafcde9be00dcfd098715ebcf7f410daebc582fda69d24a28e9d0bc890d1";

(See https://github.com/monero-project/monero/blob/8361d60aef6e17908658128284899e3a11d808d4/src/cryptonote_config.h#L162)

What that hardcoded transaction means is: Create 17.592186044415 XMR out of thin air (that is the base 10 representation of the amount ffffffffffff03 in hex) as a mining reward, and let the recipient of the amount be whoever knows the private key corresponding to the output public key 9b2e4c0281c0b02e7c53291a94d1d0cbff8883f8024f5142ee494ffbbd088071.

There is a transaction public key included in the transaction which would help the recipient's wallet automatically determine that this output was destined for the wallet via the usual Monero mechanisms (the tx public key is combined with the recipient's wallet's private view key and public spend key, and this is cross referenced with the output public key to check if that output is destined for the wallet).

  At first, we don't have any wallet. So, how can you make a transaction to the wallet "9b2e4c0281c0b02e7c53291a94d1d0cbff8883f8024f5142ee494ffbbd088071" ?

Firstly, 9b2e4c0281c0b02e7c53291a94d1d0cbff8883f8024f5142ee494ffbbd088071 is not the destination wallet. It's something called the transaction public key, which is an elliptic curve point which the destination wallet uses to figure out whether the transaction is destined for that destination wallet, and helps the destination wallet figure out how to construct the necessary keys to later spend the funds.

To be able to receive funds, all you need is two private/public key pairs (your private/public spend and view keys), and these can be generated independently. It's just math. To generate the tx public key, you just create a random number r and then determine the tx public key by multiplying r with the ed25519 elliptic curve base point G. To generate the output public key, you combine the recipient's public view and spend keys with r (the specific algebra is Hs(rA)G+B).

  How can you get the transaction id ?

The transaction id is just a hash of the transaction, which can be determined after you manually create the genesis transaction. It can be determined by simply performing a Keccak hash on the hard coded transaction.

  How can you predict the wallet address ?

As mentioned above, you manually create it by creating two public/private key pairs.

  Are you supposed to create a wallet before you start the blockchain ?

You just need to create the two public/private key pairs. As side note, technically you don't actually need to even create wallet private/public key pairs to receive funds. If you know the specific output that is yours, you can spend it directly if you know the output private key (which you could know if you manually created the transaction yourself, but not if someone else created it for you). But wallet addresses and tx public keys are there so that the wallet can detect the incoming funds and mathematically determine the correct output private key without having to be told this information outside of the blockchain.

  Or maybe this wallet is fake and "locked", and the amount inside is "lost" ?

The genesis block was created by thankful_for_today, see https://bitcointalk.org/index.php?topic=563821.0

If thankful_for_today wanted to, they could certainly spend the funds created in that block (as long as thankful_for_today didn't intentionally mangle the output public key so that there is no known key to spend the funds - we can't tell from looking at the blockchain). Perhaps thankful_for_today did spend it - Monero's ring signatures make it impossible to know.


How do multisig wallet seeds work? If I create a 3/3 multisig wallet and then type seed, the seed shown is 528 hex characters.

What does this seed consist of, and does it allow full restoration of that participant's multisig wallet?

528 hex characters is 264 bytes.

The format is:

threshold of signers required - 8 byte uint32
number of total signers - 8 byte uint32
multisig signing secret key of this wallet - 32 byte scalar
public spend key of the overall multisig wallet - 32 byte EC point
secret view key of the overall multisig wallet - 32 byte scalar
public view key of the overall multisig wallet - 32 byte EC point
multisig keys - 3x 32 byte scalars. One of these is your own blinded multisig signing
  secret key, the others are blinded versions of the other signers' multisig
  signing secret keys
multisig signing public key of this wallet - 32 byte EC point

Note that the multisig secret signing keys are blinded as follows:

blinded multisig secret key = hash_to_scalar(multisig secret key || salt)

where salt is a 32 byte sequence starting with the ASCII "Multisig", right-padded with zeros.

Thanks to jtgrassie for the link to the source code where this is written.


How might someone view the balance of a multisig monero address without both its private keys? Is it possible? Would two view keys allow you to at least see what it had received? Would one view key? Not sure how multisig would work with Monero. Perhaps there would only be one view key?

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

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


genesis block with v12 block version I'm trying to start a new genesis with v12 block version.
v1 as is explained in depth here
How can I create a new Monero genesis block?
works without problems.
What info / bytes are needed for v12 different to v1.

"v12" refers to the hard fork version, not the tx version. Given that, and by the mere definition a genesis block is the first block mined, what you're asking makes little sense - compounded by the fact you talk of block versions but are actually referencing the miner tx of a genesis block.
If you are trying to fork Monero with a new chain that starts with v12 functionality, it's not the genesis tx that needs changing, rather a bunch of other code.


Opening Ledger with wallet v0.14.1.0 Boron Butterfly I have a Monero GUI wallet v0.14.0.0 Boron Butterfly whick I open with my Ledger Nano S.

I downloaded Monero GUI v0.14.1.0 Boron Butterfly for Windows 64-bit.

When opening, it says:
"wallet can't be opened: unsupported device application version: 1.2.2  At least 1.3.1 is required."

Can you help please. Thanks.

As the error message says, you need to upgrade your Ledger Monero app to v1.3.1. Thereafter, you should be able to properly use your wallet.


Security concerning private keys on monerowallet rpc on hosted server if taking monero payments My query is about the security - or lack thereof - of private view keys when they are placed on a server (web host) as part of a payment integration system to accept Monero payments from customers. As it says here:

  https://github.com/monero-integrations/monerowp Secret Viewkey (if
  confirmation type is viewkey) - Your private viewkey (No default)
  Monero wallet RPC Host/IP (if confirmation type is monero-wallet-rpc)
  - IP address where the wallet rpc is running. It is highly discouraged to run the wallet anywhere other than the local server! (Default:
  127.0.0.1)

So does this mean that the website hosting company has access to private view keys if the Monero Wallet RPC is on the same server as the website? It means they can see the funds?

I ask because i wonder if you can host the RPC elsewhere, at home for example, but the 'good practice' advice in the help files says that it should be on the same server as website.

I am aware that the funds will be safe on a hard wallet, but what to do if you don't want personnel (server admin and staff) connected to the webhost company to see what should be private info?

What is the Payment Wallet RPC or what does it connect to?  a special node for payments?

Thanks.

The secret view key allows one to see outputs going to the address corresponding to that key. It does not allow spending them. If that secret view key is on a machine, whoever has physical access to that machine can ultimately extract it, if they care enough. Whoever has control over a hypervisor where a VM which contains this key runs can also do, even if they do not have control over the actual hardware. From the above, anyone who has extracted your secret view key can therefore see incoming monero (and usually see when you spend too, since you usually get change back, which is seen by the view key).

The reason is is recommended to run the wallet on the same host is because you can have the wallet listen to the loopback interface (lo), which means it does not listen to anything coming from the outside NIC. Only local connections will succeed. You can however run the wallet server on a machine you control, and enforce SSL usage as well as whitelist the SSL certificate to use. Of course, this does not help as much as you might think since the certificate will be extractable by the hardware/VM provider in the same way they could get the view key previously, and they can make requests to your wallet server as if it was coming from whatever website client you use. You do get an auditable trace of the request, however, so it is objectively better in that respect.


Is there any way to put non AES-NI processors to use for mining? Is there anyway to use non AES-NI processors for mining Monero or is it mostly just a waste of time because the hashrate is so small?

It is possible. You just have to set ./configure --disable-aes-ni when building  the cpu miner.
There is a memory leak when built without aes-ni. So you will have to restart it regularly (for me, that was at least once every 2 days).

With a pretty good core 2 duo, i get ~30 h/s (both core running) for ~100 Watt. So, unless you have a little army of them and free electricity, it is not worth it.


When Monero is worth $10,000 will fees in xmr be the same or lower/higher? Currently (FEB-2021) a monero transaction fee is about .000015 XMR ($0.003 USD). When XMR reaches a higher price will these fees stay the same in XMR terms? If so won't that cause for concern like how ETH and BTC is now with outrageous fees of $5-$50 per transaction? Basically a scalability problem.

When XMR reaches a higher price will these fees stay the same in XMR terms?

Yes, they stay the same in XMR terms. I.e. XMR fee level is not based on any exchange rate.

If so won't that cause for concern like how ETH and BTC is now with outrageous fees of $5-$50 per transaction? Basically a scalability problem.

No. The fee and scalability problem with Bitcoin happens because Bitcoin imposes a block size constraint which limits throughput, causes competition for block space and thus a fee market is present. When usage is high people are competing to get their transactions in the next block and thus pay higher fees. Monero doesn't have this problem and in fact with higher usage fees actually go down (in XMR terms).


Why some coinbase transactions have very long extra field, and some short? Wondering what is the difference between coinbase transactions. For example, this coinbase transaction has short extra field:

https://moneroexplorer.com/tx/0abf00d51d051c0854d7715ceabdc518c07104434a01658a9dc53417a7dbbdf7

016e823f579828d0247e7f4f86deb9189923ca2b97d42bde8e77dfebe24b8217d60208000000025495d62b

On the other hand, this transaction has long extra field:

https://moneroexplorer.com/tx/36f88dc165ac4192dd217472e993fdf566cbc6a93d55ea84f3b092b198ab8737

011387342c514195795e3088503cbac8b1f947db67a567933dc688faf20756f81f021d3951c73f000000004d696e6572476174653030310000000000000000000321003ed59fbae2a8aacb71a9e41639927beaa45e4b50c0d95ef1c8fd640fc74729f9

Why is there a difference in the length, and what is the extra data?

Because miners are free to put whatever they want in there.

For example, if you parse the 2nd as ASCII codes, it can be decoded to:

4,QAy^0P<ºÈ±ùGÛg¥g=ÆúòVø9QÇ?MinerGate001!>Õºâ¨ªËq©ä9{ê¤^KPÀÙ^ñÈýdÇG)ù


concatenate in the monero world I am trying to replicate in python the  calculation of public key derivation, that is: P = H(aR||i)G +B where i is the output index in a transaction.

I got all the operators figured out (using a python ed25519 implementation) except for the concatenation.
How is concatenation (||) defined in Monero? Is it taking the two scalars as strings and calculate their hash? bitwise or? etc...

Thanks

aR is an elliptic curve point, and has a 32 byte compressed representation. i is not a scalar. Scalars, like a would have a 32 byte representation. i however is a varint. Varints are specified in section 1.2 of this document: https://tukaani.org/xz/xz-file-format.txt

Therefore aR||i will usually be 32+1 = 33 bytes of data. The concatenation has no padding, and is simply one byte sequence followed by another.

Also note that although the white paper says P = H(aR||i)G + B, if you look at the Monero source code it's actually P = H(8aR||i)G + B. This is to avoid small subgroup attacks, because it forces the result of 8aR to be in the subgroup of the base point G.


What is the output of a hash so that the PoW is validate I understand the concept of hash, PoW and difficulty, but what I want to know is that in monero, when a block is mined, what is the rule to accept that block as valid and when the difficulty change, what change in the hash of the PoW (to be consider as a valid block)?

A hash is just a number. The hash is valid (in PoW terms) if it meets the current network difficulty. The network difficulty keeps getting adjusted so that the subsequent blocks get found approximately every 2 minutes.

As for determining if a hash meets the current network difficulty:

if B / H >= D then valid

Where B is the base (max) difficulty, 2^256-1, H is the hash and D is the current network difficulty.

Of course, the block being submitted also has to be a valid block (i.e. parses to a Monero block structure, has correct coinbase transaction etc etc).


Need specific instructions on using formula to calculate Monero's current block reward Building my own php-based monero profit calculator for fun.

However, setting a static variable for "block_reward" would be very bad, and become less accurate as time goes by.

I've looked at this thread here:
What is the mining reward equation?

I've also looked at the whitepages here:
https://cryptonote.org/whitepaper.pdf       Page 13 specifically

I'll post their high-level equation first:

To ensure the smoothness of the emission process we use the following
formula for block rewards:
MSupply = 2^64 − 1 atomic units
BaseReward = (MSupply − A) >> 18,
where A is amount of previously generated coins.

Here's the laymen's version of the formula:

The Monero block reward = (M - A) * 2^-20 * 10^-12
Where A = current circulation. (NOTE:Assuming M = total supply)

Using this "laymen's" formula with current supply and circulation as of RIGHT now
Doing this on a scientific calculator

(18,132,000 - 14,952,626) * 2^-20 *10^-12
(3179374) * (0.00000095367431640625) * (0.000000000001)
3.0320873260498046875 * (0.000000000001)
0.0000000000030320873260498046875     // Final Solution

What am I missing? That's clearly NOT the block reward

Current block reward is saying 6.6 XMR
Found on: https://whattomine.com/coins/101-xmr-cryptonight

I went on Freenode IRC #monero-dev and got an answer to Atomic Units

An Atomic Unit, for Monero, = 1e-12 or .000000000001

That's eleven zeros before the 1

Here's the php code I used to calculate this for anyone that would like to use it

//Simple Public Get API
$url = "https://moneroblocks.info/api/get_stats";
// Make Request
$info = file_get_contents($url);
// Digest JSON into a php array (FLAG 2)
$info = json_decode($info,2);

$total_circulation = $info['total_emission'];

// Calclulate total supply, this is taken directly from cryptonote man pages
// https://cryptonote.org/whitepaper.pdf  ATOMIC  UNIT for monero = 1e12
$total_supply = pow(2,64) * 1e-12;
$base_reward = ($total_supply - $total_circulation) >> 20;

$next_step = $base_reward * 1e-12;
// Multiply by 2
$actual_reward = $next_step * 2;

Hope this helps someone!


Why one word is found two times in each seed? Why one word is found two times in each seed?

Is it use as a checksum?

Yes, it's because the last word is a checksum word which will always be picked from one of the words in the mnemonic. See here for more details.

In fact, one word could occur even more than 2 times. For example,

  aces aces aces aces aces aces aces aces aces aces aces aces aces aces
  aces aces aces aces aces aces aces aces aces aces aces,

is a perfectly valid seed, however, you will have a hard time generating it randomly ;) The resulting address is:

47Rz1Ee4GMj3DVyQ56XWLE5ZnffaAj934Sk6fFE7US4CUyHKBKZZNj9cCigdZweGdN1LhsAmx2VvH573AMLdSKj3QBXdg3F

I didn't check if there's any monero there, though.

The words can be repeated because the mnemonic is a way to encode 256-bit numbers. The seed is just a random 256-bit number, and as such, can have repeating digits or sequences or be divisible by some number or powers of that same number.

The mnemonic is a representation of that 256-bit number in base1626 number system, where each word of the dictionary represents a digit. With this system, 24 words are required to represent 256bits of information, and the 25th word is introduced as a checksum, which is additional information not encoded in the actual seed (the 256-bit number).

If we were to count in such a system, once you reach the last word (zoom) of the dictionary, you need to add one more "digit" to continue counting, as you would do when counting 8,9,10 - but here your "9" is "zoom", example:

0 = abbey
1 = abducts
2 = ability
...
1625 = zoom
1626 = abducts abbey
1627 = abducts abducts
1628 = abducts ability

and so on... once you use up all the words for the 2nd "digit", you move on with the first "digit",

3251 = abducts zoom
3252 = ability abbey
3253 = ability abducts
3254 = ability ability
3255 = ability ablaze

and so on... until the first digit reaches zoom, then we add 3rd digit on the next increase:

2645502 = zoom zoom
2645503 = abducts abbey abbey

I think you get the idea by now. So as you can see, any combination of words represents some number, and any number can be represented by a series of words, as long as you have a list of words to use and a methodology to use for converting. In fact, the biggest number you can represent with 24 words (remember, 25-th is the checksum) is

  = 1626^24 - 1,

which is a 78 digit number (base10, what you call a "normal" number), if you were willing to write all the digits.

So, that is why you can have repeating numbers.


Did the Silk Road coins of 110,000 Bitcoins actually moved into Monero XMR during 2018 Sept? There were reports of the Silk Road coins being moved into Monero XMR, which caused the XMR price to go over 20%+ over a 3 day period. Was there any proof of this happening or was it the cause of some other insider news to cause the monero price to move so much?

This did not happen. The FBI confiscated the BTC and later sold it to Tim Draper. Here is the source: https://www.coindesk.com/tim-draper-revealed-silk-road-bitcoin-auction-winner


What is the password for monero.hashvault.pro pool? Hello this is probably a stupid question but.
I set up some xmrig miners with this config:

{
"pools": [
{
"url": "pool.monero.hashvault.pro:5555",
"user" :"xxxxxxmygui-wallet-address",
"pass" : "worker_id",
"keepalive" : "true",
"nicehash" : "false"
}
]
}

I wanted to log in to check statistics on monero.hashvault.pro.

I put my Monero GUI wallet address as login but for the password I have no clue what to enter, I tried "worker_id" but that wasn't correct.

From the instructions:

Password (email field from "pool_password")

What am supposed to enter?

Did I forget to add this setting to my config.json?

Thank you.

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

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

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

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


Can I verify that a "forgotten" subaddress belongs to my wallet? Consider the scenario where I delete my wallet then restore it from the seed phrase. Now all sub-addresses are lost. Then, I recover my sub-addresses by other means (e.g. logs). Can I verify that they actually belong to my wallet, and can I add them back to my wallet to use them again?

When restoring a wallet from seed phrase, you do not lose your subaddresses. This is because subaddresses are deterministically derived from you wallet keys. Therefore there is never a scenario whereby you would need to restore subaddresses "by other means" or " add them back to my wallet". By restoring a wallet, you have all the subaddresses too.

Getting technical, it is also possible to verify if you own a given subaddress. To do this you would need to create all the subaddresses that cover the range of possible indexes of the subaddress you wanted to check for a match. E.g. if you knew your wallet only had 2 accounts and up to 100 subaddresses, you would create the first 100 subaddresses for account 0 and account 1, then one of those will match the address you are checking.


bitmonerod data-dir in a virtualbox shared folder I'm trying to run bitmonerod in a VirtualBox VM with --data-dir pointing to a directory in a shared folder from the host system. I get this error:

If I do the same in the host system, using the same directory in the shared folder, it works. It also works when copying the entire data dir of bitmonerod into the VM (which I want to avoid).
Both host and guest are the same Linux distro (OpenSuSE Leap  42.1). Im running the official 0.9.4 binaries.

I have no clue what is the property of a shared folder that makes lmdb unhappy. It can't be a permission problem as I can read and write to the shared folder from within the VM.

This will not work. VirtualBox shared folders don't support mmap, which is required for LMDB (and BDB).


xmr-stak-cpu on Ubuntu 14.04 compilation issue I'm trying to install xmr-stak-cpu on Ubuntu 14.04 following steps described in the installation TXT file:
https://github.com/fireice-uk/xmr-stak-cpu/blob/master/LINUXCOMPILE.md

But executing make install i'm getting following output:

make install
[  5%] Building C object CMakeFiles/xmr-stak-c.dir/crypto/c_skein.c.o
/usr/bin/c++filt: invalid option -- 'm'
Usage: /usr/bin/c++filt [options] [mangled names]
Options are:
  [-_|--strip-underscore]     Ignore first leading underscore
  [-n|--no-strip-underscore]  Do not ignore a leading underscore (default)
  [-p|--no-params]            Do not display function arguments
  [-i|--no-verbose]           Do not show implementation details (if any)
  [-t|--types]                Also attempt to demangle type encodings
  [-s|--format {none,auto,gnu,lucid,arm,hp,edg,gnu-v3,java,gnat}]
  [@<file>]                   Read extra options from <file>
  [-h|--help]                 Display this information
  [-v|--version]              Show the version information
Demangled names are displayed to stdout.
If a name cannot be demangled it is just echoed to stdout.
If no names are provided on the command line, stdin is read.
make[2]: *** [CMakeFiles/xmr-stak-c.dir/crypto/c_skein.c.o] Error 1
make[1]: *** [CMakeFiles/xmr-stak-c.dir/all] Error 2
make: *** [all] Error 2

cmake . however uses /usr/bin/c++ which was absent at my system and I had to create a sym link: c++ -> /usr/bin/gcc

/usr/bin/gcc --version
gcc (Ubuntu 5.4.1-2ubuntu1~14.04) 5.4.1 20160904

What can be done to install it?

c++ is the canonical "implementation independent" name for the platform's C++ compiler. gcc is the C compiler. g++ would be the C++ compiler. If you don't have g++ installed, then install it first. GCC supports many languages, but C++ may not be installed by default.

Looking at this repository, it seems to be using cmake and not normal makfiles, so once g++ install is done:

git clean -dfx
  cmake .
  make

should build it.


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

Some specific questions:

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

"If configured properly, additional peers can be found through typical p2p peerlist sharing."
What is the proper configuration that achieves this? Does this mean you specify one anonymous peer manually and it will discover the rest?

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

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

Thanks.

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

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

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

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

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

So you see, they have different purposes.

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

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

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

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

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

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

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

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

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

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

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


Benefits to starting out mining at a higher difficulty I have been trying to find out what the benefits are to starting out mining pools at higher difficulties.  I imagine there must be some added benefit to it but I haven't found any real information on it.  Can anyone shed some light on this or point me towards some documentation on it?

A high pool difficulty is for high power mining equipment. What this does is lowers the bandwidth amount for both the pool and the miner. Because the difficulty is higher, the miner will find valid shares less frequently, resulting in less data transmitted from the miner to the pool.

Lower difficulties are for lower powered mining equipment, so that the miner has a chance to submit some valid shares before the next network block is found, and it has to start the hashing process over again for the new block. If no shares are submitted by a miner between blocks, that miner will get no credit for the mined block. This is why pools have several different difficulty levels.

Typically pool payouts are weighted on the number of shares per miner, while those shares are weighted on the difficulty setting, so a low difficulty share is worth less than a high difficulty share.


What installer to choose for 64-bit GUI? I want to install 64-bit Monero GUI, but the Monero downloads page shows both a "Windows, 64-bit" and "Windows, 64-bit Installer" option.

What is the difference on these two options?

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


Why are empty blocks not all the same size? Why are empty blocks not all the same size?
On Monero Blocks I see a different size for blocks with zero transactions.

1157855 block size 210
1157856 block size 254

Usually, empty blocks can vary within a couple bytes, as monero amounts (present in the coinbase transaction even in "empty" blocks) are stored in a varying length encoding.

1157856, however, is a lot larger because it's got extra info in the extra field. It's probably been mined by MinerGate, who tends to add their own private information in blocks.


Monero April 6 Hardfork guide? I mine Monero, and use the GUI wallet. I know updating the miner should be pretty straight forward, but the wallet? Will I keep the old blockchain? Where will I find the update? Should I move my balance out of the wallet? I know so many questions...maybe someone could post a guide or something? Thanks in advance.

If you want to use ready made binaries, these will be available soon (in the next few days) on getmonero.org.

You will not need to replace your blockchain, nor move your monero. Just start using the new version when it's out.


Who is behind monero and how does is compare to other major crypto currencies? Who is leading Monero? What are the process in place to avoid an hostile entity to take control of the network/the development/the security of the system? How resilience is achieved?

How does it compare to Bitcoin or Ethereum (for the latter, it is at least know that a company is behind it, with clear profitability goal and state(s) specific state laws and requests to comply with  - which in light of recent Yahoo events is at least bothering regarding privacy and back doors).

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

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

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


Best method of speeding up Monero downloading / syncing of the xmr blockchain? My node is 8000 blocks behind, and its taking quite a while to sync. Is there a faster way to sync / download the Monero blockchain?

You can download the blockchain and then import it using the instructions here:

How to synchronize the GUI wallet using the blockchain bootstrap


How to perform a simple verification of a Monero address with a regular expression? For people that want to do a simple verification of a Monero address to ensure it has been entered correctly, what are some methods that can be employed?

Here is a simple regular expression and javascript code snippet that can be used to confirm a Monero address has been entered correctly.

Regular expression:

4[0-9AB][<insert-all-base-58-characters-here>]{93}

In Javascript:

addr_str.match(/4[0-9AB][123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz]{93}/);

Credit goes to /u/binaryfate for the useful info.


How to install Monero on Debian Linux? Debian is one of the top server Linux OSes, and has many popular derivatives including Ubuntu, Linux Mint, Pop!_OS and others. What's the easiest way to install the Monero GUI on it?

Whonix has added Monero to its APT repository (you can see that here) so the process is now pretty straightforward:

Download and add the Whonix signing key:

wget https://www.whonix.org/patrick.asc
sudo apt-key --keyring /etc/apt/trusted.gpg.d/whonix.gpg add ~/patrick.asc

Add Whonix's APT repository:

echo "deb https://deb.whonix.org buster main contrib non-free" | sudo tee /etc/apt/sources.list.d/whonix.list

Update your package lists:

sudo apt-get update

Install the Monero GUI:

sudo apt-get install monero-gui


How to achieve uniform hash rate I am trying to learn about mining and am using xmr-stak-cpu on Ubuntu 17.10 to mine with an AMD a10 6800k processor. I haven't seen a single time my miner reporting 100H/s but the stats of my miner on the pool say I have been at that rate for some time. How can I reach this hash rate more often?

Also I tried to use iGPU to mine but the xmr stak miner does not identify it, is it a driver problem since ubuntu 17.10 does not have proprietary drivers.

Pools do not know your hash rate, they can only estimate it based on the shares you submit. Since finding those shares is in inherently random process, you will sometimes have lucky breaks, and sometimes long dry spells. This will translate to a randomly changing hash rate being reported by the pool. Your miner knows the rate at which it is hashing, so reports the actual rate.


Is it possible to solo-mine on a non-public node? I am wondering whether it is possible to solo-mine, with a non-public node. I have no port-forwarding configured at this stage, so when I display the monerod status, it doesn't show any outgoing connections obviously:

Height: 1173753/1173753 (100.0%) on mainnet, mining at 24 H/s, net hash 24.21 MH/s, v3, up to date, 8+0 connections

It looks like it's technically possible to start the mining, but it may not make sense … I suppose that when a block is found (ignoring the very low hash rate), it cannot propagate this to the network, right?

Those outgoing connections are also 2-way. All connections are 2-way. Having an incoming means that your node can listen for others that want to connect. With no incoming, your node can still connect to other nodes.

So long story short, you can solo mine on a non-public node.


How to calculate Monero addresses for different account numbers? Monero accounts and subaddresses are conceptually well illustrated at https://medium.com/@anhdres/how-moneros-accounts-and-subaddresses-work-in-monerujo-4fa7df0a58e4.

And page 125 of Mastering Monero does a good job of describing how subaddresses associated with account #0 are calculated.

My question is, how are the deterministic Monero public spend and view keys calculated for accounts other than account #0?

Each account is simply another subaddress. Therefore the math is identical to the usual subaddresses calculation - it is still represented by an i index in:

PSi = Hs(pV0 || i) G + PS0

(using Mastering Monero's notation).

However, it's worth noting that the calculation for the subaddress secret key is actually m = Hs(a || index_major || index_minor), and for its public key, M = mG, where index_major is the account index and index_minor is the subaddress index. Thus i is the concatenation of index_major || index_minor.

Therefore the Master Monero example is a little misleading. The subaddress, regardless of which account it is in, is actually calculated like:

PSij = Hs(pV0 || j || i) G + PS0

Or in the common notation used in the code and elsewhere:

m = Hs(a || index_major || index_minor)
M = mG
D = M + B

D being your public view and spend keys for account # subaddress #.

Sources: device_default.cpp#L144 and device_default.cpp#L198


Ways to hold your keys in memory? What are some methods that can be used to hold your private keys in memory?

Memorizing 25 words is rather difficult.

Great suggestion by PyRulez. Making up a song with the words is another way to memorise them. Of course, this doesn't mean you should only have the song, you need to have a physical backup too just in case!


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

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

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

Here's a quick list:

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


How can I receive monero on my openalias address? I've amended my domain records by following this procedure and my new OpenAlias address is xmr.mysite.com..

How could someone transfer Moneroj to me using that alias? Can it be done using monero-wallet-cli?

Type:

transfer xmr.mysite.com 0.50

You will get a prompt asking you to confirm the full address and show a DNSSEC validation notice. If it is okay, enter Y


Is Monero really decentralized, if the dev team can easily change the POW algorithm to fight off ASICs so easily? With the recent ASICs on the scene as of 2019-Jan, someone managed to create ASICs again for monero and they're able to attain over 50%+ of the network. The monero core devs scheduled a fork only a month after noticing this. But from my understanding I thought the longest chain wins? If the core devs can easily fork the code like this without community feedback, how is this decentralized? It seems that the core devs have a lot of power over what happens in the monero ecosystem regardless of what miners or users say.

So what makes a cyptocurrency like monero "decentralized"?

Centralization is a continuum. Actions and circumstances move a particular system along that continuum.

There are several points which are topical here:

Monero development is made by a smallish number of people (more centralized)
Anybody with skills is free to join Monero development (less centralized)
A single party being able to dictate what gets mined is extremely centralized
Miners choose what code they run, regardless of what Monero developers do (less centralized)
The Monero community previously backed a stance of forking to prevent hash rate monopoly (less centralized)
Hardware with much higher efficiency than usual in the hands of very few parties is a very large centralization force

So when you consider this, you can deduce that, in this particular case, forking makes Monero less centralized than not forking.

Now, Monero is less decentralized that Bitcoin, which has more developers, and where the current mining distribution seems less concentrated. But more decentralized than many others cryptocurrencies.

I think one very important point that many people are missing is that of "but the Monero developers change the code, that's centralized". This is completely missing the point that Monero developers come and go, and that anyone is free to be part of this group. Indeed, a few people who have gone include NoodleDoodle (an original core team member), the late Warptangent, or tewinget. A few people who joined the developer team include moneromooo, hyc, or stoffu. Some are in both groups. What makes it seem centralized is that the current set of people who develop Monero are seen as a static "Monero developers" group, though this group is not static in the first place, it is just a term for whoever happens to be developing Monero at the time (many of these people being long term Monero developers, but not all).

Additionally, this was not fully without community feedback. While the original discussion was made privately to avoid tipping off those suspected ASIC operators early, public discussion was had afterwards to get to a consensus on what to release when.

As for your particular point about the longest chain: the rule is the longest valid chain wins. Once the fork happens, the chained mined by miners using the new code will not be valid anymore by the rules used by miners not using that new code, and vice versa.

tl;dr: That change in rules was made to help decentralization, and I believe it clearly does if you consider the points above.


Started monerod 0.10.1 on an AWS EC2 t2.micro instance, why does it sync so slowly? I started monerod on an AWS EC2 instance of type t2.micro. This means it has 1GB of RAM, which should be enough from what I've read in various places.
It is syncing (from scratch) since two days already, and arrived at roughly 60 percent of the block height only so far.

CPU usage is below 1 percent, but memory above 700 MB, so I guess it is swapping a lot.

Do I have to set some specific parameters for runnning better on machines with little memory?

EDIT: I should add that it's an AWS instance from the free tier, if that makes any difference.

I now found the reason, and it perfectly makes sense (took me a while to realize though, being a first time AWS user).

My instance is running on an SSD (more specifically, the volume type is called gp2), but of course I have to share the hardware with a lot of other users, so Amazon limits the IOPS. Currently you get 3 IOPS per GB as baseline performance (but at least 100 IOPS for small volumes), and you're allowed to burst up to 3000 IOPS as long as you have what they call credits. Initially you get 5.4 million credits, which allows you to burst at 3000 IOPS for 30 minutes. After that you fall back to baseline performance, and during times when you don't use the volume your credits are filled up again at the baseline rate. More details here: Amazon EBS volume types

This matches the behaviour that I observed: Synching started out quite fast, but became incredibly slow later. Based on the above, it must have slowed down after around 30 minutes, which wasn't enough to sync the whole blockchain from scratch. Hence, when running on such an instance, it might make sense to download the blockchain from the monero website.


Gui never updates. Data.mdb will not sync. Need handholding guide. Please help The GUI Wallet will download blocks from node.moneroworld.com but I see no blockchain on my HDD.  I tried monerod.exe and get the following:

sync_info
Height: 1, target: 1 (100%)
Downloading at 0 kB/s
2 peers
212.83.175.67:18080       0000000000000000  0  0 kB/s, 0 blocks / 0 MB queued
163.172.182.165:18080     0000000000000000  0  0 kB/s, 0 blocks / 0 MB queued
0 spans, 0 MB

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

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


How to calculate exact Monero transaction fee? I assume that transaction fee is deducted from the transaction amount, i.e. if Alice sends Bob 10 XMR, then Bob will receive (10 - tx_fee) ~ 9.x XMR

I don't know how precise https://www.monero.how/monero-transaction-fee-calculator is, but from looking at it and API docs it seems that a to calculate transaction cost I will need to multiply result of the get_fee_estimate Wallet RPC call to the transaction size.

As far as I understand in order to do that I will need:

base transaction size
number of inputs and size overhead in kb per each input
number of outputs and size overhead in kb per each input
number of rings and size overhead in kb per each ring
dynamic fee per kb

as a bare minimum. There is also a 13 kb boundary(whatever that means) and maybe other variables in that equation.
Then, if my assumption is correct, it will not be a final amount because, tx + tx_fee essentials means new transaction, for which a bigger fee will be applied.

Can somebody please help to figure out:

What exactly is needed to calculate transaction fee and how to obtain that data (preferably via Daemon/Wallet RPC calls)
How to calculate transaction fee?
How to get as close as possible to the exact final amount, i.e. being able to answer how much Alice should transfer to the Bob so Bob gets N XMR? Three digits after decimal point accuracy will be good and five will be perfect!

This question arose out of real need and not curiosity so I will really appreciate if answers will be as practical as possible.

The fee calculator that you have linked gives you the exact formula, with one exception. Every transaction contains a list of "vins", meaning a list of varint offsets that reference the inputs used in the ring signature.

Depending on the spacing of the inputs that are randomly chosen as ring decoys, the length of the vin list will vary a little.

In practice though, this won't matter, because of the "KB boundary". In Monero, the size of a transaction is rounded up to the nearest KB. The fee then applies to the rounded up KB amount. Therefore a little bit of uncertainty about the vin list will mostly not affect the final fee, since you'd have to be unlucky to find that the variation in transaction size will leave you just over or just under the KB boundary.


Is there any evidence of Bitcoin being "Tainted"? Monero claims to be fungible, meaning every XMR is worth the same as another XMR. But I've also people say this isn't true about Bitcoin - and that Bitcoin can be tainted.

Is there any evidence of some Bitcoin being valued at a different price, or any evidence of some Bitcoin being treated differently based on it's past?

A few examples of Tainted/Clean Bitcoins come to mind:
Binance blocking a mixed BTC deposit: https://blockonomi.com/binance-blocks-bitcoin-withdrawal-wasabi-wallet/
Bitcoins requiring a history audit: https://redd.it/8tzh7w
Bitcoin node dropping transactions from BTC used in gambling: https://bugs.gentoo.org/524512
Dirty BTC on the Bisq market: https://bisq.community/t/dirty-btc-coins-on-the-xmr-market/7798
Chinese police freezing bank accounts that traded tainted BTC on OTC market: https://www.coindesk.com/china-police-freeze-otc-traders-bank-accounts-tainted-crypto
FBI document mentions DNM users discussing how to "clean" "dirty" BTC: https://ia803206.us.archive.org/23/items/dark-web-files-from-blueleaks/200309%20LES%20FBI%20EIR%20-%20Darknet%20Market%20Actors%20Likely%20Convert%20Illicit%20Bitcoin%20to%20Monero%20Using%20MorphToken%20Cryptocurrency%20Exchange%2C%20Impeding%20Law%20Enforcement%20Tracing%20Efforts.pdf


Transfer stuck for 2 days with "Unconfirmed incoming transaction found in the txpool" message. Why and what can I do? I withdrew some XMR from an exchange two days ago to test the transfer on my new own linux wallet that I run with the CLI. The daemon is running, in sync, and has incoming and outcoming connections.

I generated an integrated address to receive the XMR amount. Using the show_transfers command, I can see the incoming transaction with the corresponding payment id and amount. However it's stucked there for 2 days now and my balance is 0, and when I check the transaction the following message is displayed: "Unconfirmed incoming transaction found in the txpool".

I don't understand how it can just be in the transaction pool for two days without being confirmed and I don't know what to do to get my coins since everything seems to be running fine.

Edit: I'm using v0.13.0.2 release, the exchange is Kraken, and the transaction id shows up on xmrchain.net with 1533 confirmations.

The solution was to use rescan_bc then save_bc once completed.


Is there a network protocol specification or description outside the source code? Obviously the network protocol is specified in the Monero source code in c++, but I was wondering if a more generic document exists that could be useful for implementing a program in another language that interacts directly with nodes on the network. Something along the lines of this, perhaps:

https://en.bitcoin.it/wiki/Protocol_documentation

Or this:

https://bitcoin.org/en/developer-reference#block-chain

I realize both those documents explicitly state that they are NOT specifications, merely descriptions of the protocol as implemented the reference client, but I'm still curious if something like this exists for Monero/Bytecoin.

No, but it's on the list of things we have to do. At this juncture it would be wasted on Monero, but once / if we switch the wire protocol to something standardised like ZMTP then it will be nearly trivial to do.


How is the block hash encoded? How to compute block difficulty from a hash of that block?
In Bitcoin, I can see that block hash starts with a lot of zeros, but in Monero I don't understand how uniqueness of new block in represented in the hash value.

I've read the specification for Cryptonote:
  https://cryptonote.org/cns/cns003.txt
and it doesn't seem to be in 'varint' representation.

I wasn't able to find anything on this. I've been through all the questions on this stackexchange and all articles on monerobase.com.

Thanks a lot!

You cannot compute a block's difficulty from its hash. The hash is a Keccak hash.

A different hash using Cryptonight is used for PoW purposes, but this isn't the block hash. It is often called the PoW hash, or just PoW. It uses a similar system to Bitcoin where the hash as an integer must be below some treshold based on difficulty. This hash is run on the "hashing blob" of the block, which is basically the header plus the merkle root of the transactions. So in order to compute the difficulty, you have to have the block hashing blob itself.

This PoW hash is visible to casual users when a reorg happens. You see messages such as:

2017-08-25 04:28:11.472 [P2P6]  INFO    global  src/cryptonote_core/blockchain.cpp:1411 ###### REORGANIZE on height: 1384066 of 1384066 with cum_difficulty 3031277306080642
 alternative blockchain size: 2 with cum_difficulty 3031295878143490
2017-08-25 04:28:11.846 [P2P6]  INFO    global  src/cryptonote_core/blockchain.cpp:1422 ----- BLOCK ADDED AS ALTERNATIVE ON HEIGHT 1384066
id: <6df10afb911800584d13c9016280737eb9cac5b0fa7dc72ab4aa7919153af4ec>
PoW:    <24b75b4f1b6e61341e294efb25da9bd427667ac555f24b040457100b00000000>
difficulty: 18661398539

Note how the PoW above is a small number (all the zeroes at the end).


How do you setup a node to communicate with other nodes only over an anonymous network? BACKGROUND:
My understanding is that at some point in the future i2p will be integrated into monero, so that it is trivial to launch the monerod daemon in such a way that it only communicates with other monero nodes exclusively over the i2p network (with the possible exception of the initial block download which would be done in the clear so as not to burden the anonymous network).  There are several benefits to doing so, for example: 1) anonymous networks like Tor and i2p generally play nicely with home router firewalls, making it possible to receive traffic from other nodes without explicitly punching a hole in the firewall and 2) In countries where monero might be frowned upon, it will be harder to determine which citizens are actually running monero nodes and 3) Right now, when you connect to your node with your wallet and create a tx to broadcast it, the other nodes receiving the tx see the ip address of your node, and until Dandelion is added, there's a lot of info that can be gleaned from that. (I'm guessing this is even more of an issue if you're operating from behind a firewall and have no inbound connections, which I presume means that the only txs coming out of your node are your own.)

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

I am aware that you can connect your wallet via Tor or i2p to a remote node, but there are a lot of reasons with monero that it is better to run your own local node. So, let's say you have monerod running on your home computer (the same computer as your monero client), and it has its own copy of the full blockchain. How to get that node to interact with other nodes anonymously?

I have read the ANONYMITY_NETWORKS.md document multiple times. It says that the main mechanism for sending tx information anonymously between your node and other nodes is to use the --tx-proxy flag to direct the transactions through your i2p or Tor service running on your computer (in my case, I already have Tor running, so I've been using that). But then, it also says that if you do that, you need to manually --add-peer other onion nodes, presumably because your node has no way to discover an initial onion node to connect to. Once you connect to one, it sounds like you will be informed of others that exist and have specified that they permit anonymous inbound connections. The document provides no list of onion nodes to begin by connecting to.

So, I searched the web and only came up with a couple onion monero nodes: xmr.to and moneroworld, but adding them as peers did not actually work. I asked about this at Having trouble with tx-proxy and was told that they aren't full nodes communicating over Tor for the p2p traffic, they simply have a JSON RPC port that you can connect a wallet to remotely over Tor.  Furthermore, I was told that at some point in the future, there will be some seed nodes that serve this purpose of being a reliable thing you connect to in order to discover the other peers that accept anonymous inbound connections, but that this does not currently exist.

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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


Accounts got deleted from the wallet I have a wallet with more than 10,000 accounts in it. I have tried to send some amount from one address to another address within the wallet but the amount sits in the sender's ledger balance for a long time so I ran rescan_bc from the wallet-cli. after rescan I can see only 1717 accounts in my wallet the rest of the accounts got deleted from my wallet. I try restore the wallet using the seed but it didn't help. Can anyone please help.

Accounts are never "deleted". The wallet does, however, need to precompute some elliptic curve points for all possible accounts and subaddresses that it will search for incoming funds at. By default, the wallet will not look ahead more than 50 accounts at a time, and will not look ahead more than 200 subaddresses at a time, unless it sees activity at those subaddresses.

You can start the monero-cli-wallet with the option --subaddress-lookahead MAJOR:MINOR where MAJOR is the number of accounts to look ahead, and MINOR is the number of subaddresses to look ahead.

I assume that you misspoke when you said that you had 10,000 accounts, and meant that you had 10,000 subaddresses all within the same account. Therefore, use the option --subaddress-lookahead 50:10000 and then type rescan_bc when you're inside the wallet.

Note that looking ahead 50:10000 means precomputing 500,000 elliptic curve points, because 10,000 subaddresses will be precomputed for each of the 50 accounts. Therefore, expect the operation to start the wallet to take a few minutes.


When will the mandatory minimum mixin be increased? Currently a minimum mixin of 2 is mandatory.  It is my understanding that the mandatory minimum mixin will be increased to 4 at some point.  When will that happen?

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

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


How function bytes_to_words() works? Here are codes in function bytes_to_words():

w[0] = SWAP32LE(*(const uint32_t*)(src + (i * 4)));
w[1] = w[0] % word_list_length;
...
words += word_list[w[1]];

Then I try a case whose mnemonics are:

gesture mouth bids aglow tudor bawled insult listen jewels sugar calamity alley obvious sovereign jubilee legion oyster gumball using payment gumball giving sedan splendid giving

And the Seed should be:

688b988f7de513383daa61f282807fe5aabe71a639aa58b9cb6beab6f5f80a0c

I'd like to generate first mnemonics "gesture" with seed above so I calculate 688b988f mod 1626 and get 1441 which is not right index of wordlist...

Is there anything wrong with the process?

Example, taking your seed number:

688b988f7de513383daa61f282807fe5aabe71a639aa58b9cb6beab6f5f80a0c

Then byte swapped (and split):

8f988b68 3813e57d f261aa3d e57f8082 a671beaa b958aa39 b6ea6bcb 0c0af8f5

The first 4 bytes are:

8f988b68

Which as decimal is:

2409139048

Then:

2409139048 mod 1626 = 538 = words[538] = gesture

Which (following on from this question), is the first of the 3 words (gesture, mouth, bids), generated from the 4 bytes 8f988b68.


Monero block explorer, xmrblocks, build failing I am trying to build the onion Monero blockchain explorer. The build got through to 100% but then fails:

Scanning dependencies of target xmrblocks
[ 95%] Building CXX object CMakeFiles/xmrblocks.dir/main.cpp.o
[100%] Linking CXX executable xmrblocks
/usr/bin/ld: cannot find -lcurl
collect2: error: ld returned 1 exit status
CMakeFiles/xmrblocks.dir/build.make:133: recipe for target 'xmrblocks' failed
make[2]: *** [xmrblocks] Error 1
CMakeFiles/Makefile2:69: recipe for target 'CMakeFiles/xmrblocks.dir/all' failed
make[1]: *** [CMakeFiles/xmrblocks.dir/all] Error 2
Makefile:83: recipe for target 'all' failed
make: *** [all] Error 2

Can anyone help? Thanks in Advance.

The error, at the library linking phase, is stating it cannot find libcurl:

/usr/bin/ld: cannot find -lcurl

Install that and do a rebuild.

I would also double check you have any other dependencies installed before rebuilding.

To quote the README section on how to build:

# first install monero dependecines
sudo apt update

sudo apt install git build-essential cmake libboost-all-dev miniupnpc libunbound-dev graphviz doxygen libunwind8-dev pkg-config libssl-dev libcurl4-openssl-dev libgtest-dev libreadline-dev libzmq3-dev libsodium-dev libhidapi-dev libhidapi-libusb0


How can i specify in mining to only use 75% of my CPU power? I have seen when i mine Monero in pc, the cpu utilized goes to 95% to 100% most of the time, i want to keep it to 75 to 80%, what can i do?  will it work by specifying the threads? I have a 4 core pc.

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


How to increase monero node connectivity? I have a server in Germany with a monero node running.

1) I want my node to be informed about the appearance of a new block as faster as possible.

2) I also want other nodes to be quickly informed about my mined block.

What are the recommendations to achieve the best results for these two tasks?

My attemps:

I opened the port 18080 so that my node accepts incoming connections
from other nodes.
I increased the limit of out-peers to 512.
I
increased the limit of in-peers to 1024.
I added public nodes found
on the internet through the parameter add-priority-node.

As a result, I got such a config file:

add-priority-node=opennode.xmr-tw.org:18080
add-priority-node=node.moneroworld.com:18080
add-priority-node=node.xmrbackb.one:18080
add-priority-node=uwillrunanodesoon.moneroworld.com:18080
add-priority-node=node.xmr.to:18080
add-priority-node=nodes.hashvault.pro:18080
add-priority-node=node.supportxmr.com:18080
out-peers=512
in-peers=1024

I got the following results:

incoming_connections_count - 35
outgoing_connections_count - 511

I think I need to increase the number of incoming connections. But I can’t understand how this can be done.

Some suggestions...

Relying on those publicly known/advertised nodes is probably a bad idea to start with. Lots of people use those as remote nodes for their wallets for example, so I'd expect the operators make sensible use of the limit-rate-... options.

Which brings me to the next point, what limit settings are you using? You should set these according to your available bandwidth and the amount of peers you plan to connect with.

Also, don't expect that just because you started with allowing an inbound of 1024 your node will somehow instantly have 1024 connections - it could take some period to fill that many.

Lastly, and perhaps most importantly, if you're not going to run your own set of geographically distributed nodes, thus want to have fast reliable connections to other people's nodes, you are going to want to write a script to ping and/or read the data rates as reported by print_cn for the peers your node finds and kick any that are particularly slow.


Failure when using XMR Stak CPU Miner on Linux I recently set up XMR-Stak-CPU Miner on my Linux system, and, as listed as a common occurrence in the README (located here), the program failed with the "MEMORY ALLOC FAILED: mmap failed" exit code. I performed the steps required to fix the error as recommended in the README (without logging off and back on as is necessary for changes to take effect), and the program began to work. Later on, after logging off and logging back in, I noticed the miner would once again not start and gave me the same "MEMORY ALLOC FAILED" error in spite of me already performing the fix.

I have no idea what could be causing the program to fail after successfully working for a full day without problem. I have tried changing the /etc/security/limits.conf file back to the original without success.

Any and all suggestions are welcome!

Thanks!

It seems (after some troubleshooting and a few direct messages to the author of XMR-Stak-CPU, /u/fireice_uk on reddit) that I've found the solution:

As it turns out, the sudo sysctl -w vm.nr_hugepages=128 command that must be run to fix the "MEMORY ALLOC FAILURE" error must be run every boot.

Hope this helps someone!