How can I mine Monero on a cloud service? Canonical question on cloud mining: Is there any way by which I can mine Monero on Azure Cloud Services, or Amazon Web Services, or Digital Ocean? How? Does it pay off?

I have tried mining on AWS, Azure and Google Cloud so trust me when I say you might never break even. I used their 30 days trial to setup mining using minergate cli mining client, which is easy to setup. To setup, use the following command;

wget https://minergate.com/download/deb-cli
mv deb-cli minergate-cli-release.deb
chmod u+x minergate-cli-release.deb
sudo apt install libpcre16 ./minergate-cli-release.deb && sudo apt-get install -f
minergate-cli --user xxxx@yyy.com --xmr 1

The last command (minergate-cli -user xxxx@yyy.com –xmr 1) starts mining. xxxx@yyy.com is your registered email on minergate.
-xmr is the currency to mine (Monero) while 1 is the number of CPU cores to use, if ommitted it will use all available cores.

It might be better for you to use screen command to run the mining instruction so that it does not stop when your ssh session closes.

LESSONS LEARNT

Google frown at mining with their 30 days trial cloud server. I am
not sure if it is allowed with the paid version
None of the providers proof profitable. The average Hashpower of
most of the servers is around 30-40H/s. AWS even drops to 3-5H/s at times. You might never be able to break even.


What does this mean: ./monero-wallet-gui: /usr/lib/x86_64-linux-gnu/libstdc++.so.6: version `CXXABI_1.3.9' not found (required by ./monero-wallet-gui) When I try to run the GUI, I get these errors:

./monero-wallet-gui: /usr/lib/x86_64-linux-gnu/libstdc++.so.6: version `CXXABI_1.3.9' not found (required by ./monero-wallet-gui)
./monero-wallet-gui: /usr/lib/x86_64-linux-gnu/libstdc++.so.6: version `GLIBCXX_3.4.21' not found (required by ./monero-wallet-gui)

What are these .so.6 files?

Those errors mean that you are trying to run a binary which was not built for the same system libraries you are currently running. That is, monero-wallet-gui was built against versions of libstdc++ (the C++ standard library) and glibc (the GNU C library) which are not compatible with the ones you have on your system.

Your options are to either wait for the next release of the GUI binaries, which will be built to be compatible with a wider variety of machines, or to build the GUI yourself, on that machine.

those .so.6 files are shared libraries. The ".so" suffix is traditionally used for them, and is short for "shared object". The .6 is a version number, signalling the 6 version of the library with incompatible changes. Here, you do not have to care about those versions, since you likely won't try to build compatible libs.


show_transfers fields I wanted to test the monero cli wallet to make transfers using a subaddress instead of the primary address because I read that this will make the transfer with an encrypted payment ID and is thus a more anonymous option.

So I made a transfer from my sub-address to my primary address just to try out what would happen. I used a small quantity. I'm trying to understand what happened by investigating the output of the show_transfers command.

However, I cannot make sense of what it means. In addition to my sub-address there is another field, that looks like an address, which I do not recognize. It is not of my own.

Could someone explain the output of "show_transfers" to me so that I can be sure I understand what I'm getting? Or can you refer me to where I can learn about the information provided when looking up transfers? Thank you!

I copied an example below, with changes in numbers for anonymity. What does each field mean?

1020393    out        -       2020-05-01 01:01:52       0.000000000000 f7c031c53cc0aa2f2e021ff44a8feadd462f2002feee6a09d254288b50f53ccf 0000000000000000 0.000101530000 894HLgLpdQSAn2j29EMcZfQ3DwaT5RkncFmRHF2GvuSDgxa2tALcL22MMXtoo5Vr2eLhxqRH5UK2X4oV7J3cPWAyTQJxCA8:0.100000000000 0 -

help show_transfers documents all the fields.

help show_transfers
Command usage:
  show_transfers [in|out|pending|failed|pool|coinbase] [index=[,,...]] [ []]

Command description:
  Show the incoming/outgoing transfers within an optional height range.

Output format:
  In or Coinbase:    Block Number, "block"|"in",              Time, Amount,  Transaction Hash, Payment ID, Subaddress Index,                     "-", Note
  Out:               Block Number, "out",                     Time, Amount*, Transaction Hash, Payment ID, Fee, Destinations, Input addresses**, "-", Note
  Pool:                            "pool", "in",              Time, Amount,  Transaction Hash, Payment Id, Subaddress Index,                     "-", Note, Double Spend Note
  Pending or Failed:               "failed"|"pending", "out", Time, Amount*, Transaction Hash, Payment ID, Fee, Input addresses**,               "-", Note

  * Excluding change and fee.
  ** Set of address indices used as inputs in this transfer.

As you are showing the output for an "out", the fields are:

Block Number, "out", Time, Amount, Transaction Hash, Payment ID, Fee, Destinations, Input addresses, "-", Note

Also note, sending from a primary address, a subaddress  or an integrated address are all equally anonymous.


How can I distinguish between transactions (send vs. receive)? How can I distinguish between the transactions I sent and those that came to me?
If I decrypt the outputs using my view key and address in the amount field, I get balance / tx amount. But other fields are equal.
For example (using https://xmr.llcoins.net/checktx.html),
tx sent by me:

This address doesn't own output 0 with pubkey: c9cab9f8d53eba51f00640d19ea4215632c1b94ed3df78cbc91fbe9bedd1dac8 for amount: Confidential
This address owns output        1 with pubkey: 9ae1f1843fa68489d532b9b77c6073a8a79fb4f9c3ba348ca42eed8f46290a89 for amount: 0.04322344

Total received: 0.04322344

If decrypted with the recipient address:

This address owns output        0 with pubkey: c9cab9f8d53eba51f00640d19ea4215632c1b94ed3df78cbc91fbe9bedd1dac8 for amount: 0.0001
This address doesn't own output 1 with pubkey: 9ae1f1843fa68489d532b9b77c6073a8a79fb4f9c3ba348ca42eed8f46290a89 for amount: Confidential

Total received: 0.0001

If a transaction includes a key image in a ring which corresponds to one of the outputs you own, then it is a transaction you sent. If no key image in a tx corresponds, then it is not a transaction you sent. This holds regardless of whether any output is sent to your address. Usually, when you send money, there will be a change output back to you, but not always.


Win10 64-bit - Wallet not restored after upgrade to 0.11.0 Hydra GUI I've upgraded the wallet on my Win10 64-bit PC from 0.10.3.1. Beta 2 to the 0.11.0 Hydra release. It hung up at 3442 blocks to go for a long time, then finished the download.

However, the $XMR I had in my account went to zero, and $XMR I've tried to transfer in from my Bittrex account didn't arrive.

Any ideas how I can rectify this? Thanks! Do I have to just delete everything from my PC and start again, backing up using my private key?

Restored two wallets associated with the GUI on my PC. $XMR was in the second. Upgrade to 0.11.0 seemed to have defaulted a previously unused wallet.


Is it possible to create a Monero miner in Python? I would like to create a Python based Monero miner. I know that using Python for mining will likely be slow, but this is just for experimental purposes. Thanks.

It is certainly possible to make a miner using Python. There are several ways this can be accomplished and depends on what you want to achieve.

At it's bare minimum you would need to have the hashing algorithm, cn_slow_hash, implemented in Python. An example library that exposes this is here. The rest will boil down to what kind of miner you want to create. You could create a stratum based miner to work with a pool or you could create a solo miner talking directly with a Monero node via it's RPC interface.

I suggest first learning about the actual process of mining and then look at the source code of existing miner implementations.


SSL usage in Sumokoin/Monero There is this merge: https://github.com/sumoprojects/sumokoin/pull/63
that enables SSL for Sumokoin (can be used also for Monero).

What is it used for? I guess For SSL communication between RPC-wallet and daemon, but I am not sure, because I set enable_ssl to true and even the initialization somehow failed, I think it failed on handshake. I can spend more time investigating that, but I guess asking here is faster.

What I am looking for is a way to have SSL communication between client (for example someone using cURL to communicate with RPC-wallet) and RPC-wallet, so I guess this isn't it and it makes communication between RPC-wallet and daemon using SSL, is that right?

Btw, the init method with with parameter enable_ssl set to true is never used in Sumokoin code, so I am really not sure about the usage.

Monero does not implement SSL in the RPC but it's super simple to enable if you really want to open up a remote node with encrypted communication.

Some options are:

Connect via an SSH tunnel
Proxy an SSL enabled Apache/Nginx vhost
Use stunnel


Problem building release-v0.16 I can build release-v0.15 perfectly.
However, when I change to branch v0.16 and try to build it, it failed every time.
Can anyone give me some advice to solve it? Thanks!
[ 36%] Building CXX object src/checkpoints/CMakeFiles/obj_checkpoints.dir/checkpoints.cpp.o
/media/test/monero/src/checkpoints/checkpoints.cpp: In member function ‘uint64_t cryptonote::checkpoints::get_max_height() const’:
/media/test/monero/src/checkpoints/checkpoints.cpp:138:103: error: ‘boost::placeholders’ has not been declared
                          ( boost::bind(&std::map< uint64_t, crypto::hash >::value_type::first, boost::placeholders::_1) <
                                                                                ^
/media/test/monero/src/checkpoints/checkpoints.cpp:139:103: error: ‘boost::placeholders’ has not been declared
                            boost::bind(&std::map< uint64_t, crypto::hash >::value_type::first, boost::placeholders::_2 ) ) );
                                                                                ^
src/checkpoints/CMakeFiles/obj_checkpoints.dir/build.make:62: recipe for target 'src/checkpoints/CMakeFiles/obj_checkpoints.dir/checkpoints.cpp.o' failed
make[3]: *** [src/checkpoints/CMakeFiles/obj_checkpoints.dir/checkpoints.cpp.o] Error 1
make[3]: Leaving directory '/media/test/monero/build/Linux/release-v0.16/release'
CMakeFiles/Makefile2:1241: recipe for target 'src/checkpoints/CMakeFiles/obj_checkpoints.dir/all' failed
make[2]: *** [src/checkpoints/CMakeFiles/obj_checkpoints.dir/all] Error 2
make[2]: Leaving directory '/media/test/monero/build/Linux/release-v0.16/release'
Makefile:138: recipe for target 'all' failed
make[1]: *** [all] Error 2
make[1]: Leaving directory '/media/test/monero/build/Linux/release-v0.16/release'
Makefile:102: recipe for target 'release-all' failed
make: *** [release-all] Error 2

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


Can xmr.to work without javascript? I found on reddit a post that was created one year ago. And there are links to xmr.to and xmr tor address and there types it work without javascript. But today I went to xmr.to and it said you need to turn on javascript to make it work.

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

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

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


How to prevent stack smashing on ccminer I have tried everything to get mining with my Nvidia GPU on Ubuntu 16.04 using ccminer. I've tried completely purging all drivers and dependencies and building from scratch, but I still have this issue, but when I try to run I get a "stack smashing detected" error:

richard@motherload:~/Apps/ccminer-cryptonight$ ccminer -o stratum+tcp://monerohash.com:3333 -u 49rGPcgztcd3ULhDSiao7AZh3666xfE3LTTWwUHXeqyJ37TmvtCWtcsCRqRs794HnKT3exyvoZ6hFTYgB3CD4x7y8dXH2Xg -p x
    *** ccminer-cryptonight for nVidia GPUs by tsiv ***
 based on ccMiner by Christian Buchner and Christian H.
 based on cpuminer-multi by LucasJones
 based on pooler-cpuminer 2.3.2 (c) 2010 Jeff Garzik, 2012 pooler
    BTC donation address: 1JHDKp59t1RhHFXsTw2UQpR3F9BBz3R3cs
    DRK donation address: XrHp267JNTVdw5P3dsBpqYfgTpWnzoESPQ
    JPC donation address: Jb9hFeBgakCXvM5u27rTZoYR9j13JGmuc2
    VTC donation address: VwYsZFPb6KMeWuP4voiS9H1kqxcU9kGbsw
    XMR donation address:
      (man these are long... single address, split on two lines)
      42uasNqYPnSaG3TwRtTeVbQ4aRY3n9jY6VXX3mfgerWt4ohD
      QLVaBPv3cYGKDXasTUVuLvhxetcuS16ynt85czQ48mbSrWX
-----------------------------------------------------------------
*** stack smashing detected ***: ccminer terminated
Aborted (core dumped)

My video card is a GeForce GTX 580 (CUDA compute 2.0). I have the latest drivers installed from Nvidia. I have tried to use the --threads=1 flag to see if that would help, but no dice. I've also tried using CUDA 6.5 and CUDA 8.0. I am out of ideas.

It turns out that I was accidentally using the ancient and unmaintained tsiv branch of ccminer. When I had tried to install the KlausT version, it didn't overwrite this old version.

To solve this, I ran sudo rm /usr/bin/local/ccminer and re-cloned the KlausT branch of ccminer.


What settings for ZFS dataset containing blockchain directory? The ZFS file system allows the user to specify various characteristics when creating datasets, or even after their creation.  For example:

zfs create -o compress=lz4 -o atime=off zroot/data/monero

or

zfs set recordsize=1024k zroot/data/monero

When creating a ZFS dataset for containing the blockchain's data-dir, what are some appropriate settings for that dataset?

Presumably atime=off is a good one.  The blockchain is constantly written to, so there's no need to spend resources on tracking access times, I would think.
I would think compression may not be a good idea.  If the blockchain is filled with keys, that's a lot of entropy that can't be compressed really anyway, so maybe it's not worthwhile to spend resources on it.  Then again, (a) maybe there is some required boilerplate filler taking up space, and (b) from the FreeBSD handbook:

  If LZ4 does not achieve at least 12.5% compression in the first part of the data, the block is written uncompressed to avoid wasting CPU cycles trying to compress data that is either already compressed or uncompressible.

It's common to consider recordsize as a potentially critical choice affecting database performance because databases tend to get updated frequently (e.g., taking a case where recordsize=512k and database records are 16k, it would be wasteful to read 512k to change a 16k database record and then have to rewrite the whole 512k back). I imagine lmdb's use in Monero might lend itself to an ideal recordsize. If so, what might that be?
In the case of a blockchain, where data is generally only appended, maybe recordsize isn't actually important. But what might an optimal recordsize be if one wanted to optimize for chain reorgs?

The recordsize must be the same as the system's VM page size, which is usually 4KB on most systems. For blockchain data, compression is a waste of CPU. Cryptographic data is inherently incompressible.


Accept payment for digital goods I want to accept Monero for a digital good I am selling but I am new to the crypocurrency and I am pretty lost.

I initially thought of using an online wallet such as Cryptonator and MyMonero but I think I will lose money on the transactions between the online wallet and the local wallet (0.02 at Cryptonator and hidden fees at myMonero).

Can I accept payment to my local wallet? Do I have to leave my pc open all day long to accept the payments or it will synch when i get login? Are there any transaction fees when I am using my local wallet?

I don't need automation right now, I assume that the buyer will send me some Monero and a mail and I will be able to trace that user's transaction with my wallet transaction. What information do I have to ask from the buyer to confirm the payment?

I don't have to run this into a Tor because my goods are just software (music sheet editor)

Can I accept payment to my local wallet?

Yes, of course.

  Do I have to leave my pc open all day long to accept the payments or it will synch when i get login?

Transactions are stored on the blockchain, your Monero wallet is not needed for them to work. You only need it to check your balance and perform transactions yourself.

  Are there any transaction fees when I am using my local wallet?

No, transaction fees are paid by the sender.

  What information do I have to ask from the buyer to confirm the payment?

You should provide the buyer with a Payment ID that lets you identify the transaction.


Miner enquiry for exchange bought crypto If i buy crypto currency on an exchange with paper money. Do miners have to confirm that i now own X quantity of a  BTC or whichever coin or token I may have bought, is this then confirmed by all nodes on the blockchain? Cold storage devices, any recommendations or referral to past questions or sites? thank you

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

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


What is the difference between mixin and ringsize? The community recently changed from using the term mixin for ring signatures to using ringsize. Are these terms used interchangeably, or are there some differences between these two terms?

There is a small difference. In summary, ringsize will always equal mixin + 1. So, a mixin of 2 is the same as a ringsize of 3.

Mixin refers to the number of other inputs used in a ring signature that you do not control.

Ringsize refers to the number of total inputs used in a ring signature, including ones you control.


Smart contract privacy What type of smart contracts sidechains would most benefit from the privacy that Monero provides by default?

Assuming that many types of smart contracts sidechains were operational today, which would be most helped by using Monero as a base layer compared with a transparent blockchain base layer such as Bitcoin?

If you think about all the reasons why privacy matters for a crypto currency, almost all the same cases apply to any side-chain or smart-contract.


What is Monero "dust"? I've seen the term "dust" used for small amounts of Monero. What is the maximum value threshold for an amount to be considered dust?

I consider "dust" to be any amount of Monero not exceeding the cost of the transaction fee, therefore nullifying its value.


Why does `monerod` on Raspberry Pi 3 with a copied LMDB not catch up with new blocks? I have both a macOS system and a Raspberry Pi 3 on the same home network. Both are having Monero release 0.10.1.0 installed. I stopped the daemon on macOS, and then copied the entire .bitmonero directory from macOS to the Raspberry Pi 3 (running Ubuntu MATE 16.04), because the LMDB blockchain database should be compatible according to this answer. The copy was made at block height 1202945. Unfortunately, I can't get the monerod on the Raspberry Pi to synchronize. Event though it regularly prints something in the log, it seems stuck and currently is 75 blocks behind already:

2016-Dec-17 02:12:23.986976 [P2P9][167.114.49.139:18080 OUT]Sync data returned a new top block candidate: 1202945 -> 1203019 [Your node is 74 blocks (0 days) behind]
SYNCHRONIZATION started
2016-Dec-17 02:12:24.661208 [P2P0][45.32.187.175:18080 OUT]Sync data returned a new top block candidate: 1202945 -> 1203020 [Your node is 75 blocks (0 days) behind]
SYNCHRONIZATION started
2016-Dec-17 02:12:25.103400 [P2P8][37.10.71.83:18080 OUT]Sync data returned a new top block candidate: 1202945 -> 1203020 [Your node is 75 blocks (0 days) behind]
SYNCHRONIZATION started
2016-Dec-17 02:12:25.375142 [P2P0][85.194.238.130:18080 OUT]Sync data returned a new top block candidate: 1202945 -> 1203020 [Your node is 75 blocks (0 days) behind]
SYNCHRONIZATION started

When I do a monerod status it shows this:

Creating the logger system
Height: 1202945/1203020 (99.9%) on mainnet, not mining, net hash 37.98 MH/s, v3 (next fork in 24.4 days), up to date, 6+0 connections

How can I resolve this?

Update

Started monerod with --add-exclusive-node 192.168.0.115, my internal node's IP address, to rule out any external connectivity issues.

2017-Jan-08 21:48:22.763516 [P2P9][192.168.0.115:18080 OUT]Sync data returned a new top block candidate: 1202945 -> 1219550 [Your node is 16605 blocks (23 days) behind]
SYNCHRONIZATION started

After I did set_log 1, I got to see 19 of the following errors in bitmonero.log, and after that nothing:

2017-Jan-08 21:52:46.665384 Attempting to get output pubkey by global index (amount 30000000000000, index 46428, count 46423), but key does not exist
2017-Jan-08 21:52:46.698247 EXCEPTION: Attempting to get output pubkey by global index (amount 30000000000000, index 46428, count 46423), but key does not exist
2017-Jan-08 21:52:48.283107 Attempting to get output pubkey by global index (amount 20000000000000, index 75368, count 75366), but key does not exist
2017-Jan-08 21:52:48.322563 EXCEPTION: Attempting to get output pubkey by global index (amount 20000000000000, index 75368, count 75366), but key does not exist
2017-Jan-08 21:52:49.951894 Attempting to get output pubkey by global index (amount 10000000000000, index 914594, count 914594), but key does not exist
2017-Jan-08 21:52:49.952457 EXCEPTION: Attempting to get output pubkey by global index (amount 10000000000000, index 914594, count 914594), but key does not exist

When I do a status after this, I got an error because the monerod process seemed to be no longer there (pressumably crashed).

There was a bug in the ARMv7-specific source code, which was triggered when using newer versions of GCC to compile the code.

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

It has recently been fixed.


how to calculated how much H/s can my GPU do for different types of cryptocurrencies? How can I calculated how much H/s can my GPU do as a function of the type of gpu, the difficult of the cryptocurrency and time?
You can calculate this with https://www.nicehash.com/?p=calc, https://www.cryptocompare.com/mining/#/equipment  but they miss many important cryptocurrencies.

Many Thanks

It's not possible to calculate. There's either data available based on what people are reporting, or there's not.

Mining performance is dependent on the mining algorithm used. Monero uses CryptoNight, and for that you can find a list here: Which type of hardware is the most efficient for mining Monero? It should be the same for any cryptocurrency using CryptoNight.

For non-CryptoNight cryptocurrencies, I doubt you'll find an answer here as this StackExchange site is focused on Monero and other CryptoNote cryptocurrencies.


Is it safe to share a daemon with a roommate? Are there any security concerns with sharing a Monero daemon with a roommate to send or receive transactions?

If we each person has their own wallet, encrypted with a very strong password what are the risks of sharing the same computer and bitmonerod program?

You are asking two different things here:

what are the risks in using the same daemon

They're typically small, and mostly either privacy leaks or denial of service.

Obviously, whoever runs the daemon may either withhold new blocks, and try to inject fake blocks. The wallet will not check PoW, etc. A daemon who knows the user's standard address could make a transaction to that address, not relay it to the network as a whole, mine it, and make it seem the user was paid.

Privacy leaks exist, and most of them can be plugged by not using --trusted-daemon (however, if you're connecting to a node on the local machine, the daemon is assumed trusted. If you're on the same machine, you have bigger problems anyway, see below).

First, when sending a transaction, the wallet will request random outputs from the daemon to use in a ring signature. This means that, when the wallet sends the transaction, the daemon will see the outputs it sent earlier, plus another one. That must be the real output, which the wallet already knew about. This is fixed in the rct branch: the wallet then decides which outputs to get, and include its own there, so the daemon cannot tell which is which.

When refreshing the wallet, a block containing one more more outputs for that wallet will cause a request to the daemon for more information about this transaction. This tells the daemon that this transaction has at least one outout for the wallet. This is fixed in the rct banch, where this information is sent with all blocks in the first place, so the daemon cannot tell which transaction pay the wallet.

When sending a transaction, the wallet will ask the daemon for the number of outputs of given size exist on the blockchain, to know what amounts are compatible with the requested mixin. This tells the daemon the set of amounts for which the wallet has one more more outputs. If using an untrusted daemon, this will be skipped (the wallet will ask for all outputs, not just the ones it has; it's fairly slow, but privacy preserving).

In any case, the daemon never gets anywhere the wallet's private keys, whether spend  or view.

Last, if the wallet connects to an untrusted daemon, then the daemon may try to attack the wallet through an buffer overflow or other bug. Hopefully there aren't any, but then most software hopes so too.

what are the risks in using the same machine

That's a lot riskier. Hardware access to the machine means you can install hardware keyloggers. Assuming you each use different accounts, a kernel exploit could allow software keyloggers too. Then you get passwords to the account and the wallet (the former being not even needed if you have a kernel exploit).


Missing one word from 25 word mnemonic seed I wrote down a mnemonic seed that is missing one word, the position of which is unknown. I was able to locate this recovery tool which is very helpful. However it assumes a 13 word mnemonic seed formatted for mymonero instead of 25 word monero-wallet-cli seeds.

How can I adapt this tool for a 25 word seed?
In addition to the partial mnemonic seed I also wrote down the complete view key and address. Therefore, I have no need to scan the entire blockchain in order to know if the recovered mnemonic is accurate or not. How  can I codify the automatic comparison of my address and/or view key to those generated from a recovered mnemonic to verify the match?

It will not matter if it is 13 or 25 words seed since the script will just need to add another word in the first, last or in between your seed and create the wallet. Your problem is implementing it for the real monero-wallet-cli/monero wallet since it will take longer to scan compared to mymonero. In mymonero a single query would return that the wallet is new or old but in real monero wallet you need to scan the whole blockchain to find if there was a transaction.

This is not impossible to implement but you need to  create a script on top of monero-wallet-cli and be able to automate the creation of wallet using the --restore-deterministic-wallet command or just create a new program based on monero-wallet-cli which automates the wallet creation and scanning of the blockchain.

Lastly, you can't trivially find the transaction hash knowing only the monero address and view key. You have to scan each transaction in the blockchain.

Edit: In the case that you have the view key you don't need to scan the blockchain you just need to compare it with the view key of your new created wallet.

Edit 2: Actually the address is enough and there are three ways you can implement this.

Use the javascript code found in mymonero.com. The same source can be found here and  the specific file
Modify the cli wallet which is in github to just create wallet address base on given seed and looping to all possible combination.
Use your favorite scripting language and automate the monero-wallet-cli --restore-deterministic-wallet. It will return the address.

Edit 3: I implemented it in javascript. The seed is missing the word older in the end. http://jsfiddle.net/gundamlancer/9jvdkrat/1/


Why does the num_unspent_outputs decrease to 1 in Monero wallet? This wallet is used for withdrawing, as the number of withdraws increases, the num_unspent_outputs decreases to 1 in the end. This will cause the wallet to lock its whole balance for each transfer, which is very much undesirable. Why is this? I suspect the wallet is spending outputs in ascending order, that is spend smaller outputs first, so in the end, it will group all the balance into one output. Is there any setting to change this?

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

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

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

For example, you can run:

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

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


Why does Monero GUI kill my internet connection? I sync and I sync, for like 36 hours now to an SSD. Seems like the internet connection goes offline for the majority of the time I run the daemon. Turn the daemon off, internet comes back on. Any ideas?

edit: should I allow the port through my router? could be a stuuuuupid question!

Many cheap internet modems choke when the outgoing bandwidth is saturated. Try starting the daemon with the "--limit-rate-up=X" where X is a small value in KB/sec. You can start by allocating one third of your maximum outgoing bandwidth and see how this behaves.


If Poloniex was hacked or shutdown, what effects would that have on Monero? If Poloniex was hacked or shutdown, what effects would that have on Monero?  I suspect they have a ton of coins there, since it seems to be the largest monero exchange.  Would it effect the coin in any way besides reactionary price changes?

It would hurt Monero users who rely on exchange wallets instead of offline cold storage.

Volume would quickly move to other exchanges such as Cryptopia, Bittrex, Shapeshift and Bitsquare. Depending on the reason Poloniex shut down, decentralized options such as Bitsquare would likely benefit the most.

No hard fork would even be considered to recover the losses of those who had funds on the exchange. Monero is immutable and such a fork would be an impossibility for both technological and social contract reasons.

From a practical standpoint, there would be no way to trace any Monero stolen from the exchange as the result of a hack. The best chance of finding the attacker would be to trace other coins he/she may have stolen from the exchange and hope the hacker confesses and returns all the Monero after being caught.


Is my monero core wallet seed password compatible when using android monerujo app? Can I use my same seed phrase from monero core on the monerujo app?

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

  Recover wallets from mnemonic seed or from keys


From "Pending balance" to "Total paid" Under which conditions the accumulated amount of XMR in a mining pool, goes from "Pending balance" to "Total paid", then definitely in my wallet?
I have exceeded the payout threshold of 0.5 XMR in my pending balance, which is now around 0.53,but I still did not see the 0.5 amount moved into "Total paid".

Must a new block be found for the transaction to occur? I still did not understand completely how pool mining works.

It depends on the pool payment schedule. If you go over the threshold it doesn't mean the pool will immediately make the payment, but it should be part of the next batch, whenever that may be. Some pools make payments once per day, so you'd have to wait a bit. Maybe you've already received your payment :)


How many characters can be missing or mis-typed in a Monero address to still be valid? If I mis-typed or left out some characters, what is the threshold where the address won't be valid? I know Bitcoin and some other addresses have some type of error correction built into the address. What is Monero's?

The odds of getting a 4-byte cryptographic checksum to match is roughly 1 in 4 billion, 2^32 = (2^8)^4. A Monero address provides a 4 byte cryptograph checksum for detecting errors (parity). No Hamming error correction services are provided. Monero addresses without payment addresses and multisig abilities are always 95 characters in length.

The last 5-bytes of the hex encoded representation of a Monero address are base58-encoded.  The lower 4-bytes of hex characters represent the checksum  while the last byte of public view key bleeds into the top portion of the ninth base58-encoded segment that contains the checksum.

For details on how a Monero address is constructed see the working example at the bottom of Constructing a Stealth Monero Address?. For this working example, the 9th base58-encoding of ffADD56816 (hex) is Vr5GCd (base58).  The ff comes from the lower portion of the public view key 3c450f27cd6849d9130addb2c566d910c5ef9bf4cecaed547004496fda52a4ff, and the ADD56816 comes from top four bytes of a Keccak-256 bit hash the Monero Cryptonote prefix in hex (12) + public spend key in hex + public view key in hex.


Online implementation of CryptoNight/R I'm on an adventure trying to write my own own implementation of a C CryptoNight/R hasher. I already have some working code but wanted something that could help me validate the hashes.
Is there any online CryptoNight/R hasher out there? If not, is there some code implemented somewhere that is easier to understand than the code in the monero-project on Github?

I don't know of any web-based example but it's pretty easy to use py-cryptonight for testing/validation purposes.

For example:

pip install py-cryptonight

Then in Python:

import pycryptonight
import binascii

height = 123456
data = binascii.unhexlify('DEADBEEF')
prehashed = 0
variant = 5
hash = pycryptonight.cn_slow_hash(data, variant, prehashed, height)
print('Hash: {}'.format(binascii.hexlify(hash)))


XMR-STAK - Does it detect CPU/GPU heat? Will xmr-stak stop working if it detects either the CPU or GPU temperatures are too high?

Similar to the configurable options in Claymore?

It will not. As of now, it doesn't monitor heat.


Where and how to start to understand Monero? I'm a newbie and I would like to know more about Monero and the technology behind it.

What is a good starting point to learn more about Monero? Website, wikis, books?

Thank you so much for answers.

I think that, at this time, the best starting point to learn all about Monero is Mastering Monero: The future of private transactions. The book covers all the aspects behind Monero and gives you all the useful things to understand Monero.

As stated:

  This book contains everything you need to know to start using Monero
  in your business or day-to-day life, even if you've never understood
  or interacted with cryptocurrencies before.

Apart from that, you can find a lot of useful resources on the web and you can start reading the resources section on the official getmonero.org website.


With Monero firmware loaded on a Trezor, how does one create private spend keys from the BIP 39 seed words supplied during a Trezor's configuration? I’ve experimented with Monero’s V0313 experimental firmware that is installed on a traditionally hierarchical deterministic Trezor hardware device, which is also immune to key loggers and the CSRF vulnerability.

For future proof contingency planning purposes, if I could reconstitute traditional *.keys files outside the Trezor, I could sleep a little better. (When a Trezor device is not used, *.keys files exist for each Monero wallet. When a Trezor device is used, private spend keys are vaulted inside Trezor, and thus there is no need for *.keys files.) I’ve already successfully tested recovering a Trezor from BIP 39 seed words using this procedure.  But with experimental firmware, that is not enough assurance to satisfy me.

If I knew how V0313 Monero firmware creates a private spend key inside a Trezor device from the 24 BIP 39 seed words provided to a end user during the configuration of a Trezor, I will be able to reconstitute a Monero wallet using traditional Monero key recovery mechanism that uses Electrum seed words, i.e. --restore-determinstic-wallet.

It is also unclear what branch/tag configuration was used to compile the V0313 Monero firmware, evidence from mytrezor is pointing towards a fork of trezor-mcu v1.3.4.

From experimentation, I’m 100% certain that the integer argument supplied to a forked V0313 simple wallet code via the --hardware-wallet argument changes the private spend key. Similarly, providing an arbitrary password beyond a numerical PIN to establish a Trezor session also changes the effective spend key. Hence, the 24 BIP 39 seed words, the --hardware-wallet integer, and the unlocking wallet password all impact the binary representation of a private Monero spend key supported by V0313 Trezor firmware.

The question posed in the title up top is also very important for multi-cryptocurrency wallet developers to know how to develop wallets supporting BIP 39 seed word portability across different implementations. Also, requiring end users to record Electrum seed words for Cryptonote currencies, and a separate BIP 39 word for other altcoins is very undesirable. If multi-currency wallets only have end users record BIP 39 words, it simplifies life for those end users.

There needs to be a Monero Improvement Proposal (MIP) documenting the degree of private key interoperability Monero has with BIP 32/39/44 technologies. Granted, from a HD m/44/128/0 private key, the means to establish a corresponding Monero M/44/128/0 public address key is quite a different beast and BIP 32 technology that can't be applied to derive M/44/128/0. Additionally, associated view keys that can be made deterministic.

Can anyone knowledgeable answer the question posed in the title up top? It is a first step towards developing a MIP and extending BIP 44 to calculate private spend keys.

The answer to this question will require a Monero subject matter expert. If someone tells me that Monero Trezor functionality does not use BIP 39 words, I will puke all over their ignorance!

Harmonization of Electrum seed words and BIP 39 seed words is possible with the application of socialized best practices if one opens their mind a bit... No changes are required on the behalf of how Monero uses Electrum words and no changes are required Bitcoin, and numerous other altcoins.

The initial answer below, doing things the Monero way, originated from How does one convert the Trezor seed to a simplewallet seed and vice versa. I followed this URL's recommendations using the associated V0313 binaries, but was unable to recreate the same Monero address that my Trezor is using for a given prompted "password" and an integer "index" passed via the --hardware-wallet argument index:addr_version that is supplied to the forked V0313 simplewallet.

Here is an example of results for using the V0313 trezorctl with mnemonics_recover assuming a Trezor during its configuration (using the V0313 firmware) resulted in these 24 BIP 39 seed words: honey naive mouse rubber runway fetch rifle enhance unfair undo hood sister dog armed exhibit interest public rib tourist camera mistake claim flat wing.  The index passed to simplwallet was 0 and the password promted by simplewallet is Bad_PASSword.

% ./trezorctl recover_mnemonic 0 Bad_PASSword English honey naive mouse rubber runway fetch rifle enhance unfair undo hood sister dog armed exhibit interest public rib tourist camera mistake claim flat wing

Private key: 7e22a1f766b70f10e88364ac833d8622cebee457eba9f1f4b9826bfe728d1e05
Wallet address: 48iYq4jBs6BZEzGXJZcWC8C85aA3pHSYhF7JE2Dg3iD6Hdd56NVTcfygghHqw66DvAKohATR4DMQsPBtgeQxU3Lp59pwkt8
Mnemonic: agnostic ignore heels update syndrome ultimate vaults tufts mugged picked rudely trash lukewarm enlist observant later suddenly shuffled gleeful stellar soya tudor habitat hire lukewarm

It is worth noting the Private key, Wallet address, and Mnemonic computed above all correlate with results from https://xmr.llcoins.net/ Javascript, which can be confirmed offline. Those using the Monero firmware, might want to independently validate the v0313 trezorctl recover_mnemonic is working properly for them.

More importantly, one can positively confirm they recorded the proper BIP 39 seed words displayed by their Trezor device if they use libbitcoin's bitcoin-explorer (bx) command, which has an extremely good track record for recreating Trezor device results with a relatively simple command line interface. Of course one must use the 24 words that is applicable to their Trezor and not the ones demonstrated below and their appropriate password. Other than that the arguments to the piped processes below remain the same.

% echo "honey naive mouse rubber runway fetch rifle enhance unfair undo hood sister dog armed exhibit interest public rib tourist camera mistake claim flat wing" | bx mnemonic-to-seed -p Bad_PASSword | bx hd-new | bx hd-private -d -i 44 | bx hd-private -d -i 0 | bx hd-public -d -i 0

xpub6C9uhLie5mr2TJ8z27sARKZQf5AL8EA5U5S5NjtjC9sYx1fW6hXC8FZxLRqoBZtk35mC5GCyffx3BKAiv9GwP9utEEtfN5VTw31fYyFfrBD

If the extended public key produced immediately above matches the one available when one digs through https://wallet.mytrezor.com/#/ with their Trezor, then one most definitely recorded the BIP 39 seed words properly.  With the computed Monero address not matching, and the application of bx to properly compute the extended account public key convinced me the trezorctl recover_mnemonics capability is not functioning properly for V0313.

Suggested behavioral improvements for "trezorctl mnemonics_recover" capability:

Below is a candidate test vector recommendation that also uses libbitcoin.  Applying bx to the trezorctl command example above, here is how a future release could work and be consistent with BIPs 32, and 39, and BIP 44 coin registrations to the maximum extent possible for synthesizing the private spend key. The 44 integer below indicates BIP 44 is to be used. The 128 indicates Monero is to be used, see the BIP 44 coin registration table.

% echo "honey naive mouse rubber runway fetch rifle enhance unfair undo hood sister dog armed exhibit interest public rib tourist camera mistake claim flat wing" | bx mnemonic-to-seed -p Bad_PASSword | bx hd-new | bx hd-private -d -i 44 | bx hd-private -d -i 128 | bx hd-private -d -i 0 | bx hd-to-ec

4a06027938fbe584f0c7fad131cdae14c737e53f6f3e9bdec2b382698b384fac

The following produces the Monero private spend key:

% ./sc_reduce32 4a06027938fbe584f0c7fad131cdae14c737e53f6f3e9bdec2b382698b384fac

08bf67d7301c2e1491a74e747f0af943c637e53f6f3e9bdec2b382698b384f0c

The following produces the Electrum seed words used for wallet/(private spend key) recovery:

% ./bytes_to_words 08bf67d7301c2e1491a74e747f0af943c637e53f6f3e9bdec2b382698b384f0c

ascend wedge sorry fiat gone isolated rowboat skydive educated regular amaze fossil heels tagged awakened gables upload sipped lynx anvil kickoff basin does enigma educated

Then using https://xmr.llcoins.net/addresstests.html, the following Monero address results:

4Ak341HR2HnYPgocscZYAaMByPa7rHCj1EhbyCQjLvyWQkcNTG2zbbB1h8iB5sbcDYjUNobgGJn4fjgqMfeYQfEaS6w8HHL

This test vector approach succintly demonstrates how Monero harmonization with BIPs 32/39/44 is possible and desired.  This mindset also leaves open the concept of applying BIP 38 to Monero's deterministic private spend keys.

Update: Created an executable called ./xmr that takes a private secp256k1 key. Results below match results above.

% echo "honey naive mouse rubber runway fetch rifle enhance unfair undo hood sister dog armed exhibit interest public rib tourist camera mistake claim flat wing" | bx mnemonic-to-seed -p Bad_PASSword | bx hd-new | bx hd-private -d -i 44 | bx hd-private -d -i 128 | bx hd-private -d -i 0 | bx hd-to-ec | ./xmr

   Private Spend Key    : 08bf67d7301c2e1491a74e747f0af943c637e53f6f3e9bdec2b382698b384f0c
   Private View Key     : ec69371cc4f7176b3eddb69a1eca4a775909d73b68021aaf5f173eac9d8fd706
   Public Spend Key     : f0a59fa7ee5e71bbace5a9f6a4bdb778b404d54406ffa051e841710e9642f98e
   Public View Key      : 00d7d42cee66de04230aa498f3efb3fdec69c69beceea0ff352775998ad293de
   Monero Address       : 4Ak341HR2HnYPgocscZYAaMByPa7rHCj1EhbyCQjLvyWQkcNTG2zbbB1h8iB5sbcDYjUNobgGJn4fjgqMfeYQfEaS6w8HHL
   Electrum Seed Words  : ascend wedge sorry fiat gone isolated rowboat skydive educated regular amaze fossil heels tagged awakened gables upload sipped lynx anvil kickoff basin does enigma educated

Cheers...


Get public key of tx that currently in txpool Can someone tell me how I can get list of public keys of the transactions, which are currently in the txpool and has not yet been mined? That is, I am interested in how to get this information out of the data returned, for example, by this rpc request:
https://ww.getmonero.org/resources/developer-guides/daemon-rpc.html#get_transaction_pool

The transaction public key is contained in the txextra part of the get_transaction_pool response.

The format of txextra is documented here: https://cryptonote.org/cns/cns005.txt

You therefore want to parse txextra and look for subfield 0x01.

Please could you leave a comment and let us know how you made the tx private key deterministic? What are you hashing together to determine your tx private keys?


Where can I find the Monero transaction specification? I am trying to understand Monero by coding a transaction parser and general utilities library in Go. Is there a place I can get a transaction specification for Monero transactions? I know it's based on CryptoNote, but I'd like something like https://en.bitcoin.it/wiki/Transaction to work with.

Also, is there any website I can get raw hex Monero transactions to test against?

There is no such specification. It's fairly simple though, see src/cryptonote_basic/cryptonote_basic.h, the transaction and block classes.

Most numbers are variable length integers (format in src/common/varint.h), vectors are a number followed by the elements, etc. Fields are concatenated. Hashes, keys, etc, are dumped as is. Objects which can be different types have an identifier determining the type (see VARIANT_TAG at the end of src/cryptonote_basic/cryptonote_basic.h), then the object.

You can find the hex dump of a transaction in the daemon: print_tx SOMETXID


Why/how does monero generate public ed25519 keys without using the standard public key generation provided by ed25519 libraries? Why/how does monero generate public ed25519 keys without using the standard public key derivation provided by ed25519 libraries?

Inspecting the code for mininero (https://github.com/monero-project/mininero/blob/master/mininero.py), it seems that it doesn't call the ed25519 publickey method to generate public keys. Instead, it defines its own public_key method that does this:

ed25519.encodepoint(ed25519.scalarmultbase(sk))

Mininero's copy of the ed25519 library (from http://ed25519.cr.yp.to/software.html) provides a function called "publickey", which appears to be identical in purpose to the python pynacl and warner/python-ed25519 libraries. All three produce the same resulting public keys. Neither of those other libraries appear to provide an alternative mechanism to derive a public key the way mininero does, nor do they provide any methods to mirror the functionality of mininero's ed25519.encodepoint. This leads me to believe that minero is deriving the public spendkey in an alternative way.

Why doesn't it just use the normal public key methods provided by these libraries? What is the reason for deriving the public key this way?

My hunch is that there is a reason to use a different public key generation system because the intent is to use ed25519 for more than just signing something. For background, I'm writing some monero address generation code as a learning project and I noticed that with the same seed, my public keys are not being generated the same way as valid monero code. My code takes the seed:

awning ramped obedient frown vaults voice dash sunken talent myriad soggy pumpkins buffet vigilant yields foggy wayside rabbits unplugs sarcasm behind lopped tycoon uttered frown

Which produces a spendkey of

77fadbe52830d30438ff68036374c0e3fb755d0d983743bcbfb6a45962f50a09

My code uses python libraries to generate an ed25519 public spend key. I wrote the code to use either https://github.com/pyca/pynacl or https://github.com/warner/python-ed25519 , which both produce the same result. For my spendkey above:

9235e2ecf938d462e79fe993bfdb1717353c87a0b0ed7cb1d58c9692035336d0

This doesn't match what the mininero code and https://xmr.llcoins.net/addresstests.html produce for the same spendkey. They both produce 0f3b913371411b27e646b537e888f685bf929ea7aab93c950ed84433f064480d

Here is a snippet of code that shows the 9235e2ecf938d462e79fe993bfdb1717353c87a0b0ed7cb1d58c9692035336d0 generated public key (ed25519 from warner/python-ed25519):

import ed25519
import binascii
spendkey_hex = b'77fadbe52830d30438ff68036374c0e3fb755d0d983743bcbfb6a45962f50a09'
sk = binascii.unhexlify(spendkey_hex)

def sc_reduce32(n):
    n = int.from_bytes(n, byteorder='little')
    l = (2**252 + 27742317777372353535851937790883648493)
    reduced = n % l
    newbytes = reduced.to_bytes(32, 'little')
    return newbytes

reduced_sk = sc_reduce32(sk)
sec = ed25519.SigningKey(reduced_sk)
pub = sec.get_verifying_key()

print('pub key: ' + str(pub.to_ascii(encoding="hex")))

Here is a snipped of code that produces 9235e2ecf938d462e79fe993bfdb1717353c87a0b0ed7cb1d58c9692035336d0 using ed25519 from the mininero copy of ed25519.py

import ed25519 as ed25519
import binascii
spendkey_hex = b'77fadbe52830d30438ff68036374c0e3fb755d0d983743bcbfb6a45962f50a09'
mininero_pub_spend = ed25519.publickey(binascii.unhexlify(spendkey_hex))
print('pub key: ' + str(binascii.hexlify(mininero_pub_spend)))

Monero doesn't use EdDSA, which all of those libraries are specifically set up for. We don't use SHA512 at all, but rather Keccak (~SHA3). We don't use secret keys as seeds like EdDSA does, but rather as scalars. If you look at ed25519.py on L63, you can see what I'm talking about.

Change the function to look like this:

def publickey(sk):
  a = decodeint(sk)
  A = scalarmult(B,a)
  return encodepoint(A)

Now you'll get the correct result: 0f3b913371411b27e646b537e888f685bf929ea7aab93c950ed84433f064480d. I use binascii.hexlify to get the output converted to hex (and also unhexlify to use the secret key as input to publickey(sk)).


Are Monero transaction types versioned? For example, we have RCTTypeNull, RCTTypeSimple and RCTTypeFull.

If I were to make a change that was not backwards compatible to RCTTypeSimple, is this versioned in some way, or is another type of tx created?

I ask if another type of tx is created because we also have RCTTypeBulletproof and RCTTypeBulletproof2.

Transactions have a version field (see here and here, which is currently 2, RingCT). However RingCT signatures also specify a type in rct_signatures.type. RCTTypeSimple etc, are the type of RingCT signature used and are defined here.

Therefore it depends what you intend on changing (transaction / signatures), that would determine which field(s) you should change to ensure backwards compatibility.

If you intend on doing away with RingCT altogether, you would of course change the transaction version field.

If you intend on creating a new type of RingCT signature, you would create a new signature type.


Can you choose the mnemonic seed to create a wallet? To recover a wallet, all it requires is your 25 word recovery seed. I was wondering if you can create a wallet by selecting these 25 words yourself and going from there. This would be cool because then people could pick more easily memorize their seed and also would allow people to create a wallet completely offline without any software.

Also, is the 25 word seed function specific to certain wallets or could you use those 25 words to recover a wallet on any wallet software...(i know mymonero.com uses only 12 words or at least used to)

I was wondering if you can create a wallet by selecting these 25 words yourself and going from there.

Yes. But you actually select 24 words and compute the last one (25th is the checksum, and it will always be one of the 24 words of your seed mnemonic).

Your wallet is really defined by those first 24 words, and the last one is an extra which lets you check for errors when recovering or makes recovery easier if you lose a few words somehow.

  This would be cool because then people could pick more easily memorize their seed

It would (note that you'd need the correct dictionary to pick from), but I'd strongly advise against this. Human brain is horrible at producing randomness. You really should roll a random seed first, and then memorize it if you will. The generation should always be truly random.

  and also would allow people to create a wallet completely offline without any software.

You can do this with dice, here's a simple way:

Perform 4 rolls of 6-sided dice and calculate a number between 0 and 1295 like: WordIndex = 6 * 6 * 6 * (roll_1 - 1) + 6 * 6 * (roll_2 - 1) + 6 * (roll_3 - 1) + (roll_4 - 1).
Pick a corresponding word from the dictionary using the number above as index.
Repeat until you have 24 words.
Compute the 25th checksum word.

Note that it will have somewhat reduced entropy (it will be about 248 bits) because we're not using a part of the dictionary but that's not really a big deal. I was playing around with this a while ago and came up with this system to minimize entropy loss.

  Also, is the 25 word seed function specific to certain wallets or could you use those 25 words to recover a wallet on any wallet software...(i know mymonero.com uses only 12 words or at least used to)

It's a wallet convention thing, and any wallet can have its own if you will. The protocol doesn't care about mnemonic or seed. 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. There are 2 conventions in use (for now) and the 13-word one will be deprecated AFAIK.

This site, made by one developer from the core team (Luigi1111), has a great explanation on how the whole key derivation process works, and below text is taken from the site and formatted to suit SE:

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

To add to the confusion, there are presently at least three different methods of private key derivation in existence for Monero (and other Cryptonotes), though Bitcoin also has many:

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

Also, inspecting that site's code will tell you a great deal about how it all works, if you understand JavaScript. For example, if we're interested in how exactly is the checksum derived, we must look at the code as the process is not explained on the site.

The relevant functions for conversions between seed and mnemonic are in the mnemonic.js file. If you're generating the seed by some other means, all you really need to do is compute the checksum to end up with a valid mnemonic.

function mn_get_checksum_index(words, prefix_len) {
    var trimmed_words = "";
    for (var i = 0; i < words.length; i++) {
        trimmed_words += words[i].slice(0, prefix_len);
    }
    var checksum = crc32.run(trimmed_words);
    var index = checksum % words.length;
    return index;
}

What that function does is: assemble a string of prefixes of each of your 24 words, run a CRC32 on that string and use the resulting number to pick a checksum word. The word is picked from one of the words found in your mnemonic.

For example, if we have the mnemonic:

skirting trash phase buckets apology gags sedan coffee vinegar else fifteen pitched idled gorilla siren cucumber urban junk vastness laboratory rift rhino situated taxi

The string which we feed to CRC32 will be:

skitraphabucapogagsedcofvinelsfifpitidlgorsircucurbjunvaslabrifrhisittax

and the result of CRC32 performed on it will be
1790087523.

Performing a mod on that number with the number of words in your checksummed data (24 in this case) will give you an index of the checksum word:

3.

So, the checksum is the 4th (note that index is 0-based) word of your mnemonic:

buckets.


Going through customs in a foreign country. I want to delete my monerujo app. Can I re-download with everything intact? I've read that you can delete and restore the monerujo app without affecting the wallet data, I never tried it as I'm afraid of losing access to my wallets.

When you setup your initial and load your own monero private key and not a seed, it throws you a crazypass passphrase that it tells you to remember. I didn't write this down. Do I need this to restore my wallet? Or do i just remember my password?

If you are removing Manerujo from your phone, first view and write down the mnemonic seed. When you reinstall the app, recover wallet from the seed.

https://github.com/m2049r/xmrwallet/blob/master/doc/FAQ.md

You should be backing up your password and seed or keys anyway. Then just try with a test wallet to verify before using with your real wallet.


Moneroaddress.org balance verification, wallet restoration, and usage precautions I have used the moneroaddress.org website to generate a wallet, sent some funds using shapeshift.io

I kept my spend and view key, my wallet address and mnemonic.

All this was done offline except for the trade

I later used xmr check site to see the transaction went through and my wallet address received those funds.

If I wish to see my wallet balance later and restore it, should I use simplewallet?

Do any precautions need to be taken?

If I wish to see my wallet balance later and restore it, should I use simplewallet?

Yes simplewallet is your best choice for restoring your wallet. Instructions to restore from mnemonic-seed can be found here. You can can also restore from keys but that is slightly more difficult.

Before restoration, the xmr tests site you mentioned is the easiest way to verify your balance (assuming your mnemonic seed and keys were kept safe and no outgoing transactions occurred) with the use of your view key to see the incoming transactions.

  Do any precautions need to be taken?

You did the right thing by creating your wallet offline

Store your mnemonic-seed in a safe place offline. When restoring, ensure your system is free from keyloggers and you use a strong password.


Whonix problem: Wallet Address Changed, Coins Lost Hi I am new to crypto and I am still learning the basics of things. I hope somebody can help me understand what's going on with this problem I am struggling with for the past many hours.

I installed Monero CLI on Whonix. I created a wallet just fine. Somebody sent some coins to the wallet address. But I had to synchronize the wallet before the coins show up. No matter what i tried I could not connect to the daemon through Tor ( I kept getting "could not bind IPv4 /failed to initialize p2p server" error). I search for a long time for a solution to this, but I could not solve it.

Eventually I gave up on Whonix. I said I will figure out anonymity later, I just want to see my coins. I went to a different machine and installed the Monero wallet GUI  on clearnet (no Tor). I used the seed to recover my wallet. Got the daemon working and synchronized the wallet. I thought the coins I received before would finally show up in my wallet....... but they don't. I checked and realized that now my wallet receive address is completely different from before. I exchanged coins at the new address to make sure it works, and sure it does..... but the coins from my initial transaction never arrive in the wallet.

I used blockchain explorer and saw the first transaction went thru to the old address and it's getting broadcasted. I went back to Whonix machine (daemon still cant connect so it still cant synchronize the wallet) and the wallet still shows the old receive address from before I recovered the seed on the 2nd machine (as expected). Which means the coins are sitting in a wallet somewhere...?

My questions:

Why did the wallet address change? Are they 2 separate wallets now?
Can I ever get the coins from the first transaction? Or are they lost forever

Thank you very much

A Monero mnemonic seed is a word based representation of a secret spend key. It is essentially the secret spend key. If you use the same set of words, you will end up with the same secret spend key, which deterministically yields the same public spend key. Since you have a seed in the first place, your secret view key is also deterministically derived from that seed (it is possible to have independent view and spend keys, but you don't get a seed for those). In turn, this deterministically yields the public view key. Both public view and spend keys deterministically yield your standard address. So from a seed, you get an address.

Note that some software (mostly trezor and ledger I believe) don't do this, but you did not mention you use those so I'll assume you don't.

So the most likely explanation is that you did not restore the same seed. Make really sure you copied the seed correctly from the first machine to the restoring machine. If you're really sure you used the same seed and the addresses are still different, then you could copy the keys file (if you name your wallet BLAH, then the keys file will be named BLAH.keys) to the new machine and open it without restoring from seed. Then file a bug on https://github.com/monero-project/monero and includes details like your monero software version, whether both machines are 32 bit, their architecture, and anything else that seems relevant.

If you keep the keys file, you should be able to see and use your monero whenever your p2p connection gets fixed. The keys file contains the secret keys (which are another representation of the seed).


Monero Genesis transaction & nonce I've seen the monero genesis-tx breakdown

version 01 unlock time (varint, height, 60 here) 3c vin length (value in) 01 vin #1 (of 1) type (gen, 0xff) ff height for gen input 00 vout length (value out) 01 output #1 (of 1) amount (17592186044415 as varint) ffffffffffff03 output #1 type (to key, 0x02) 02 output #1 key (32 bytes) 9b2e4c0281c0b02e7c53291a94d1d0cbff8883f8024f5142ee494ffbbd088071 extra length in bytes (varint, here 33) 21 extra pubkey tag (0x01) 01 transaction pubkey (32 bytes) 7767aafcde9be00dcfd098715ebcf7f410daebc582fda69d24a28e9d0bc890d1

Does one simply change the output key and pub key, recompile and run the daemon?

Your objective is to have a unique genesis block.

You could achieve this by altering the genesis transaction, for example by altering the output key and transaction public key so that your own wallet can be the beneficiary of the funds created in the genesis transaction. An easy way to do this would be to create a wallet address and then create a transaction destined for your wallet on the main Monero network. You could then use a blockchain explorer to inspect the tx public key and output one-time public key, and copy/paste that into the genesis transaction.

But if you don't care about getting access to the funds mined in the genesis transaction, you can leave the genesis transaction alone and simply change the nonce that is assigned to the genesis block.

If you're getting errors then please copy and paste the actual error messages into your question so that someone might be able to better understand specifically what you are doing wrong. My guess would be that your genesis block is fine and that the issue is related to aspects of setting up the daemon that are unrelated to the validity of your new genesis block. Therefore please document what you've tried, other than simply changing the contents of the genesis block.


Suggestions on how to consistently get more outputs? I've got a service that frequently runs out of outputs. For this service, sending a heavily split transaction back to my wallet is not practical. Ideally, I would want something like the my return output to be split up multiple times.

What are some other options I can use to get more outputs in my wallet?

Take a look at a response to issue #2351:

  You can send 50 monero 20 times in one tx to yourself (make sure you have set merge-destinations to 0 first). This will break up the 1000 output.
  Also set min-outputs-count and min-outputs-value to, say, 20 and 10, see the commit message for 0ad87db for an explantion of how they work. Last, you can pay several destinations in the same tx, which means no intervening change. Payment id is per tx, so if you have two payment ids, you have to make two txes at least. Just make the payout limit higher for people with a payment id.

Maybe that's what you are looking for.


How private is this transaction sequence? I buy BTC on Coinbase, let's assume that my BTC wallet address is publicly tied to my real identity.
I use ShapeShift to convert the BTC to XMR.
I receive the XMR in a wallet I've never used before on MyMonero
I send the XMR to someone else using MyMonero 'medium' privacy settings.

Is there any reasonable way someone could tell that the final XMR transaction was connected to me and if they could, how much would they know about who I sent it to and how much I sent?

If "someone" doesn't have access to any of the services, there's no way he can tell that the final TX is connected to you.

If "someone" had access to only ShapeShift data, he'd know to which Monero address you withdrew, and how much. He could suspect when you move those funds elsewhere but never be sure if it was you or it just so happened that someone else used your output as "decoy". Even if he assumed that you moved the coins, he'd have no way of telling to which address or how much. He'd just see that you maybe moved those (or part of, he can't tell) coins somewhere.

If "someone" had access to only MyMonero data (or forced MyMonero to collect whatever data it can), they wouldn't know from where your balance came. They wouldn't know who "you" are. The source and your ID would remain hidden. When sending, MyMonero could know the amount. If sending to a non-MyMonero user, they wouldn't know the destination address. If sending to a wallet also registered at MyMonero, they could also know the destination address.

If "someone" had access to both MyMonero and ShapeShift, they'd know who you are, how much you received and how much you sent. If sending to a non-MyMonero user, they wouldn't know the destination address. If sending to a wallet also registered at MyMonero, they could also know the destination address.

If "someone" got access to only recipient data, they wouldn't be able to trace it back to you. If they got the recipient data and ShapeShift data, they'd have a loose link but wouldn't be able to prove anything.

If "someone" got access to recipient, MyMonero and Shapeshift data, they could establish the link.

The only way to protect against someone coercing all involved services is to use an independent wallet instead of MyMonero and do some "churning" before sending to final destination. That way, even if someone had the recipient and ShapeShift data, you'd have fuzzed the trail enough to erase any suspicion.


How is monero different from byteball with being anonymous? Doing some research on monero vs byteball. What are the fundamental differences between these two?

Monero is private by default with published academic research analyzing RingCT and funded PhDs that continue to review and improve upon Monero privacy and security.
Byteball is public by default with claims of optional privacy via "Blackbytes" which AFAIK has received no scrutiny from academics.
According to their wiki

Blackbytes are defined as a private asset, meaning its never posted to the public Byteball database, it is ever only transferred when Byteball wallets have paired, private assets are sent encrypted through the Byteball network from device address to device address.
If blackbytes are traded on a centralized exchange, the exchange would have enough information to reveal the origin and destination of blackbytes, and amounts traded, which defeats their purpose.
Blackbytes hence can only be traded on decentralized exchanges, with conditional payments in the Byteball wallet. Peer discovery has to happen outside the Byteball wallet. Such an exchange is yet to appear (2017-May).

Monero is traded on many exchanges with all transactions private by default. Just like Byteball, Monero can optionally be used with Tor. Meanwhile Kovri development continues with plans for an eventual native Monero integration


Error using monero-wallet-rpc: No wallet file I am trying to use monerod and monero-wallet-rpc to run RPC commands to my Monero daemon with curl.

I have run monerod and monero-wallet-rpc in the following way:

1) ./monerod

...
You are now synchronized with the network. You may now start monero-wallet-cli.

2) ./monero-wallet-rpc --rpc-bind-port 28083 --wallet-dir monerowallet --disable-rpc-login

This is the RPC monero wallet. It needs to connect to a monero daemon to work correctly.
...
Starting wallet rpc server

3) curl -X POST http://127.0.0.1:28083/json_rpc -d '{"jsonrpc":"2.0","method":"getbalance","id":"test"}' -H Content-Type: application/json"

The response returns an error that the Monero wallet file cannot be found:

code: -13
message: No wallet file

What step am I missing? My wallet file monerowallet is in the same folder as monerod and monero-wallet-rpc

I was running the command with the wrong parameters. I should have used --wallet-file instead of --wallet-dir when running monero-wallet-rpc.

My corrected command:

./monero-wallet-rpc --rpc-bind-port 28083 --wallet-file monerowallet \
    --password mycoolpassword --disable-rpc-login


Error in synchronisation with monerod I had a problem with the synchronisation of monerod because when starting, it gives me this error:
--log-level 2

`2017-05-26 01:45:42.857 7f49065b6740 INFO net.p2p src/p2p/net_node.inl:545 Binding on 0.0.0.0:18080
2017-05-26 01:45:42.859 7f49065b6740 ERROR net contrib/epee/include/net/abstract_tcp_server2.inl:740 Exception at [boosted_tcp_server::init_server], what=bind: Address already in use
2017-05-26 01:45:42.859 7f49065b6740 ERROR net.p2p src/p2p/net_node.inl:547 Failed to bind server
2017-05-26 01:45:42.860 7f49065b6740 INFO global src/daemon/core.h:89 Deinitializing core...
2017-05-26 01:45:42.860 7f49065b6740 DEBUG miner src/cryptonote_basic/miner.cpp:325 Not mining - nothing to stop
2017-05-26 01:45:42.861 7f49065b6740 INFO txpool src/cryptonote_core/tx_pool.cpp:763 Received signal to deactivate memory pool store
2017-05-26 01:45:42.861 7f49065b6740 INFO txpool src/cryptonote_core/tx_pool.cpp:767 Memory pool store already empty
2017-05-26 01:45:42.862 7f49065b6740 ERROR daemon src/daemon/core.h:94 Failed to deinitialize core...
2017-05-26 01:45:42.862 7f49065b6740 DEBUG miner src/cryptonote_basic/miner.cpp:325 Not mining - nothing to stop
2017-05-26 01:45:42.862 7f49065b6740 INFO global src/daemon/protocol.h:77 Stopping cryptonote protocol...
2017-05-26 01:45:42.862 7f49065b6740 INFO global src/daemon/protocol.h:81 Cryptonote protocol stopped successfully
2017-05-26 01:45:42.862 7f49065b6740 INFO msgwriter src/common/scoped_message_writer.h:94 Daemon stopped successfully
Daemon stopped successfully
2017-05-26 01:45:42.862 7f49065b6740 ERROR daemon src/daemon/main.cpp:288 Exception in main! Failed to initialize p2p server.

`
Thank you

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


What is the importance of 'save' command in monerod? I am trying to sync the wallet using monerod (and was also playing with the commands) when i came to notice a "save" option when i type 'help'. what is the use of it or is there any use of it because the blockchain will be automatically saved by monerod, right?

The blockchain is indeed automatically saved.
This command ask to the underlying OS to write any cache to the disk immediately, when the OS has the ability to store data in cache before writing.
It's a security step you might need in extreme cases (like power loss and short UPS period).


Will Monero have unconfirmed transactions problems like bitcoin? Recently there has been many unconfirmed transactions with bitcoin resulting in transactions taking a lot of time to process (12 hours+). I was wondering if Monero would have the same problem in the future if there were many transactions? Would it have delayed transactions like bitcoin? Are there any solutions to deal with it that is in work or could work?

Thanks!

Bitcoin has a backlog because there's only so many transactions that can fit into their 1mb blocks.

Monero has an adaptive blocksize limit so in general it doesn't suffer from this problem.  There can, however, be periods where there is a backlog because the blocksize limit isn't increasing rapidly enough.

If a miner mines a block that is too large, compared to recent blocks, it will forfeit the blockreward.  If however the transaction backlog becomes large enough a rational miner will mine a big block anyway, because a large block full of fee-paying transaction can net more than the blockreward.


EXCEPTION FOR BLOCK 202612 , from what's it bassed and where it was fixed? who can  asnwer me this for litle qustion , i find  this at code

// EXCEPTION FOR BLOCK 202612
const std::string correct_blob_hash_202612 = "3a8a2b3a29b50fc86ff73dd087ea43c6f0d6b8f936c849194d5c84c737903966";
const std::string existing_block_id_202612 = "bbd604d2ba11ba27935e006ed39c9bfdd99b76bf4a50654bc1e1e61217962698";`

how was it calculated ' if it's new chain , this option need ? or this option only for fix some bug before hardfork ? and not need if used 6 ver hard fork ?

i want  udernstand what make this exception

There was a bug in the tree_hash function used to compute the transaction Merkle tree that caused the hash of block 202612 to be bbd604d2ba11ba27935e006ed39c9bfdd99b76bf4a50654bc1e1e61217962698 instead of the correct value 3a8a2b3a29b50fc86ff73dd087ea43c6f0d6b8f936c849194d5c84c737903966.

There is a comment in the file src/crypto/tree-hash.c about this:

// The blockchain block at height 202612 http://monerochain.info/block/bbd604d2ba11ba27935e006ed39c9bfdd99b76bf4a50654bc1e1e61217962698
// contained 514 transactions, that triggered bad calculation of variable "cnt" in the original version of this function
// as from CryptoNote code.
//
// This bug applies to all CN altcoins.
//
// Mathematical bug here was first published on 14:45:34 (GMT+2) 2014-09-04 by Rafal Freeman <rfree>
// https://github.com/rfree2monero/bitmonero/commit/b417abfb7a297d09f1bbb6de29030f8de9952ac8
// and soon also applied to CryptoNote (15:10 GMT+2), and BoolBerry used not fully correct work around:
// the work around of sizeof(size_t)*8 or <<3 as used before in 2 coins and in BBL later was blocking
// exploitation on normal platforms, how ever we strongly recommend the following fix because it removes
// mistake in mathematical formula.

As block 202612 has been accepted in the blockchain with the bad hash, this bad hash is now hard coded as the "official" one instead of the mathematically correct hash.


How do I import a large number of private keys into a wallet? I have a list of my private keys I generated, and I want to import all of them into SimpleWallet.

I have the Spend key, view key, address, and mnemonic from MoneroAddress' generations. I can format them differently if needed. I'd like to know how I can import many of these at once into SimpleWallet or any other wallet software.

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

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


If I send money with Simplewallet, it'll show that I've both sent and received funds. Why? Whenever I send funds with XMR and use the refresh command to check my balance, Simplewallet will show a number of transactions, some adding money to my account and some withdrawing money from my account. Why is this?

This is change coming back to your wallet. For instance, if you send 5 XMR, simplewallet might send that using a 10 XMR input, which it will then split and send 5 XMR to the person you are sending to, and send another 5 XMR output back to your wallet.

See section A, bullet 2 here for a bit more explanation in context:
https://getmonero.org/knowledge-base/protocol_explanation.html


Will Monero CPU mining always be feasible? Bitcoin mining, as far as I'm aware, hit a point where it can't be mined merely with a CPU, if you expect results.

Will Monero's mining remain constant (is "constant" even an appropriate term)?

The algrithim Monero uses, CryptoNote, has a POW mechanism that makes it hard for asic miners to be developed, so that CPU mining and GPU mining will remain the standard. But the difficulty of mining coins will not be constant.

"The proof of work mechanism acts as a voting system. Thus, it is crucial that during the voting process all the participants have equal voting privileges. CryptoNote brings this equality with its egalitarian proof of work, utilizing built-in CPU instructions, which are very hard and too expensive to implement in special purpose devices, but perfectly suitable for ordinary PCs." CryptoNote


XMR not showing up in my gui wallet after refreshing wallet I exchanged some BTC through ShapeShift, but my monero-wallet-gui never got the Monero. I followed the instructions here, and it didn't work. I did verify that I got the transaction confirmed and it should be there. The wallet just doesn't say so. I'm on the latest version of the software on a Mac running Sierra. (Haven't upgraded to High Sierra yet.)

Right now, I've switched to local node (from a remote one) and I'm waiting for it to sync in hopes that it will resolve the situation. (Is there any way to speed up the sync? What I need the XMR for is a little time sensitive.)

But, from my research on GitHub and other places, I should be able to see my balance when I switch to a remote node. What can I do next to resolve this issue?

Okay, so it did get solved, by just waiting for the local node to sync completely. This was weird because I would have thought that using a remote node would be sufficient. I just had to wait a day. (Longest day ever!)


CoinHive javascript doesn't seem to work I recently made a localhost website to easily mine Monero using my home computers. With CoinHive and the JavaScript miner (without the opt-in screen), I don't see my processor usage go up at all, although, if I use the authedmine miner, the usage increases to 100%.

this is the code that I use to start the opt-in miner...

<script src="https://authedmine.com/lib/authedmine.min.js"></script>
<script>
    var miner = new CoinHive.Anonymous('PUBlIC KEY ENTERED HERE...', {
        throttle: 0,
    });
    miner.start();
</script>

When the code above is used, the website asks for mining permission and when pressed allow, it starts mining and the processor usage goes to 100%

<script src="https://coinhive.com/lib/coinhive.min.js"></script>
<script>
    var miner = new CoinHive.Anonymous('PUBLIC KEY ENTERED HERE...', {
        throttle: 0,
    });
    miner.start();
</script>

But when this code is entered, the only thing I changed is the link to the miner javascript location, the processor doesn't go to 100% utilisation and my CoinHive dashboard doesn't show a hash rate.

Am I doing something wrong here?

Any help or suggestions are warmly welcomed,
Thanks,

Sid.

Your browser might be blocking it, unfortunately some people abused this miner that is a great alternative to ads in my opinion however didn't inform users to this occurring leading to some browsers blocking the miner.

Source: https://www.wired.com/story/cryptojacking-cryptocurrency-mining-browser/

Archived link: https://web.archive.org/web/20171229133832/https://www.wired.com/story/cryptojacking-cryptocurrency-mining-browser/


How is Monero's network less secure than Bitcoin? How is Monero's network less secure than Bitcoin's network? Are there any plans in work to increase the security of Monero's network and will it ever match Bitcoin's network or surpass it?

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

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

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

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


How does RingCT work with / without coefficients? I was trying to get more information on how RingCT works, I found the thread I linked to below here on the stack exchange. In the other thread, the most upvoted answer explains it as a coefficient, but then others say there is no coefficient for ringCT, so how does it work if there's no coefficient there?

I quote @samsunggalaxyplayer's question which I would like the answer to as well:

  "If RingCT does not use coefficients, then what does it use? Is there
  a noticeable difference in average reported amount of a transaction of
  10 XMR and 10000 XMR?"

I appreciate your help understanding this!

Here is the link to the older thread I was referring to:
ELI5: How does RingCT work?

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

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


How do I get the TX Key from the GUI Wallet? I'm trying to verify a payment but I'm not sure how to get the TX Key from my history on Monero Wallet GUI.

First note that you can only obtain the private tx key for outgoing transactions, because it's randomly generated by the sender. In the GUI, first go to History tab. Subsequently, you can obtain the private tx key by clicking on Details of the relevant outgoing transaction.

Lastly, bear in mind that if you have to rebuild your wallet cache (after you, for instance, deleted it) you'll lose your private tx keys.


Can I use the GUI wallet over SSH? I SSH into a Linux 16.04.2 LTS box, where I run monerod and monero-wallet-cli from the command line.  Can I run the GUI similarly?  Do I need to I need to add any args to the ssh command?  Do I need to add any args to the monero-wallet-gui command?

Just change :

ssh XXXXXXX

with :

ssh -L18081:127.0.0.1:18081 XXXXXXX

This means : open a local port 18081, and redirect all messages to 127.0.0.1:18081 in the remote host.

This will be exactly like running monerod in your local computer. So just use the default host in monero-wallet-gui, which is 127.0.0.1


Missing 1 character in Monero address generation from a seed using Javascript I have an interesting one off case with a Monero address generation where I am generating a 94 character Monero address vs 95 characters. However when I take the private_spend_key and run it through the monero_wallet_cli I get the full 95 characters. The address generated by the JS is this:
43pQ9h9F7KBFgDpFB1aa9ZAvqbxXa7zixfuFAUoybXzbnsy89jVH4YUG8Wwn1BzSFir8WGMkxHpq91XVNhcaaF27UsGFQw
But when creating it in the cli wallet I get this:
43pQ9h9F7KBFgDpFB1aa9ZAvqbxXa7zix1fuFAUoybXzbnsy89jVH4YUG8Wwn1BzSFir8WGMkxHpq91XVNhcaaF27UsGFQw
Notice the mising "1" before fuFaU
I'm not sure what is causing this issue to create a one off case of a malformed Monero address creation.
My code is in javascript with the following:
function keyToMonero(seed) {
seed = [ 26, 248, 94, 251, 77, 236, 73, 191, 132, 172, 51, 247, 227, 152, 99, 247, 97, 252, 142, 34, 29, 184, 192, 129, 53, 217, 217, 3, 145, 230, 103, 254 ];

  var private_spend = reduce32(seed);

console.log('private_spend');
console.log(private_spend);
console.log(private_spend.toString('hex'));
  var private_view = reduce32(keccak256(private_spend));
console.log('private_view');
console.log(private_view);

  // Hack
  var kp = ed25519.keyFromSecret()
  kp._privBytes = Array.from(private_spend);
  var public_spend = Buffer.from(kp.pubBytes());
  var kp = ed25519.keyFromSecret()
  kp._privBytes = Array.from(private_view);
  var public_view = Buffer.from(kp.pubBytes());

  var address_buf = Buffer.concat([Buffer.alloc(1, 0x12), public_spend, public_view])
  console.log('address_buf 1');
  console.log(address_buf);
  address_buf = Buffer.concat([address_buf, keccak256(address_buf).slice(0,4)]);

  console.log('address_buf 2');
  console.log(address_buf);

  var address = ''
console.log('Correct XMR Address:');
console.log('43pQ9h9F7KBFgDpFB1aa9ZAvqbxXa7zix1fuFAUoybXzbnsy89jVH4YUG8Wwn1BzSFir8WGMkxHpq91XVNhcaaF27UsGFQw');
  for (var i = 0; i < 8; i++) {
    address += bs58.encode(address_buf.slice(i*8, i*8+8));
    console.log('length'+ address.length);
    console.log(address_buf.slice(i*8, i*8+8));
    console.log(address);
  }
  address += bs58.encode(address_buf.slice(64, 69));

  console.log('length'+ address.length);
  console.log(address);

  return {
    private_spend: private_spend.toString('hex'),
    private_view: private_view.toString('hex'),
    public_spend: public_spend.toString('hex'),
    public_view: public_view.toString('hex'),
    public: address
  }
}

My console log output looks like this from the above code:

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


Mining drops to 0 H/s for hour I am mining monero by xmr-stak-cpu on pool pool.supportxmr.com:5555. My problem is that hashrate sometimes crash to 0 H/s for about hour while CPU usage still be about 99%.

At the time in log appears

[2017-10-23 20:10:51] : Result rejected by the pool.
[2017-10-23 20:10:51] : Your miner was unable to find a share in time. Either the pool difficulty is too high, or the pool timeout is too low.
[2017-10-23 20:10:51] : SOCKET ERROR - RECEIVE error: socket closed
[2017-10-23 20:10:51] : Pool connection lost. Waiting 10 s before retry (attempt 1).
[2017-10-23 20:11:01] : Connecting to pool pool.supportxmr.com:5555 ...
[2017-10-23 20:11:01] : Connected. Logging in...
[2017-10-23 20:11:01] : Difficulty changed. Now: 5000.
[2017-10-23 20:11:01] : New block detected.

Is there any option how to fix that?

The hash rate dropping to 0 is as measured by the pool, not your miner. The pool hash rate can and usually is different from what your miner will display, because the hashrate on the pool side is estimated based on the hashes you have submitted.

Because the difficulty of the port you are on is a bit high for your CPU hash rate (I estimate from the graph your actual hash rate is between 30-40 hashes per second), this causes your CPU to not find a valid share for a while, which makes the pool believe that you are hashing at 0. This is also what is causing the timeout in your connection.

The solution for this would be to move to a lower difficulty port, then your hashrate graph will be more consistent and closer (but still not 100% accurate) to the hashrate displayed in your miner.


What's the point of ring signatures if stealth addresses hide the actual addresses anyways? I understand generally how ring signatures work, but I also realize they are sent to and from stealth addresses, and so I'm curious why ring signatures are needed in the first place. Doesn't a sender's stealth address make the transaction untraceable anyways?

Stealth addresses mask a receiver, so 5 different people could all send XMR to the same address, but the construction of stealth addresses is such that none of the 5 people could tell that any of the other 5 people sent XMR to the same address. All they would see are five outputs to five random stealth addresses, and they only know the true address that their own transaction was sent to.

If we extend this to more people, they could all be sending coins between one another (B to D, D to A, C to E, E to B, etc) but no one would be able to tell any other pairs by looking at independent transactions (B couldn't see D and E even if B has traded with both D and E separately).

Ring signatures mask which outputs are used as inputs to create a new transaction output. So extending our previous example, ring signatures would hide when (if ever) any of those five outputs are spent. They do this by essentially saying "one of these X outputs is being spent as an input into a transaction, but you can't tell which one." This prevents anyone from knowing when an output is spent.

In addition, ring signatures prevent linking of multiple stealth outputs that are combined as multiple inputs into a transaction. Without ring signatures, you could tell "these X outputs are all from the same person" while ring signatures obfuscate that.

With stealth addresses, you can't link two different transactions to the same address, but you can link the path of outputs. aka, A to B to C to D. So if I send you coins, I could tell when you then spend them. Ring signatures block this by making the source of a transaction be "either A or G or K or P" instead of "definitely A", etc.

Example:

Putting all this together, this means that if person A spends outputs "aa" and "ab" to send coins to person B as new output "bb", and then person B spends output "bb" and some other output "bc" to send coins to person C as new output "cc", each person involved could only see the following bits of information:

Person A:

Outputs "aa" and "ab" were spent, send to the address of person B, as new output "bb".
I included outputs "ff", "hh", "kk", and "oo" in the ring signature for "aa" and "fg", "hi", "kl", and "op" for the signature for "ab".
No idea what happens to "bb"... there's a tx that included it in a ring rignature to output "cc", but there are also txs that included it to output "dd", "qq", "tt", and "zz". Maybe one of those outputs have the coins now?

Person B:

Some coins from somewhere (the ring signature says it's either "aa", "ff", "hh", "kk", or "oo") and other coins from somewhere else ("ab", "fg", "hi", "kl", and "op") are now my output "bb".
I spent them when I sent coins to person C as output "cc".
I included outputs "dd", "ee", "ii", and "jj" in the ring signature.
I also spent output "bc" which became part of "cc" as well. "bc" was ringed with "de", "ef", "ij", and "jk" to hide the origin.
I can't tell if they've been spent, but they have been included in these tx ring signatures: "rr", "ss", and "uu". So maybe he spent them.

Person C:

Some coins from somewhere (either "bb", "dd", "ee", "ii", or "jj") and somewhere else ("bc", "de", "ef", "ij", or "jk") were sent to me and are now my output "cc".
I haven't spent them, but my output was included in ring sigs txs "rr", "ss", and "uu" so now Person B doesn't know if I still have them ;)