Monero Hash, how does it work, C++ basisc

piHashVal = (uint64_t*)(result.bResult + 24);
result.bResult is a pointer to some data structure, it's storing the memory address at which the structure begins. We're not interested in the beginning of that data blob, but want to access some 64-bits starting at  offset 24. The above expression increments the address by offset 24 and casts the result to pointer to uint64_t. This means that the expression *piHashVal will return value of those 64-bits, interpreted as unsigned int. Note about the offset, how much bytes it offsets will depend on the type of pointer result.bResult. See also: Pointer Arithmetic for Structs

piNonce = (uint32_t*)(oWork.bWorkBlob + 39);
This does similar, only we're taking the 32-bits starting at offset 39 from beginning of oWork.bWorkBlob data structure.
*piNonce = ++result.iNonce;
Increment the result.iNonce by 1, and assign the resulting value to *piNonce which is the data stored at memory address piNonce. Note that both variables result.iNonce and *piNonce are changed here. By doing this, we surgically changed some 32-bits in the oWork.BworkBlob data structure since the piNonce points to a part of it and we accessed that part directly with *piNonce.
if (*piHashVal < oWork.iTarget) {
    executor::inst()->push_event(ex_event(result, oWork.iPoolId));
}

So here we compare those 64-bits from the start with the target. We're accessing the value *piHashVal stored at memory location piHashVal.
Appendix - Pointer Example
#include <stdio.h>
#define ARLEN 2

int main(void)
{
    unsigned long a[ARLEN];
    unsigned long *b;
    unsigned char *c;

    for(int i=0; i<ARLEN; ++i)
        a[i] = 100 + i*100;

    b = &a[0];
    /* Note that b = a is equivalent to the above expression, because when a is
     * declared as an array it becomes a pointer but the memory block for the array
     * is allocated at declaration as well. The [] is also known as offset operator.
     * and can be applied to any pointer.
     * After the above assignment, a[i] and b[i] will be equivalent.
    **/

    c = (char*) b;

    printf("Accessing using offset operator:\n");
    for(int i=0; i<ARLEN; ++i)
        printf("a[%d] = %lu = 0x%02X;\n",i,a[i],a[i]);

    printf("Accessing using dereference operator:\n");
    for(int i=0; i<ARLEN; ++i)
        printf("*(b+%d) = %lu = 0x%02X\n",i,*(b+i),*(b+i));

    printf("Reading individual bytes of the array using char pointer:\n");
    for(int i=0; i < (ARLEN*sizeof(long)/sizeof(char)); ++i)
        printf("*(c+%d) = %hhu = 0x%02X;\n",i,*(c+i),*(c+i));

    printf("Setting odd bytes to 0xFF:\n");
    for(int i=0; i < (ARLEN*sizeof(long)/sizeof(char)); ++i)
    {
        if (i%2==1)
            *(c+i)=0xFF;
        printf("*(c+%d) = %hhu = 0x%02X;\n",i,*(c+i),*(c+i));
    }

    printf("Printing the modified long array:\n");
    for(int i=0; i < ARLEN; ++i)
    {
        printf("a[%d] = %lu = 0x%02X;\n",i,a[i],a[i]);
    }
    return 0;
}

Program output (compiled on x86-64 system):
Accessing using offset operator:
a[0] = 100 = 0x64;
a[1] = 200 = 0xC8;
Accessing using dereference operator:
*(b+0) = 100 = 0x64
*(b+1) = 200 = 0xC8
Reading individual bytes of the array using char pointer:
*(c+0) = 100 = 0x64;
*(c+1) = 0 = 0x00;
*(c+2) = 0 = 0x00;
*(c+3) = 0 = 0x00;
*(c+4) = 0 = 0x00;
*(c+5) = 0 = 0x00;
*(c+6) = 0 = 0x00;
*(c+7) = 0 = 0x00;
*(c+8) = 200 = 0xC8;
*(c+9) = 0 = 0x00;
*(c+10) = 0 = 0x00;
*(c+11) = 0 = 0x00;
*(c+12) = 0 = 0x00;
*(c+13) = 0 = 0x00;
*(c+14) = 0 = 0x00;
*(c+15) = 0 = 0x00;
Setting odd bytes to 0xFF:
*(c+0) = 100 = 0x64;
*(c+1) = 255 = 0xFF;
*(c+2) = 0 = 0x00;
*(c+3) = 255 = 0xFF;
*(c+4) = 0 = 0x00;
*(c+5) = 255 = 0xFF;
*(c+6) = 0 = 0x00;
*(c+7) = 255 = 0xFF;
*(c+8) = 200 = 0xC8;
*(c+9) = 255 = 0xFF;
*(c+10) = 0 = 0x00;
*(c+11) = 255 = 0xFF;
*(c+12) = 0 = 0x00;
*(c+13) = 255 = 0xFF;
*(c+14) = 0 = 0x00;
*(c+15) = 255 = 0xFF;
Printing the modified long array:
a[0] = 18374966859414962020 = 0xFF00FF64;
a[1] = 18374966859414962120 = 0xFF00FFC8;


Conceptually speaking, there are still only 2 types of tunnels : client and server.

But the idea is that we can do "better" for a specific application/protocol by leveraging some of its characteristics.

So http is a specialization of a server tunnel for the HTTP protocol, and likewise, irc is a specialization of a client tunnel for the IRC protocol.

Currently, there is no distinction between irc and client. There is this open ticket for this task.

AFAICT, here is the only distinction between http and server : it looks like it's used to dynamically change the Host parameter in the header of an HTTP request.


401 HTTP error is defined as UNAUTHORIZED error meaning you don't have the permission to call the RPC API.

At the moment, Monero Wallet RPC requires authentication by default, username is: monero , password is a randomly generated string.

To disable the login: add the --disable-rpc-login flag to the command line.

If you want to specify a username and a password, add the --rpc-login username:password where username is your username and password is your password.


How much larger would a mixin=4 Monero transaction be compared to a Bitcoin transaction?

Well, looking at a few transactions gives you the answer quite plainly, at least for the Monero side. I'm not familiar with Bitcoin transaction sizes, but I think they're a few hundred bytes, typically.

A small tx, 4 inputs and 4 outputs: 1692 bytes.
http://moneroblocks.info/tx/f634025ef2d0fd0836ce2a5207e782609c3250cd5f8a0dd5269ce4e5c2f71bb7

A large tx, 21 inputs and a whopping 40 outputs: 9464 bytes.
http://moneroblocks.info/tx/069884b2ff99fb9b9a3f026d51c204c2abf5e23e23b6ce5c8fc73245cf81f67a

With RingCT, transactions will start at about 6.7 kB, and typically increase not a lot from there, since most transactions are expected to be 2 inputs and 2 outputs, typically. A RingCT tx with 2 inputs, 2 outputs, and mixin 4 looks like about 13 kB. Interestingly, making it mixin 85 only takes it to 24 kB, which means a large increase in privacy only takes 50% more space.


What exactly are bulletproofs replacing in monero?

Bulletproofs are used to prove that the amounts in confidential transactions are in range, so you can't do underhanded things like creating negative amounts. They replace Borromean range proofs. They are smaller in size, and faster to verify, though slower to generate. As used in Monero, they are unrelated to ring signatures, but are part of RingCT, since RingCT uses confidential transactions, and thus range proofs.

Amounts are hidden by Pedersen commitments.

Senders are hidden by ring signatures.

Recipients are hidden by stealth addresses.


Add an address to the wallet CLI with a payment ID

The syntax is (see the emphasis):

address_book [(add (<address> [pid <long or short payment id>])|<integrated address> [<description possibly with whitespaces>])|(delete <index>)]
                               ^^^

So you need to identify the payment id with pid - in your case it would look like:

address_book xxx pid yyy recipient


To allow inbound connections to the daemon p2p and the RPC (assuming default ports are used), you would need:

--rpc-bind-ip 0.0.0.0
--confirm-external-bind

And ensure your firewall allows inbound connections on ports 18080 and 18081.

If you are behind a router, that would also need configuring to forward traffic on those ports to your machine running the daemon.

Note, you may also want to add the login option for the RPC:

--rpc-login arg                       Specify username[:password] required
                                      for RPC server

And if you want to allow javascript access:

--rpc-access-control-origins arg      Specify a comma separated list of
                                      origins to allow cross origin resource
                                      sharing


Is there any way of changing the password of an existing wallet?

This answer depends on whether your .keys file was compromised as well. If an attacker knows your password and somehow has access to your .keys file he will be able to steal your funds. However, if he only knows your password and doesn't has access to your .keys file he won't be able to steal your funds. In the former scenario you should send your funds to a newly created wallet with a new password. In the the latter scenario you could restore your wallet with the 25 word mnemonic seed. It will then ask you for a new wallet name and you can choose a new password. Restoring is done as follows:

Linux and Mac OS X

./monero-wallet-cli --restore-deterministic-wallet

This should be done from the terminal from the directory of monero-wallet-cli itself.

Windows:

monero-wallet-cli.exe --restore-deterministic-wallet

This should be done from the command window from the directory of monero-wallet-cli itself.

Lastly, bear in mind that with the 25 word mnemonic seed is able to bypass any password set on the wallet. Thus, you should keep this somewhere safe.


Why is monerod not connecting to any peers?

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

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


Copied blockchain and gui still saying syncing for aeons

There are two synchronizations that happen.  The daemon needs to synchronize the blockchain with the network.  It sounds like you did that, and then you transferred the blockchain to another computer.  The next sync is the wallet syncing with the blockchain, where it scans for transactions that belong to it.

If you didn't specify a starting height, the wallet will scan all blocks to ensure there are no outputs destined for it.  If you were to have specified a starting height - since you knew the address was just created - the wallet would have only started scanning at that height, and therefore been done very quickly.


"transferFee" should be set to 0, as it's an obsolete setting: the wallet will calculate the fee for this transaction based on its size.

"minPayment" is the amount of monero a miner should reach before a payment is made.

"denomination" is the granularity of the payment made. That is, payments will be made in multiples of that number (most likely leaving some unsent small amount in the miner's pending balance).

Note that all amounts above are expressed in atomic units, of which there are 1e12 per monero. For example, 1 monero is 1000000000000, 0.1 monero is 100000000000, etc.

To give a more real world example of minPayment and denomination, you could compare it to a scheme where you pay someone, but only using fairly large coins. For instance, with 0.10 coins, if the person you're paying has a balance of 0.46, you can pay 0.4 (4 coins), and the remaining still unpaid balance is 0.06.

With RingCT, denomination does not matter anymore, since amounts are not decomposed in several outputs anymore, so there is no dust problem. Therefore, denomination can be set to 1.


How to go back to previous command when using monero cli?

If readline commands aren't working, there are two possibilities:

you build without readline enabled (it's optional). Check libreadline-dev or equivalent package is installed (ie, the headers are usually missing when a basic package is installed on many distros)
you have a bad ~/.inputrc - much less likely, but try moving it out of the way if you've really built with readline enabled.


Is automated churning of XMR bad for privacy?

Is this bad for privacy?

Yes. Performing a churn (or any transaction for that matter) at regular intervals is bad for privacy (for yourself and others to some degree).

You are essentially helping to create a linkage by exposing the likely true output in a ring (thus also exposing the likely decoys), based purely on the timing of the transactions.

  Also, if I churn like 20 times in a row, am I helping myself or other users on the network by adding entropy to the transaction pool?

A single churn can be useful for yourself in certain circumstances (like after receiving money from a centralized exchange). And whilst every transaction on the network increases the entropy set, the increase is so negligible, one shouldn't go around patting themselves on the back thinking they are "helping the network". Normal usage is fine.


You can add this line of code in the first line of the get_block_reward function for premine, set  the reward of your choice

 if(already_generated_coins == 0) {
       reward = 4000000;
       return true;
    }


In finder hold down cmd and shift then the period.  The period toggles hidden files that start with a '.' like '.bitmonero'.


sc_add - scalar add - is taking two big numbers, which are stored as binary in byte (char) arrays and returning the result of adding them together in another byte array, mod the order of the base point.

The function has to use byte arrays because the largest type for native numbers in C/C++ is 64 bits, hence if you want to add two 256 bit numbers you need to 1) store these numbers as byte arrays and 2) use shifting and ANDing to perform the calculation.

int64_t a0 = 2097151 & load_3(a);

Is taking 3 bytes pointed at by a and taking the lower 21 bits.

int64_t a1 = 2097151 & (load_4(a + 2) >> 5);

Is taking 4 bytes pointing at by a + 2 (so not the same bytes as the previous line), shifting the bits down 5 places and then taking 21 bits.

  Why not just add like 'a' + 'c' = 'd' (and 'z' + 'a' = 'a')

Ignoring the fact that in C that 'a' + 'c' = 'd' is incorrect, the reason you can't just use operators like +,-,/,% is because the numbers we are operating on are too big (as I outlined at the beginning). This, and many other of the crypto functions, are highly optimized math operations on large numbers for 32/64 bit systems.


Where are the monero-core configuration parameters stored?

The monero-core configuration is stored in the following places:

Linux (File) :

/home/xxx/.config/The Monero Project/monero-core.conf

Windows (registry key) :

Computer\HKEY_CURRENT_USER\Software\The Monero Project\monero-core

OS-X (File) :

$HOME/Library/Preferences/org.getmonero.monero-core.plist


How can I set a payment ID of 64 characters hex on wallet cli?

Payment ID is really a message attached to the TX. Usually it's only important when sending to exchanges, services etc. because they use just one address for receiving funds from different users and PID is the only way they can tell them apart.

Sending

If you're sending to an integrated address then just use: transfer [address] [amount]. You can recognize it's an integrated address because it's longer (106 characters vs 95 in regular)

If you're sending to a regular address + payment ID, then be sure to use: transfer [address] [amount] [paymentID]. Don't forget the payment ID in this case!

Receiving

If you want to receive something with the PID attached, use integrated_address and give it to your sender. It will generate a random 16-digit PID and encode it together with your regular address into the integrated format. Then, you'll be able to tell apart incoming payments by using payments [PID] command to filter according to payment ID.

To receive something with 256-bit PID, just generate random 64 hexadecimal "digits" by any means you like! Then give both your regular address and the payment ID to the sender, and he must be sure not to forget to attach it in the command when sending. That's why integrated format is more convenient.


Multi VPS servers with monero installed for remote connections. Monero Gateway Redirection?

you can setup a load balancer using tomcat or nginx.
round robin will choose a random host to forward your request to.
you can setup what's called a health check to add and remove hosts as they fail. a health check makes a request to your hosts behind the load balancer to for example /get_info, if it doesn't receive a response then it know it's not healthy.

You'll have to do a lot of this research yourself on the exact steps. This is definitely outside the scope of monero.


What does the Monero wallet do during I/O bound initial sync?

It's verifying transactions for blocks past the set of known hashes (past 1.2 million), and storing tx and block data in the database. It can also be serving some blocks to others, but that's typically not much compared to the load from syncing. If you have a wallet connected, the wallet will also compete to get the blockchain lock so it can refresh blocks. It's best to keep the wallet off while syncing.

Monero uses LMDB, a fast key/value database, but writing new data to the database isn't just appending the block blob at the end of the file, as it is structured, with some tables being sorted in a tree.

As for moving the database once done, it's as simple as stopping the dameon and copying the data.mdb file. It's platform independent except for endianness.


What will the Monero Research Lab be working on in the future, after RingCT has released?

Monero Research Lab Publications MRL-0001 to MRL-0005 have been published.

MRL-0006 - Difficulty Adjustment Algorithms in Cryptocurrency Protocols
have been started.
According to fluffypony

  The difficulty research that Surae was working on is quite extensive, but incomplete.

EDIT: as of November 17th, it appears MRL-0006 will be renamed MRL-0007.

  Someone would have to pick it up and run with it, as Surae is basically burnt out on difficulty and has moved on to other challenges:)

A version of MRL-0008 - Ring Multisignature exists but is not published yet.


I believe this refers to hashes - it does 39 hashes for you and 1 hash for the developer, regardless of whether the hashes are valid or not. As Claymore is closed source, we can't easily verify this, but from what I have seen running the miner it seems like the most likely explanation.


Querying wallet RPC about whether a wallet is view-only?

I'm thinking about using query_key command with key_type=mnemonic. Is it safe to assume that if the command fails to return a mnemonic, the wallet is view-only?

Yes.

  I'm guessing this is not the best way, because the documentation mentions that older wallets do not have a mnemonic.

It's the only way if you need to check though. The likelihood of such an old wallet I would guess is low due to the fact people actually using monero will have been upgrading.

With all this said, I find it difficult to understand the need to check if a wallet is view-only. The moment you try to spend from a view-only wallet you'll get an error and know then.


start-mining with monerod doesn't seem to turn on mining

I don't think you can start mining until fully synced.

Start monerod without the --start_mining, and just start it once it syncs.

show_hr / hide_gr in monerod will show / hide your mining hashrate.


30 days before the fork there will be a code freeze + tag + release, If there are no major changes there will at least be an increase in the protocol version. A similar fork system to Bitcoin will apply, whereby a rollover to the new code after the trigger block will only occur if a sufficient number of miners are running the new code.
I am not aware of a wallet or daemon notification system that would provide advance notice. Of course if an old client fails to upgrade and is forked from the network, new blocks will no longer be consistent with those found on Monero block explorers or other clients that have upgraded. Currently it is up to Monero users themselves to upgrade in time. Community members and developers have assumed the responsibility of contacting exchanges and mining pools in the past to remind them of forks but cannot guarantee compliance. In the past there have been a few known service providers that were late in updating (ie. Shapeshift) but updated shortly afterwards. It is suspected there may have been one or more botnets that were taking off line after enforcement of the LMDB fork.
Everyone received 1 hard fork's grace period before you have to update or are kicked off the network (or left on an old fork). Just like your OS security software users are expected to remain up to date. There is no goal to support old upgraded clients for longer than the grace period described.

In terms of what is a hard fork (following the above procedure) vs what is a soft fork:

  Anything that is more of a soft fork will kick in immediately (as long as it doesn't drop pre-fork clients off the network). Anything on the p2p layer (ie. hard forkable) will be kept in the wings until the next fork date (as roughly estimated from block height) and then is enabled.


Installed the monero gui client for windows. How do I join a pool to mine?

The official monero client only supports solo mining as far as I know. You will need to download a different CPU miner for monero to connect to a pool. xmr-stak-cpu is a good one.
You can find that here: https://github.com/fireice-uk/xmr-stak-cpu

I've always used linux for cpu-miners and compiled it from source. It looks like there is a windows .exe file hosted there, but you still might need to install a c++11 compiler.


Yes, it's possible to mine on XMR-Stak with CPU, AMD GPUs and Nvidia GPUs in the same system at the same time. Take a look at Monero Mining Wiki on Reddit for more info on building a Monero mining rig and how to configure software.

In your case, the problem isn't mATX board, but how many PCI-E slots on it. Supposing that you're using the only full-size PCI-E x16 slot, maybe you have some PCI-E x1 slots free and you can use them with risers to add other cards to your rig.

If you plan to go big in mining, also a motherboard with many PCI-E slots could be helpful and you will need some risers. Get the ones that fit in a PCI-E x1 slot, since they also fit in the larger PCI-E x16 slots. Lastly, Nvidia 1070 and AMD RX 580 are nice cards for Monero mining and a good starting point for sure, I will remain with them.


How does one convert the Trezor seed to a simplewallet seed and vice versa

In the experimental binaries, which can be found here, NoodleDoodle included a tool called trezorctl. With this tool you can convert your Trezor mnemonic seed to a mnemonic seed compatible with simplewallet. Thus, using this tool allows you to, after conversion, restore your wallet using simplewallet. The tool works as follows. Note that <word_list> is your 24 word Trezor mnemonic seed. On Linux and Mac OS:

./trezorctl recover_mnemonic <index> <passphrase> <language> <word_list>

On Windows make sure to launch it from the command line. Go to the folder monero-cli-wallet is located and make sure your cursor isn't located on any of the files. Subsequently do SHIFT + right click and it will give you an option to "Open command window here". Lastly, type the following command:

trezorctl.exe recover_mnemonic <index> <passphrase> <language> <word_list>

The default language is English for seeds. Note that simplewallet also supports Spanish, German, Italian, Japanese, Russian, and Portugese. Lastly, the trezorctrl output looks like this:

USAGE: trezorctl recover_mnemonic index passphrase language word_list
            Supported languages:
            English
            Spanish
            German
            Italian
            Portuguese
            Russian
            Japanese


What is a reliable Monero remote nodes that is used in the CakeWallet mobile app?

You can use the following cakewallet remote nodes as used in the mobile wallets:

East coast:
xmr-node-usa-east.cakewallet.com:18081

West coast:
xmr-node-usa-west.cakewallet.com:18081

If your using the monero wallet cli command, you use it like this:

./monero-wallet-cli  --wallet-file=MY_WALLET_FILE --daemon-address
xmr-node-usa-east.cakewallet.com:18081


As I understand, the next Monero release will include an option to connect to the network over I2P.

Actually the current release has experimental options to use over i2p/tor. Work is underway on the GUI to add support there too, which should greatly simplify the usage (e.g. just ticking a checkbox to send transactions over i2p/tor).

  ...what do I need to do to make the node run over the I2P network instead?

Firstly, I'd encourage reading of the documentation so you are familiar with how it works.

Then the steps required essentially boil down to the following:

Run an i2p router, such as the extremely light-weight i2p-zero.
Configure a SOCKS tunnel at the router to forward outbound traffic over i2p.
Configure a server tunnel at the router to accept incoming connections from the i2p network and forward them to a local service (which will be your monerod node below).
Run monerod with the appropriate flags:

You need to use --proxy i2p,127.0.0.1:9000 (replacing 9000 with whatever SOCKS port you configured for your i2p SOCKS tunnel in step 2 above). This is for your nodes outbound connections to i2p destinations.
If you know any other i2p Monero peers, add them with --add-peer address.b32.i2p:28083 (replacing the address and port with their long hex i2p address and port). If you don't add any i2p peers, you cannot relay transactions over i2p or discover other Monero peers on i2p.
You need to use --anonymous-inbound address.b32.i2p:28083,127.0.0.1:28083 (replacing the address and port with the server tunnel address and port created in step 3 above). This is for your inbound connections from i2p.

You should now have an up-and-running Monero node that can handle both inbound and outbound i2p traffic. It will sync blocks over clearnet and relay transactions over i2p.


How do I sell Monero for USD if I start from the Monero in my wallet?

You can also use a service like LocalMonero to sell the Monero directly to someone for cash if that is your preference.


A monero address includes a 32 bit checksum, so assuming the checksum is randomly distributed over the whole space, you get one match over about 4 billion, or 0.000000023283% chance of the checksum matching by pure chance.
However, all 95 character strings do not represent a valid address in the first place, so a failure to decode as base58 will also get an invalid address rejected.

If the address is invalid, you don't lose your monero, it just doesn't get sent. If it's a valid address to which you do not have the private keys (or do not know who does, or that person/entity is not willing to send back), then you do lose your monero.


Are the blocks mined by a wallet shown as transaction?

They do show as transactions. Special types of transaction with a dummy input (since noone's actually spending any monero) and one or more outputs (usually just one, pre-rct coinbase transactions have more than one).
Example on testnet:
Height 1635197, txid <0e74095b092051a9742a36a09b6a550137132504579101062ddb2e973f837344>, 2.822135419737, idx 0/0
Height 1635198, txid <fced7485c1ee265132c5a910986b2c48b123f0c58609f61a107e7db73e4b71d8>, 2.822130036941, idx 0/0
Height 1635199, txid <775200145a2cd4891334c6181e07b9f1227b2213eb04265dc77b188210c8bdf0>, 2.822124654155, idx 0/0

These are all new blocks. With show_transfers, they show as "block" type rather than "in":
 1635197  block  40 blks       2021-01-19 14:20:31       2.822135419737 0e74095b092051a9742a36a09b6a550137132504579101062ddb2e973f837344 0000000000000000 0.000000000000 9yvGzysbcaWPHNjzkdKTMy5E7uvf85eNtZmuDQ3FLJrq3TeMy9cEaEi5CK7FqXNboWKHBvLGAxHFB5gq8KpSxmgJPah9MJc:2.822135419737 0 -
 1635198  block  41 blks       2021-01-19 14:20:55       2.822130036941 fced7485c1ee265132c5a910986b2c48b123f0c58609f61a107e7db73e4b71d8 0000000000000000 0.000000000000 9yvGzysbcaWPHNjzkdKTMy5E7uvf85eNtZmuDQ3FLJrq3TeMy9cEaEi5CK7FqXNboWKHBvLGAxHFB5gq8KpSxmgJPah9MJc:2.822130036941 0 -
 1635199  block  42 blks       2021-01-19 14:20:55       2.822124654155 775200145a2cd4891334c6181e07b9f1227b2213eb04265dc77b188210c8bdf0 0000000000000000 0.000000000000 9yvGzysbcaWPHNjzkdKTMy5E7uvf85eNtZmuDQ3FLJrq3TeMy9cEaEi5CK7FqXNboWKHBvLGAxHFB5gq8KpSxmgJPah9MJc:2.822124654155 0 -

If show_transfers shows nothing, this is either because your wallet has not sent/received anything, or because it has not scanned the chain (or only part of the chain).


Why is the wallet-GUI Payment ID field not accepting an ID?

The problem occurs with integrated addresses. Because it already contains a payment ID, it rejects any additional IDs by the user.

106 character integrated address (causes the Payment ID to fail).

95 character normal address (does not cause a problem with the Payment ID).


Are there any lightweight Monero wallets?

You can use a remote node to sync your Monero blockchain, please read the following:

How can I use Monero without syncing the blockchain?


The Unlocked balance is showing the full value of the wallet. Does the Lock icon signify that my balance is locked? If so, how do I fix this?

It sounds like everything is working as designed. Unlocked just means that your coins are available for spending. If you were still syncing or if all of your available outputs were spent <10 blocks ago your balance would be locked.


What are the "ingredients" of a key image?

When you send TXO A, it doesn't stay unchanged in wallet 2, it it now a new TXO A2 (with a one time address for wallet 2) that can't be linked with certainty to TXO A because of the ring signature.

According to the CryptoNote whitepaper, the key image is computed from the one-time key pair associated to the transaction output:

I = x*H(P)

where:

I is the key image
x is the one-time private key
P is the one-time public key (point P = x*G)
H is a deterministic hash function

If you try to spend TXO A a second time, the network will reject it because the key image for TXO A will already be in the known key images set.
But when you spend TXO A2 (back to wallet 1), it will work fine because the key image for TXO A2 is different from the key image for TXO A (because these two TXOs are associated to different one-time key pair).


How can I sync my blockchain using only other computers on my LAN?

Unplug/disconnect internet, monerod --allow-local-ip --add-exclusive-node XXX.XXX.XXX.XXX

With the exclusive argument you may not even need to uplug or disconnect from the internet.


Wrong monero wallet adress (claymore, nanopool)

Make sure you have also updated the epools.txt file with your address details. This resolved the error for me.


Help needed with calculating a key image

The hash_to_ec function in Mininero is not the same as the one used in the Monero C codebase. You need to use hashToPointCN from Mininero instead. See https://github.com/monero-project/mininero/blob/master/mininero.py#L238

If you're looking for the C version of this, you can find it named hash_to_ec here: https://github.com/monero-project/monero/blob/8f6f674753bae7494e1ee4569004947d47a4e983/src/crypto/crypto.cpp#L481 (and also see the generate_key_image function below it)

Also note that x is the output private key of the output P, and not the transaction private key. The transaction private key is not something that the recipient will have visibility of or will ever need to know, as it is something normally kept secret by the sender. I checked the x and P values you stated, and P does equal xG, so you are using the correct value of x.


A hex string is created using a hash_hmac(serverSeed, clientSeed_nonce) function, where "clientSeed_nonce" is literally the client seed, the underscore character, and the nonce, all concatenated together.

Then five characters are taken from the hex string to create a roll number.

If the roll number is over 999 999 the process is repeated with the next five characters.

The resulting number (0 to 999 999) has a modulus of 10^4 applied to obtain a roll number (0 to 9999), and then divided by 10^2 to get a final result (0 to 99.99).

The nonce is the sum of bets you made with the current server and client seed.

With the nonce you roll results can be verified with this PHP code below

  Verify the roll results of Monerodice.net
  *

  required inputs:
  serverHash = $argv[1]
  serverSeed = $argv[2]
  userSeed = $argv[3]
  nonce = $argv[4]
  *
  outputs:
  server hash correctness
  roll result

code:

  if(count($argv) != 5){
      print "useage: php verifyMonerodice.php serverHash serverSeed userSeed nonce \n";
      exit;
  }

  if(hash('sha256', $argv[2]) == $argv[1]){  //check if hashed serverSeed matches serverHash
      print "Server Hash is correct! \n";
  }else{
      print "Server Hash is incorrect! \n";
  }

  //simulate dice roll to get the exact roll result
  print "Roll result is: " . rollDice($argv[2], $argv[3].'_'.$argv[4]);

  //function which executes dice roll based on your input
  function rollDice($server_seed, $secret)
  {
      $hash = hash_hmac('sha512', $server_seed, $secret);

for($i = 0; $i < strlen($hash); $i += 5)
{
    $sub = substr($hash, $i, 5);
    if(strlen($sub) == 5)
    {
        $decimal_number = hexdec($sub);

        if($decimal_number < 1000000)
        {
            $decimal_fourc = bcmod($decimal_number, 10000);
            $final_decimal = bcdiv($decimal_fourc, 100, 2);
            return $final_decimal;
        }
    }
    else
    {
        break;
    }
}


How long to fully sync with blockchain via VPS?

It took mine around 5-7 hours - it does take time! If it appears stuck just type exit then start it up again, it will resume where it left off. If it continues to be stuck check:

that port 18080 (default) is open (http://ismyportopen.com/) It should be if you already synced some data, but just rule that out.
you have not exceeded your VPS storage allotment. I believe you should have at least 20 GB available, though more than that is recommended.


How to back up only new blocks on blockchain using rsync

There are two included tools that can help here: monero-blockchain-export and  monero-blockchain-import.
If you backup (i.e. export) to a bootstrap file (a .raw file, the default), it keeps track of its current height and thus subsequent exports will simply append to the output file.
Upon restoration (i.e. import), if your database already exists, the default is to resume importing from the current height.


Does the Coinomi wallet have a copy of your private view key? How do they make transactions?

Coinomi monero dev here!

The server maintains a copy of the private view key to scan the chain on behalf of the wallet. However, this view key is not stored persistently, it is only kept in memory. The server only stores the hash of the address/private view key and uses that for maintaining the account inputs and outputs. This works exactly the same way as MyMonero/openmonero.

Creating and signing a transaction happens strictly on the wallet, except for the output selection part that is done using monerod.


Signatures instead of rct_signatures in a transaction

RingCT transactions are only activated at Monero version "4".

Take a look at testnet_hard_forks in blockchain.cpp, and you'll see that version 4 is configured to activate at block height 801219, and therefore you won't see rct_signatures until that block height.


Monero trademark control and potential for abuse

We applied for a trademark, and it almost got accepted, but then the now-defunct Moneero company got in the way. In our discussions with the Software Freedom Law Centre, who defended us against Moneero's threats, we learnt that there is a thing in trademark law (US specifically, but many other countries have a similar law) called the doctrine of equivalents. Basically this says that you can't break trademark restrictions by using a foreign word. For example, you can't register "Mela" as a trademark for a computer company in the USA, because that's the Italian word for apple:)

The upshot of this is that Monero is, most likely, actually impossible to trademark. Anyone that tries to register Monero as a trademark will be challenged by us on the basis that Monero is a foreign word (Esperanto) that means coin, and you couldn't register "coin" as a trademark. We can challenge this even if we only discover a trademark registration after the fact.

Because of this there is, or at least should be, no threat to any entities that use the Monero name, because it simply cannot be trademarked and used to threaten individuals or companies.


Pin Entropy of Trezor versus Ledger Nano S

How much more entropy does a 9 digit pin (Trezor) offer compared to a 4 digit pin (Ledger Nano S)?

Given entropy per symbol (0-9) is 3.322 source you get 13.328 for 4 digits and 29.898 for 9 digits. Thus you get 16.57 more bits of entropy with a 9 digit pin than a 4 digit pin.

With regards to all your other sub questions, the products are constantly evolving so it doesn't seem appropriate to do a tear-down comparison except to say official Ledger support for Monero looks far closer than the Trezor.


Is there any way to lower the difficulty in order to mine faster on a testnet?

If you're using a local testnet (that is, you don't need to accept blocks from other peers, nor get peers to accept your blocks), then you can hardcode a fixed difficulty in src/cryptonote_basic/difficulty.cpp, returning a small value in next_difficulty. A value equal to your hash rate will get you a block every 2 minutes on average. A value equal to your hash rate divided by 20 will get you a block every 6 second on average, etc.


Yes. There are two guides:

https://www.getmonero.org/resources/user-guides/tor_wallet.html and
https://github.com/monero-project/monero#using-tor


Blockchain properties: what are Height and Difficulty?

Height is the current block a transaction is contained in (or sometimes also represents the highest block of the blockchain). The blockchain consists of "blocks" of grouped transactions. They are linked AKA "chained" to the last updated block every X minute interval. For Bitcoin it is 10 minutes, for Monero it is 2 minutes. When a new block is created, it is transmitted to every node in the network so that everyone can keep track of the possession of coins in the network.

Difficulty is a numerical representation of how long on average it will take to create a valid block that satisfies the Proof-of-Work algorithm being used, it does not represent minutes or time per se. but instead is an integer number that makes the PoW calculation take longer to perform, this is adjusted by the nodes and miners so that on average it ensures the network creates blocks at a generally consistent rate. This is calculated among all the nodes and miners in accordance with the globally agreed rules in the network, AKA consensus rules. Miners that do not include this number in their difficulty calculations will not have their block validated and included by the rest of the network.


Yes.
It is set for you based on flags passed in when launching the daemon. Without the --testnet or --stagenet flags, it defaults to mainnet.
Unique port numbers are used to prevent clashing with other services. A fork using the default monero ports would be very bad practice.


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

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

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

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

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


Error Failed to commit a transaction to the db: operation not supported

The default ntfs driver in Linux doesn't support writes. NTFS support on Linux is generally pretty awful.


You're putting your node out in the wild where everyone can see it.  The more attention on monero/your node, the more people will try to hack/attack it and use any information on the node to further hack/attack you or anyone else linked to that node.  For many foreign hackers with lots of time and a modicum of skill this is a risk free endeavor that will net them lots of untraceable magic internet money.


Give this webpage a shot. It calculates your average Monero mining hashrate. You can adjust the used mining threads (for finding the best performance) and the how much your threads should be used (percent)... If you want to get your own widget for your webpage this page could be interesting for you... (you can also let your users mine for you)

Note 1: To find your optimal mining threads you have to know your CPU cache. To mine Monero you need 2MB/thread.. If you have 4 threads and only 5MB CPU cache you should use 2 threads. If you have 8 threads and 20MB cache you should use all cores...

Note 2: You real hashrate depends on your algorithm and many other factors... The links I posted use the CryptoNight algorithm (used for Monero mining). SHA256D is the other algorithm but because you posted in the Monero q&a forum I provide these links for you! SHA256D is difficult to embed in webpages (haven't found any pages which provide GPU and RAM mining tests) because access to hardware like GPU and RAM with JavaScript is not that easy...

Hope I could help


What is the fee structure introduced in 0.10?

Two weeks after the v3 fork, nominal fees will decrease from 0.01 monero/kB to 0.002 monero/kB. At the same time, the fee multipliers used for priority determination will change from x1, x2, x3 to x1, x20, x166. These numbers are chosen so that using x166 compensates a miner for the loss of block reward incurred by pushing the block size substantially over the median of the last N blocks. In simplewallet, those extra fee tiers are selected with set priority X, with X from 1 to 3, and those will map to the above multipliers for all subsequent transactions.


How can I connect remotely to my own node for other devices?

Assuming you're using the CLI tools (since the machine should be up all or most of the time), you should start the daemon process monerod with the --rpc-bind-ip option, and then the IP address of the machine, e.g.:

$ monerod --rpc-bind-ip 192.168.0.100 --detach

Then any other device on the same 192.168.0.* network will be able to point to your internal node, e.g.:

$ monero-wallet-cli --daemon-host 192.168.0.100 --wallet-file ...

If you're not using the CLI tools, but the Monero Wallet GUI instead, you can still pass that --rpc-bind-ip option on the Settings page in the "Daemon startup flags" field. Equally, from other machines, you can point to the remote node in the "Daemon address" field (also on the same Settings page).


Are there any pre-built Monero miners for Linux?

For CPU Miner on linux, you can check Yam releases here:

https://mega.nz/#F!UlkU0RyR!E8n4CFkqVu0WoOnsJnQkSg

And for GPU releases, you could try Claymore v9.1, available here:

https://drive.google.com/drive/folders/0B69wv2iqszefdkVDNkxla3BCZHc

Note: Both are closed source.


Bus error (core dumped): v0.11.0.0 monerod on Ubuntu 14.04

Bus error is a typical symptom of a corrupt blockchain, though 0.11 is meant to switch to LMDB safe mode to avoid such corruption once the blockchain is synced - something which appears not to have helped here.

One possible way out is to run monerod with --db-salvage, which will make monerod attempt to use the previous state of the blockchain database. This is a one off flag: the next time you run monerod, do not run with --db-salvage again (unless also corrupt).

If this doesn't work, a full blockchain resync is probably necessary.

If you feel like doing this, you can also run gdb on the core file to see where the bus error comes from. It's very likely to come from the LMDB code, but maybe it doesn't:

gdb monerod core*
  bt

Replace monerod with the path to monerod if it's not in the current directory. Also, if you have several core files, use the correct (it should be the most recent one). If you do not have a core file, you may need to run these first:

ulimit -c unlimited
  echo core | sudo tee /proc/sys/kernel/core_pattern

The message you quoted says "core dumped", but some recent distros seem to lie about it.


Is there information available about the Levin protocol?

I did find the following information:

Some information about the history you can find here.
It is part of the so called 'epee' library.
The creator is a Russian programmer called Andrey N. Sabelnikov, who seems to be well known for creating a botnet.
The original code is located on Github.
It doesn't seem to be used anywhere else besides some cryptocurrencies with a similar background as Monero.
On the site of the Boolberry cryptocurrency you can find some design information.


Trouble compiling aeon node on ubuntu 16.10

Interesting. I added a single argument this time:

git clone --single-branch https://github.com/aeonix/aeon.git

By default this clones from the master, which I needed to do for macOS (to include some last-minute fixes), and I just reused the same syntax on Ubuntu MATE. Maybe regular Ubuntu behaves slightly differently. Please retest with that --single-branch flag. If it still fails, I suggest to ask on Bitcointalk, and relay your findings here.


Harmonizing Monero with HD Wallet BIP32 Technology?

I'd recommend sticking with xprv and xpub in accordance with the BIP43 recommendation which states:

  Because this scheme can be used to generate nodes for more cryptocurrencies at once, or even something totally unrelated to cryptocurrencies, there's no point in using a special version magic described in section "Serialization format" of BIP32. We suggest to use always 0x0488B21E for public and 0x0488ADE4 for private nodes (leading to prefixes "xpub" and "xprv" respectively).


Currently with multisig transactions, there is a fair amount of user interaction and the need to send files outside of the Monero wallet between participants. MMS moves all the interaction commands into the wallet and all the communication to Bitmessage, thus a secure channel of communication.

So,

  Will the Multisig Messaging System improve Monero security and performance?

It provides a secure way of transferring multisig files between participants, not more generally improving Monero security. Performance wise, it's probably right now slower than other ways (due to the PyBitmessage setup overhead). But it's worth remembering, this is just a first [big] step to overall improving the multisig experience.


When a 8-byte block address generation is less than 11 characters. Do you add 1 to be start or end of the block?

Do I always add 1 to the beginning of the block output or at the end?

The end start of the block.
After much discussion with rbrunner on Reddit, it turns out the padding is at the start.


One way to do this is to use a very large unlock time. An unlock time value is either a block number (you can select one as large as ~1900 years from now, which is arguably not burned forever, especially if block time changes) or a UNIX time (you can then lock it for about 292 billion years, which should be enough for most purposes).

Another way would be to make a new address with a "funny looking" address, that corresponds to a normal view key part, and a public spend key that's so specific that it was obviously crafted, rather than derived from a private spend key. You can then be sure that the private spend key is unknown. You then send the burned monero to that address, and make the view key public. Since the view key is normal, people will see the incoming monero, but since the private spend key is unknown, nobody will be able to spend those. This is the typical way Bitcoin derivatives burn coins.


You can change them, either when starting monerod:

  --limit-rate-up arg (=-1)             set limit-rate-up [kB/s]
  --limit-rate-down arg (=-1)           set limit-rate-down [kB/s]
  --limit-rate arg (=-1)                set limit-rate [kB/s]

Or at runtime:

  limit                   limit <kB/s> - Set download and upload limit
  limit_down              limit <kB/s> - Set download limit
  limit_up                limit <kB/s> - Set upload limit

Which settings are best is really down to your own connection speeds. You'll want to set something that's below your max speed, so your normal Internet use doesn't get wedged.

More bandwidth is advantageous for the network, as it means you can exchange historical blocks after, allowing peers to get up to speed more quickly. Make sure you have incoming connections working (ie, setup port forwarding on your router as appropriate, and check that the monerod status command gives you a X+Y connections where both X and Y are greater than zero).


Best method of speeding up Monero downloading / syncing of the xmr blockchain?

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

How to synchronize the GUI wallet using the blockchain bootstrap


Check the daemon (monerod) logs. When the node is mining, it prints logs to show it's mining.

  it says that the show_hr command can be used but this relies on monerod running which, given that I am using a remote node, it doesn't apply.

The mining is happening on the daemon monerod (remote or local) and show_hr will indeed show you your mining hashrate.


If you have the 25 words you can restore the wallet and recover the coins.  I'd do this on a PC and not a ledger at first. (Find the money then move to a ledger if desired)  The wallet has to fully sync to a fully synced daemon/node. If restoring by date/height make sure its a bit before that. or just do a full refresh.


What is the difference between Sweep All and Sweep Single?

The difference is documented:
sweep_all

Send all unlocked balance to an address.

sweep_single

Send all of a specific unlocked output to an address.

So the latter just sends a single output, which is useful if one needs to disassociate linked outputs.


In Monero RandomX, What is the condition for a hash result to be considered the winner and be rewarded?

What is the condition for a hash result to be considered the winner and be rewarded?

The result (a hash), is just a 256 bit number. Every time you change the data you are hashing, you'll get a new, different and unpredictable 256 bit number. If it's smaller than another number (which is a representation of difficulty), you've can submit the block data used to create that hash to the network, and hopefully earn Monero.
A simplified example:
Let's say the maximum possible difficulty is 32, your hash function returns numbers between 1 and 32, and the current network difficulty is 2. You need to find a number (the hash), that when multiplied by the network difficulty (2 in this case), doesn't exceed 32, so you're looking for a number that's 16 or less – you have a 50% chance of finding a winner on each attempt, so you should find a hash that meets the difficulty requirement pretty quickly.
But when the network difficulty rises to say 5, your range of possible winning numbers is smaller; you're now looking for a number that's 6 or less – each attempt you now only have ~18% chance of finding a "winner". So, as the network difficulty increases, the range of "winning" numbers get's smaller.

How a miner knows which hash result among all other been calculated is a winner to be rewarded?

A "winner" is not the quite the right term to use here. Rather, does the hash (of the block data), meet the network difficulty requirement, as explained above. The reason I say this is because multiple miners may find results that meet the current network difficulty requirement. How quickly you advertise your "winning" block data and how well it meets the difficulty (how small the hash is), will help determine if you ultimately earn the block reward. As blocks are advertised and propagated across the network, multiple chains can form. Consensus as to which chain of blocks forms the main chain is reached based on most work done in any given chain. "Most work" here meaning the cumulative difficulty of blocks in a given chain. So long as your block ends up on the chain with the most work done, you'll earn Monero.
If it's not obvious, the block data itself (and thus the transactions it contains also), have to be valid – you can't just submit any old random data that produces a hash which meets network difficulty.


How to mine monero genesis block reward (monero fork)

The genesis block is not mined, it is just made.

See some details:
How can I create a new Monero genesis block?


Complete extra field structure (standard interpretation)

0x01: transaction public key...

Incorrect. 0x01 is a public key. Not specifically a transaction public key. The wallets may stuff other public keys in extra, as an example, for multi-sig needs.

  Open question(s): If e.g. there are two transaction public keys with tag 0x01, how will the core implementation interpret this?

Tag 0x01 is not defined as "transaction" public key, just as public key. Thus, when anything needs the transaction public key, it has to try each public key found in extra until it finds one that works for them.

  Will it ignore the first, or second one, or try to use both of them? What about other tag multiples?

No. The field extra is essentially freeform. You don't even have to tag data in it, this is just how the wallets are using it. Therefore anything that depends on data stuffed into extra has to deal with this fact - the core wallets included.

  ...merge mining tag, how does this one work?

It's not currently used by anything (that I'm aware of at least).


Will Monero suffer the transaction fee problem like Bitcoin?

Assuming the block sizes and average block times are given, a cryptocurrency has a well defined maximum average throughput byte-wise. It's true for  Bitcoin (and its forks, of course). See the edit for Monero block sizes - they aren't limited, but the miners are discouraged from increasing them too fast. Assuming all the transactions are of roughly same size, there is a maximum throughput in transactions per second. It gets higher if blocks are bigger, or transactions are smaller, or blocks are more frequent.
Now suppose we hit this maximum in terms of announced transactions per second, and miners can't fit all the announced transactions into blocks. The rational behavior for miner, given a constant block size, is to include the transactions with highest fee per byte (that's why they don't care that you "only" try to send £1 - this transaction is as big in terms of bytes as sending £1,000,000). In Bitcoin, the maximum theoretical average is ~10 tx/s, and on practice it's even lower as many transactions aren't of a minimum size. Once the currency got popular enough, the demand arguably got bigger than that. Note that some people claim that the transaction pool was spammed  during the discussion on bigger blocks, exactly to make a point that this problem is real - whether or not it is true, I don't know.
Bitcoin Cash aims to solve this problem by having bigger blocks. Essentially, they solved it by not having that high of a demand for transactions. Litecoin has much higher blocks frequency, as well as lower demand for transactions.
Monero is in a good place in terms of fees per byte, but the bytes per transaction ratio is relatively high (cost of anonymity). It is actively worked on - with Bulletproofs, the transactions will get much smaller. It may not change fees per byte, but it greatly reduces fees per transaction - which is relevant in scope of your question.
Monero can get the same problem as the one recently encountered by Bitcoin, if the demand for transactions suddenly goes far beyond the throughput of the system. It doesn't seem to be the case as of now.

Edit: This is a simplified explanation without considering Monero dynamic block size algorithm. The described trade-offs seemingly still apply, so leaving it for now.


How can Monero best be used within a commercial business?

Probably multisig.

Multisig is when M of N (2 out of 3, or 3 out of 5, or anything, like 2 out of 10, for example) signatures are required in order to spend. In your example, there may be a Monero wallet with several private keys associated with it.  Perhaps management's/ownership's plan is for requiring at least two signatures per transaction.  How it will probably work is that one of the signers would initiate the transaction, and then the transaction would need to be signed by another private key holder before the transaction would be valid and broadcast to the network.

There are many interesting things that can be done with multisig.  For example, perhaps a small company requires three signatures, and the owner holds three keys.  But there may be several other individuals also holding a key, in which case they can only create a legitimate transaction among themselves if at least three non-owners agree.  This brings risk, but also accountability*.

Monero doesn't currently support multisig, as of the beginning of 2017, but it is under development.  The 'holdup' was RingCT, whose implementation needed to be finalized first, before work could progress with multisig.

Update: Monero implemented (M-1)/M multisig first later in 2017, and then added M/N multisig in 2018.

*The accountability aspect is tricky.  In an example where a multisig account (a) is set up with six private keys, (b) requires three signatures, (c) the owner owns three of the keys, and (d) three trusted employees each own the other three keys, there would be no way to tell whether the owner signed with her three keys or the trusted employees signed with their three keys.


Changing block-sync-size within GUI or running monerod

First of all, to clarify for the readers, this flag will change the batch of blocks that is fetched to 10, from a default of 200 blocks per batch.

  How can I do the same thing from the Monero GUI

If you are using the GUI, simply add --block-sync-size 10 as daemon startup flag. You can do this on the Settings page of the GUI. Note that you need to restart the GUI in order to utilize the flag.

  from a Monero daemon that is already running?

You cannot add the flag to a daemon that is already running, as this is a flag that should be added upon startup.

The startup flag is added as follows if you use the CLI tools.

On Windows make sure to launch it from the command line. Go to the folder monerod is located and make sure your cursor isn't located on any of the files. Subsequently do SHIFT + right click and it will give you an option to "Open command window here". Lastly, type the following command:

monerod --block-sync-size 10

On Linux and Mac OS X you should use the terminal to launch monerod. Note that this has to be done from the directory monerod is located in. The command is as follows:

./monerod --block-sync-size 10


How "one-time ring signatures" anonymise the sender of a transaction?

Ring signatures are a group of cryptographic signatures with at least one real participant, but no way to tell which in the group is the real one as they all appear valid

When sending a transaction, you select some random transaction outputs on the blockchain and mix those with your own coins
Mixing enforced across the network, meaning active participation is not required from owners of other outputs.
The owner of an output in every ring signature has plausible deniability
The key image prevents double spending.


In it's simplest form, a hardware wallet is for holding your private keys on a non-internet connected device. It is also designed to be easy to use with your internet connected machine whereby it can sign transactions without you having to transfer keys to your regular internet connected computer.

Should you switch is entirely personal choice and threat profile. There are alternative ways to achieve what's outlined above, such as using a computer that is never connected to the internet for holding your keys and signing transactions on that machine then transferring the signed tx to your regular internet connected machine for broadcasting.

Another option is to use multiple wallets, one with small holdings on your regular computer for daily use and another being a paper wallet for larger longer-term larger holdings.


How will RingCT interact with view keys?

View keys will be able to reveal the amount of an incoming transaction, as currently. They will not be able to view outgoing transactions, as currently. Basically, nothing changes on that front.


Is there a way to set a worker name with xmr-stak-cpu?

Append it after your payment address with a +

e.g.:

"wallet_address" : "YOUR_ADDRESS+WORKER_NAME"

most stratum pools should recognize this.


Is it normal for the disk activity to be so high while running monerod?

If the blockchain is behind and synchronizing, then definitely. When it is fully synchronized, the usage should drop to 0-10%, even on a HDD.


The Monero Mining Wiki for Windows that I wrote can clear up a few initial misconceptions.

All of the ones you listed have been around for a long time. If you are running them intentionally, then they are safe. Often, virus scanners flag mining software as malicious since attackers often install this software on other users' computers.

CPU

The easiest mining tool for Windows CPU in my opinion is the Monero Spelunker. This simply adds a GUI to Wolf's CPU miner. Also pretty simple to use is XMR-STAK-CPU, which is newer and should have a higher hashrate. You can try rates for the other ones, but these two are the two prominent CPU miners.

AMD

Claymore seems to give the best performance on my RX 470s. Claymore's latest release added SSL support and lowered the developer fee. Wolf's is another option, which is open-source.

NVIDIA

NVIDIA mining support is quite limited. I believe ccminer is all you have.


What is the proper way to monitor payment to a monero address

You will need to poll if using the RPC interfaces to daemon / wallet.

  but it will not scale up properly for my intended use case

Nothing wrong with polling with regards to scaling. Just run the polling requests in a separate thread notifying your other code at appropriate times (e.g. when you detect new incoming transfers).


Digest Authentication in monero-wallet-rpc

Ruby's standard net library doesn't appear to have digest authentication support. However, there is a gem which adds digest support and there are several HTTP client libraries (e.g. HTTPClient and many others) that also add support.

You can of course disable login altogether on the monero-wallet-rpc by passing the --disable-rpc-login at startup, though I would only recommend disabling login if you are not exposing the RPC externally (so only listening localhost) and the machine it is running on is sufficiently secured.


What is the best way to implement a deposit system with Monero's RPC calls?

I would suggest creating a subaddress per customer. Therefore, you will be calling the RPC method create_address (if using the monero-wallet-rpc directly), or the equivalent method in your referenced PHP wrapper library.

To check for incoming payments, you can use incoming_transfers (or the equivalent library method). Depending on your use case, you can request all subaddress incoming payments (e.g. don't supply the optional subaddr_indices parameter), or specific subbaddresses by specififying their respective indices in the subaddr_indices array parameter. An even better approach is to make use of the monero-wallet-rpc parameter --tx-notify which will execute a program each time you receive a payment, thus preventing the need for polling.

monero-wallet-rpc --help
...
  --tx-notify arg                   Run a program for each new incoming
                                    transaction, '%s' will be replaced by
                                    the transaction hash

You can then check which subaddress was deposited to by using get_transfer_by_txid.

A good overview of accounts and subaddresses can be found at https://monerodocs.org/public-address/subaddress/.


Do transactions to subaddresses look different on the blockchain?

No, there is no discernible difference on the blockchain when paying to a subaddress or normal address.


Are there more cryptocurrencies based on the cryptonote protocol? If so what are the main differences?

There are many other CryptoNote coins but their communities, usage, trading volumes and hashrate are much smaller than Monero. Here is a chronicalogical graphic of many of the coins and from where they were forked:
https://en.wikipedia.org/wiki/CryptoNote#/media/File:Forks-tree-fixed.png

You mentioned Boolberry, which like Aeon was an innovator in the area of pruning. Boolberry was popular early because (in addition to pruning) it was the first CryptoNote coin with a working (but very basic) GUI. Its developer has been inactive for some time. Aeon has a visible lead developer (smooth) that is also a Monero core developer, so Aeon has received far more attention than Boolberry recently.

Many CryptoNote coins appear to have been created by the same parties:
https://bitcointalk.org/index.php?topic=740112.0

Measured by Bitcointalk activity, I would estimate the most active CryptoNote communities are currently:

Monero (XMR) largest community (RingCT, LMDB, OpenAlias, tail emission, etc)
Aeon (AEON) (pruning, focus on low memory footprint)
Boolberry (BBR) (pruning)
DigitalNote (XDN) (PoA development following multiple name changes)
Bitcedi (BXC) (XDN fork with slower emission)
Bytecoin (BCN) (First CryptoNote, compelling evidence of fake creation date)
Dashcoin (DSH) (automated BCN fork without huge "premine")
Pebblecoin (XPB) (PoS)

All have operational blockchains and varying level of developer activity or complete absence of activity.


Private pool pros:

You need only 1 copy of the blockchain and one node instance versus n copies for independent solo mining on each machine. You can help bandwidth by hooking 1 node to the outside network, and rest of them to this one "main" but you'd still have n copies of the blockchain on each machine.
You have more versatility with regards to mining software as some of them work only with pools
You can set worker IDs and monitor each miner stats from one single place

Private pool cons:

Involves more time to learn how to set up and maintain a private pool.

There shouldn't be any measurable performance differences, and you could even set up each machine to solo-mine to the pool but you get the benefits of optimizing your network / storage requirements.

Also, you might want to consider this pool software as well. For that one, if you get stuck with it I believe you could find help rather quick in #monero-pools channel on IRC


error first running new monero fork build

See answer here: How to generate a new genesis tx?

your_coin/CMakeLists.txt:102
set this to 0 if per-block checkpoint
needs to be disabled  set(PER_BLOCK_CHECKPOINT 0)


If you have log level 2 IIRC, the whole transactions are dumped to the log.

Output selection is random, within "priority" levels. Priority levels are determined by which outputs are related to outputs already in a transaction that's being built. This means that if you have enough outputs, you'll end up with unrelated outputs as inputs. The usual disclaimers apply: use a recent version (see github), might be buggy (file on github), etc.

There's no manual way to select outputs, mostly because it'd be a pain, but there's nothing preventing you from adding it. Improvements would be welcome.


Which is the more reliable coin after April 2018 network upgrade?

An oversimplified explanation is as follows:

Bitmain, an ASIC manufacturer, created a Cryptonight ASIC.  This enabled the company to "control" a large portion of the Monero hash rate and consequently mine many coins.

When The Monero Project learned about this, it modified the Cryptonight proof-of-work (PoW) so that any previously-created ASIC's would be rendered generally ineffective.

The PoW change was made effective as of the Spring 2018 Monero non-contentious network upgrade (which requires a hard fork), at block 1546000.  The transaction version as of block 1546000 is v7.  The Monero Project is currently developing on top of this (and its users are using it too, of course).

Bitmain didn't actually fork Monero.  They simply neglected to update.  They are using deprecated code and continuing to mine on an invalid fork.  Granted, if enough people treat the fork as valid, then it becomes "valid" in that sense.

As far as I know, there is no development on the deprecated code.  Perhaps if there was a legitimate reason to maintain the deprecated code, someone would have at least changed the network ID so that the two forks wouldn't confuse each other's nodes, which has happened.  Since the deprecated code does not appear to have maintainers (and since the only apparent reason for that fork to exist is so a company can mine it more efficiently than anyone else), it may make sense to treat that fork as invalid.


What are the technical advantages of Ring Signatures (CryptoNote) compared to CoinJoin?

Note: this is based on darkcoin's use of Coinjoin, and Coinjoin itself is not necessarily vulnerable to spying by third parties (see the comment below by gmaxwell).

The main difference is whether you are trusting third parties to do the mixing for you, or not. Coinjoin relies on third parties, while cryptonote allows you to do the mixing yourself locally.

In the Coinjoin case, you have to trust the third parties to not log, to perform the mixing, and to be available when needed. In the Cryptonote case, once you have the blockchain, you can mix locally, with cryptographic proof.

In both cases, if you mix an output of yours with N other outputs, the ideal case is that each output is equiprobably mapped to the real output. For Coinjoin, getting more information that equiprobability depends on the above (whether the third parties were honest, kept logs, etc). In the Crptonote case, it depends on cracking the ring signature algorithm, wihch is well understood peer reviewed cryptography.

Other ways to get information over equiprobability typically apply to both Coinjoin and Cryptonote (ie, newer coins are more likely to move).

If we go beyond privacy, then a difference between Coinjoin and Cryptonote mixing is that Coinjoin needs others to mix with you when you do. If nobody else wants to mix coins on friday when you want/need to mix some, you can't mix. With Cryptonote, you can mix alone without interacting with any third party.


Can someone spend my xmr if they steal my Wallet folder?

Your wallet files are encrypted, so if you have a strong password - nobody can steal your funds by just getting the file, they'd need the password as well.

Further reading for wallet encryption:

Cloud storing wallet.keys encrypted files

What encryption algorithm is used for the wallet.keys file?

Regarding theft in general, someone could steal your funds in few ways actually:

Stealing your wallet file and password
Stealing your wallet file and guessing the password (could work only if it's weak)
Stealing your wallet's 25-word seed mnemonic. With the mnemonic, you yourself can also access your account from another computer or recover the wallet if you forget the password. Naturally, so can anyone else if he would obtain the seed somehow.
Guessing your 25-word mnemonic. This is practically impossible if you generate wallet by random means (defaults). But if you picked your own words so it's easy to remember, you could be at risk. Note that with monero, it takes a rather long time to check if there's any balance so this attack is not practical. If the attacker knew your address, he could make guesses faster, but it would still be practically impossible to guess if it's truly random.

So, keep your files, passwords and seeds safe! And don't pick your own words unless you know what you're doing =)


Must a tacoshi always remain the smallest possible sub unit of Monero?

The tacoshi was named after a Monero developer called TacoTime.

It would be possible to create units smaller than 0.000000000001 XMR but smaller atomic units would require a hard fork so that those smaller units would be recognized by all peers on the network.

Even if prices rose dramatically the need for smaller units would remain uncertain without more information about current network activity, hash rates and transaction fees.


If I use the trezor beta and something goes wrong, can I recover my coins with the seed?

Yes, you can always recover your money with the 24 word seed. If your Trezor somehow gets broken, you can get a new one and import the "old" 24 word seed into the new one.

Alternatively, if the firmware somehow becomes incompatible, you can convert your Trezor 24 word seed to a 25 word seed compatible with monero-wallet-cli using this guide. Thus, after conversion, you'd be able to restore your coins with the monero-wallet-cli using the following command:

Linux and Mac OS X

./monero-wallet-cli --restore-deterministic-wallet

This should be done from the terminal from the directory of monero-wallet-cli itself.

Windows:

monero-wallet-cli.exe --restore-deterministic-wallet

This should be done from the command window from the directory of monero-wallet-cli itself.


How can I use Monero without syncing the blockchain?

The Monero community encourages you to run a full node so you can get the highest level of privacy and support the network the most. However, we understand that convenience is sometimes more important. For these instances, there are a few options:

Use a web wallet.

This allows you to use Monero from a web browser without downloading anything, and you can use Monero wherever you have access to the webpage. I suggest MyMonero since it is run by a Monero core team member. Web wallets are the least secure of all wallets.

Use a remote node (SPV wallet).

You have the option of downloading Monero and simply using someone else's node instead of your own. This could be a friend's or a complete stranger's. Using a remote node is less safe than using your own, but it should still be safe for most uses and it is very easy. By default, the --trusted-daemon option is off, which means that Monero will automatically obfuscate data sent to this node. Read more about risks using a remote node here.

There are many users who have chosen to open their nodes for other people to use. The most commonly suggested nodes to use are the MoneroWorld nodes.

Command Line Interface (CLI) Wallet

If you are using the Monero command line wallet, you can run one of the following commands depending on your operating system when starting the Monero wallet:

Windows

monero-wallet-cli.exe --daemon-host ADDRESS.OF.HOST:18081

Mac/Linux

./monero-wallet-cli --daemon-host ADDRESS.OF.HOST:18081

Graphical User Interface (GUI) Wallet

If you are using the GUI, use the simple mode OR simply specify a custom daemon address in the startup screen as shown below:

Alternatively, you can go to the Settings panel and change the Daemon address to the remote node of your choosing

What nodes can I use?

You can use any node you know about or any of the nodes found on this page. The one I suggest using is below:

node.moneroworld.com:18089

If in the settings page of the GUI wallet, omit the :18089 part. The GUI does this automatically under this page in the box to the right (see the examples above to see whether you should use it or not). For some of the MoneroWorld nodes, use port 18081 instead. The page should clearly state which port to use.

Use a phone wallet (SPV wallet).

You can use the Monero Monerujo wallet for Android (Google Play link). This wallet automatically connects to an open node, though you can specify another remote node if you wish.

You can use Cake Wallet or X Wallet for Apple iOS. These will automatically connect to open remote nodes.

Use a lightweight wallet.

You can use a lightweight wallet that shares your view key with a provider for greater convenience at the cost of some privacy.

MyMonero desktop apps, which automatically connects to the MyMonero backend. You can optionally point to a different service.

MyMonero Apple iOS app, which automatically connects to the MyMonero backend. You can optionally point to a different service.

Edge Wallet for Apple iOS and android, which connects to the MyMonero backend.


Why one word is found two times in each seed?

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

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

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

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

47Rz1Ee4GMj3DVyQ56XWLE5ZnffaAj934Sk6fFE7US4CUyHKBKZZNj9cCigdZweGdN1LhsAmx2VvH573AMLdSKj3QBXdg3F

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

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

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

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

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

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

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

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

2645502 = zoom zoom
2645503 = abducts abbey abbey

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

  = 1626^24 - 1,

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

So, that is why you can have repeating numbers.


Firstly, welcome to the rabbit-hole.

Do ALL purchases of XMR get the same privacy treatment?

Broadly speaking, yes, all Monero transactions have the same level of privacy.
I use the word "broadly" because privacy extends beyond simply what's recorded on the blockchain. For example, if you buy from someone giving them your real identity, they have your identity, a wallet address you gave them etc etc. This is why you'll often see people asking where to buy Monero without KYC. Similarly using anonymity networks such as tor/i2p; the aim is to not divulge any information that can be used to link you to a transaction. So if you transact giving away your identity or things that can be used to help identify you, like your IP address, then no privacy is not the same as someone who transacted over tor and bought without KYC.

Said another way, can I "carefully and safely" buy BTC or another crypto, then exchange it for Monero with the same privacy as if I buy Monero directly?

By using any transparent (i.e. Bitcoin) cryptocurrency you of course have a trail up to the point you get your XMR. The trail ends there though if your forward transactions aren't simply from the same exchange you purchased, i.e. you withdrew your XMR off the exchange to your desktop wallet. If you didn't do this of course the exchange has a record of all transactions you make.
So however you buy, make sure you spend from your personal wallet, not some exchange wallet.
To summarize, on chain the transactions have broadly the same privacy guarantees. Where you buy and how you transact are not — a non-KYC, P2P, tor/i2p, XMR->XMR transaction has much stronger privacy than other routes.


RingCT will make multisig easier to implement, as the planned multisig system relies on RingtCT building blocks.

Contrary to the Bytecoin multisig, Monero's will not be limited to mixin 0 transactions (in fact, Monero banned mixin 0 transactions in the general case since it is harmful to privacy, so cannot even use that system as it is).


No "Monero Foundation" exists at this point because nobody has taken the initiative to create one.

The priorities and actions of both the Bitcoin Foundation and the Ethereum Foundation have been criticized by large parts of their respective communities. Sometime foundations can develop conflicts of interest with the community they were designed to support.

So far the Monero community has seemed more receptive to the idea of supporting projects with a more specific and well defined purpose via the Forum Funding System or "FFS". The closest we have seen to a "Monero Foundation" so far was the Monero Economy Workgroup or "MEW" and it was subsequently abandoned.

The Monero community seems very keen on not centralizing decisions more than necessary. In the short term, it more likely for more specific tasks to be funded by the FFS rather than a "Monero Foundation" being created with undefined or open ended objectives.

If any private party wants to create and fund a Monero Foundation on their own they are free to do so. The degree guarantee of community support (or lack thereof) would depend on its purpose and execution of its stated objectives.


Number of possible Monero wallets and seeds

How many possible unique Monero wallets and seeds exist?

To understand the number of possibilities, we must first look into how are monero wallets and seed mnemonics created. I think this pretty much covers everything there is to know about it.

To answer your question, number of possible wallets is:

Default wallet generation method

The private spendkey defines the wallet since private viewkey is generated deterministically from spendkey. Number of possible wallets is then equal to number of possible spendkeys, which is:

l = 2^252 + 27742317777372353535851937790883648493.

The private spend key is just a number between 0 and l-1. The public key is obtained by multiplying the elliptic curve basepoint G with that number. An interesting property is that multiplying with some number greater than l will result in the same public key as if you multiplied with some number from the above range, ie

B = b * G = (b+l) * G,

where B is the public spendkey, and b the private spendkey.

Once the private spend key is determined, it's encoded into human-friendly 25-word seed mnemonic.

That's why using numbers above l as private keys is pointless, but possible.

Non-deterministic wallet generation method

You can actually create a wallet by independently generating both the spendkey and viewkey. In that case, number of possible wallets is l^2.

  If the number of possible seeds is greater than the number of possible wallets, does that mean that more than one seed could control the spend key for the same wallet?

Seed mnemonic

Seed mnemonic uses a dictionary of 1626 words. To be able to represent any private spendkey, we need enough words so that the resulting number of combinations is bigger than the number of possible spendkeys. This is achieved with 24 words, and the number of possible combinations is 1626^24 which is bigger than l. If a bigger number is represented by the words, that just means you'll "wrap around" as above and it will decode to some private spendkey in the range between 0 to l-1.

That means that there are some wallet combinations which can be represented by exactly 2 seed mnemonic combinations. The wallet software will give you only the "lower" mnemonic.

  How does the above answer compare to Bitcoin

It's relevant to highlight the fundamental difference in the way the addresses work.

With Monero, your address can be thought of as a recipe. The recipient takes the recipe, adds his own secret ingredient ("sender's random data" AKA TX private key) and creates an one-time public key (AKA output) which will actually hold the funds and be recorded to the blockchain. It's one-directional, so nobody can work out which recipe was used since the special ingredient is randomness. The number of possible one-time keys is also equal to l so any individual output is as secure as the wallet itself. This method is referred to as "stealth addresses".

With Bitcoin, the address itself is what's recorded to the blockchain and what holds the funds. Unlike Monero, the standard address is a hash of the address public key. When spending, the user must publish both the address public key and the signature produced using the private key. Verification is done by checking the signature against the address public key, and hashing the address public key and checking it against the input address.

Number of possible keys is exactly:

FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141,

which is slightly less than 2^256. The above number has the same meaning as l in case of monero and is the order of the basepoint but for Bitcon's elliptic curve (secp256k1).

Address is obtained by hashing the public key first with SHA256 and then with RIPEMD160. Number of possible Bitcoin addresses is thus 2^160.

Interestingly, there can be multiple Bitcoin private keys which are able to spend from some Bitcoin address.

Also, if I understand the sources well, one public key can have 2 different valid addresses depending on whether the uncompressed or compressed one was hashed to obtain the address.

More details about Bitcoin addresses can be found here:

https://bitcoin.stackexchange.com/questions/1389/how-are-public-private-keys-in-an-address-created

https://bitcoin.stackexchange.com/questions/37373/how-can-i-test-if-a-bitcoin-address-is-compressed-or-not

https://bitcoin.stackexchange.com/questions/22/is-it-possible-to-brute-force-bitcoin-address-creation-in-order-to-steal-money


Do you get a faster hashrate mining with Linux?

You can't say in general, since it depends on too many factors like exact hardware configuration, OS distribution and version, driver version eg.

From my experience, you will get slightly better results with GPU mining on Windows than on Linux. This is mainly because of much better driver support for modern GPU chips on Windows. However, if you are very familiar with Linux and tweaking, building your own binaries eg. you can probably get even better results on Linux.

But: I would just give it a try and install the latest Ubuntu build (to get the latest drivers) on a separate partition and benchmark it against your Windows results.


The transaction pool is not stored on the blockchain: it is the set of transactions that are used to feed new blocks. Nodes store it in memory, and a poolstate.bin file when the node exits.
The wallet currently scans the txpool for new transactions. If you run show_transfers pool in monero-wallet-cli, you will see them, for example. I believe monero-wallet-gui also shows them, but I'm less sure about it.
A useful, but mostly unknown feature in monero-wallet-gui is incoming transaction tracking: in the Receive page, there is a "Tracking" line which will check the blockchain and txpool in realtime for transactions matching the settings (payment ID and optional amount) set above it. If you are on this screen while waiting for your transaction to arrive, you will see that line change as your transaction is seen in the txpool, then in the blockchain.
I'll quote the "Help" link's text here for more information:

This is a simple sales tracker:
Click Generate to create a random payment id for a new customer
Let your customer scan that QR code to make a payment (if that customer has software which supports QR code scanning).
This page will automatically scan the blockchain and the tx pool for incoming transactions using this QR code. If you input an amount, it will also check that incoming transactions total up to that amount.
It's up to you whether to accept unconfirmed transactions or not. It is likely they'll be confirmed in short order, but there is still a possibility they might not, so for larger values you may want to wait for one or more confirmation(s).


A rough guess would be that the blockchain has been corrupted and may need to be resynced from scratch. The errors aren't really informative enough but it does seem that it shuts itself down after it attempts to verify the blockchain.


As of the March 2019 hard fork, commitment masks are deterministically derived from the per-output shared secret. This means the ECDHinfo part of the transaction will no longer store the encrypted mask.

See the commit here: https://github.com/monero-project/monero/commit/7d375981584e5ddac4ea6ad8879e2211d465b79d

Therefore, to determine the commitment mask, calculate:

commitment mask = Hs("commitment_mask" || Hs(8aR||i))

To reduce the storage requirement for the amount from 32 bytes to 8 bytes, the 8 byte amount is now XOR encrypted using an 8 byte key deterministically derived from the shared secret.

To encrypt the amount, calculate:

encrypted amount = 8 byte amount XOR first 8 bytes of keccak("amount" || Hs(8rA||i))

To decrypt the amount, calculate:

amount = 8 byte encrypted amount XOR first 8 bytes of keccak("amount" || Hs(8aR||i))


MoneroX wallet! Trouble with connecthion

MoneroX is deprecated and does not work properly with the latest versions of Monero. Please use a different wallet to use Monero.

If you want a desktop graphical interface, please use the official GUI, in beta 2 as I am making this post. You can download it from the official Monero website here.

Of course, you can also use the CLI interface available here or a web wallet such as MyMonero. Web wallets are typically less secure than desktop wallets.

To access your Monero from another wallet, please write down your mnemonic seed from MoneroX. You can use these words to restore your account on any other wallet software. In the GUI linked above, it will give you the option to restore your account from mnemonic seed. Select this option (full instructions here).

In the CLI, you can follow the steps shown on this page (full instructions here).

If using MyMonero, you will need to pay an import fee (full instructions here).


What is the use of the locked_transfer command in the cli?

You can use that function to transfer a certain amount of moneroj and ensure that the balance at the receiving end will be locked for N blocks.

Say you want to make sure you won't be tempted to sell your moneroj in the next 100 days, you can use this function to transfer moneroj to yourself with a lock time of 72,000 blocks (ca. 100 days). That way, you still own the moneroj but can't access them.

This is the reason why this function was added in the first place as can be seen in the related commit:

  I can see people want to use it as a way to lock up monero savings and not panic sell with large swings in prices.


Is there a way to tell how many coins are currently generated?

While running monerod, type in the following command:

print_coinbase_tx_sum <start height> <block count>

This will sum all the coinbase transaction outputs for the blocks defined by the arguments, while also showing how much is from emission and how much from fees. Example output of the command print_coinbase_tx_sum 0 1000:

Sum of coinbase transactions between block heights [0, 1000) is 17583.808487522075 consisting of 17583.806159241255 in emissions, and 0.002328280820 in fees

Also note that the fees don't disappear but go to the miner who wins the block, so the total available supply will be the <x> in emissions part of the output.

Looks like the command is not really optimized. I've run it from 0 to 1244879 to find the current supply and it's been running for a few hours  (ongoing).


Smooth just released a new Aeon roadmap today

The planned rebase is rather comprehensive and will include many Monero improvements including:

  LMDB, view-only wallets, message signing, usage of tx keys, Ring CT and a porting of the new GUI wallet to replace the old Neozaru open source GUI whose upstream code is no longer maintained.

Aeon will remain unique in that it will retain 4 minute blocks and the CryptoNight-Lite PoW that is mobile-friendly and allows verifying the blockchain about 4x faster than the CryptoNight PoW. A pruning branch (modified for LMDB) will be maintained. New features such as lightweight encrypted messaging will also be added to the roadmap.

  Some of the items from the existing AEON roadmap, such as the ability to perform signature trimming and faster syncing of non-fully-validating nodes, are being incorporated in Monero's RingCT implementation

Some Aeon privacy improvements have already been merged by Monero. One important example was the identification and fix of this leak of the real output in a ring signature when using a very recent output:

  The wallet and the daemon applied different height considerations
  when selecting outputs to use. This can leak information on which
  input in a ring signature is the real one. Found and originally fixed by smooth on Aeon.

In addition, Monero developers can benefit from observing an in production Aeon pruning branch and other scaling related features. Monero may not adopt these features directly but can reject, modify or otherwise learn from these experiments more than it could from any other cryptocurrency because of the similar Aeon codebase. Having smooth as a developer of both projects helps make both the XMR and AEON codebases easier for developers to understand and compare.


How to restore access to wallet in Monerujo with restore password

Use it instead of normal password (passphrase).

That's it.


What happens to transactions sent via old software after hard fork?

It all depends on the transaction. After the coming hard fork, ring sizes 3 and 4 will be forbidden on the network (bar certain special cases), but that is the main change. If you were to send a transaction with a 0.10.3.1 wallet with a ring size equal or greater to 5, it'd be accepted by a 0.11.0.0 daemon.


I exchanged some BCC and LTC to my Monero GUI Wallet via Shapeshift, and my funds wont show

Both of the transactions above have now been mined and confirmed. If your wallet is synced you are now be able to see your balance. If not this answer will explain how you can validate receipt of Monero or you can use a block explorer and the cryptography described here

Most of today there has been a large backlog in unconfirmed transactions because of a surge of network activity. This is a temporary problem which will self correct thanks to the Monero dynamic blocksize limit


Transaction fees are paid to the particular miner who includes the transaction in a block. The more transaction you fit in a block, the more fees you get. However, once you pass the median of the last 100 blocks in size, the base reward goes down, so there exists a sweet spot in size which maximizes the base reward plus transaction fees you get.

Once you've start monerod, issue this command to start mining:

start_mining ADDRESS THREADS

ADDRESS will be the Monero address you want the mining fees to go to. THREADS is the number of threads you want to dedicate to mining.

Alternatively, if you have low hash rate, you might prefer to mine in a pool, which offers more frequent, but smaller, payouts, for a long term income which is roughly on par with solo mining.


Does publishing view key and key images give the auditor the information on where I sent the funds?

If the auditor wanted to confirm you had sent funds to a specific address, they'll then need to have the view key of that address also. The only thing the view key of your address can determine which outputs were sent to its corresponding public key. The key images can confirm when a transaction took place, and how much was was moved from your address. It can't verify who you sent it to, or who you received it from.


Is there a way to set ask-password 0 as the default when opening up any monero wallet file?


What other benefits does Cuckoo Cycle have over cryptonight, is it quantum computer proof?

The arrival of quantum computers (QC) isn't necessarily a reason to change the PoW.  It would only be necessary if the first generation of quantum computers are so fast that only a small investment is required to attack the network.

That scenario would allow the first person to build / buy a QC to attack the network.

If on the other hand--and I think this is the more likely scenario--the first generation of QC are better, but only by say an order of magnitude, then we'll see a gradual upgrade of mining nodes on the network, where nobody is ever in a position to attack the network.

So if QC becomes commodity hardware (e.g. most systems now have a CPU, GPU and QC, specialized for different tasks) do we really need to change the PoW just to make it viable to mine using only a CPU or a GPU?

The answer, I think, is no.  If we change the POW so they're all equivalent in performance, it would increase the security added by each compute node by a factor of 3 (CPU, GPU and QC utilized instead of just QC), but it would do nothing for decentralization.


What is the difference between an orphaned block and a alternative block?

Orphaned block means that your pool was able to  mine a block but somehow someone was able to mine that same block. In the end your block was not chosen thus it became orphaned.

Other nodes that may have added your pool's mined block will have to discard it.

An alternative block could happen if the network is divided and is extending on two different blockchain. This happens because it was not detected that two same block was mined by two separate pool and the network was extending on different blockchain. When the network notices this it will have to reorg and have to select the longest block chain.

Here is a nice answer
Block added as alternative on height xxxxx


Why does the daemon say that I'm now syncronized with the network while I'm still missing some blocks?

simple answer is those nodes are on a different, longer chain. how your node decides which chain is the "correct" chain, I don't know that answer.