How do the new rpc-payment... options for monerod work? V0.15 / Carbon Chameleon seems to have introduced new rpc options for a monero node.

How do the following options actually work?

rpc-payment-address
rpc-payment-difficulty
rpc-payment-credits

Also, is there a way to exempt your own wallet from what the above options?

Quoting the relevant commit message:

daemon, wallet: new pay for RPC use system
Daemons intended for public use can be set up to require payment
in the form of hashes in exchange for RPC service. This enables
public daemons to receive payment for their work over a large
number of calls. This system behaves similarly to a pool, so
payment takes the form of valid blocks every so often, yielding
a large one off payment, rather than constant micropayments.

This system can also be used by third parties as a "paywall"
layer, where users of a service can pay for use by mining Monero
to the service provider's address. An example of this for web
site access is Primo, a Monero mining based website "paywall":
https://github.com/selene-kovri/primo

This has some advantages:
 - incentive to run a node providing RPC services, thereby promoting the availability of third party nodes for those who can't run their own
 - incentive to run your own node instead of using a third party's, thereby promoting decentralization
 - decentralized: payment is done between a client and server, with no third party needed
 - private: since the system is "pay as you go", you don't need to identify yourself to claim a long lived balance
 - no payment occurs on the blockchain, so there is no extra transactional load
 - one may mine with a beefy server, and use those credits from a phone, by reusing the client ID (at the cost of some privacy)
 - no barrier to entry: anyone may run a RPC node, and your expected revenue depends on how much work you do
 - Sybil resistant: if you run 1000 idle RPC nodes, you don't magically get more revenue
 - no large credit balance maintained on servers, so they have no incentive to exit scam
 - you can use any/many node(s), since there's little cost in switching servers
 - market based prices: competition between servers to lower costs
 - incentive for a distributed third party node system: if some public nodes are overused/slow, traffic can move to others
 - increases network security
 - helps counteract mining pools' share of the network hash rate
 - zero incentive for a payer to "double spend" since a reorg does not give any money back to the miner

And some disadvantages:
 - low power clients will have difficulty mining (but one can optionally mine in advance and/or with a faster machine)
 - payment is "random", so a server might go a long time without a block before getting one
 - a public node's overall expected payment may be small

Public nodes are expected to compete to find a suitable level for
cost of service.

The daemon can be set up this way to require payment for RPC services:

  monerod --rpc-payment-address 4xxxxxx \
    --rpc-payment-credits 250 --rpc-payment-difficulty 1000

These values are an example only.

The --rpc-payment-difficulty switch selects how hard each "share" should
be, similar to a mining pool. The higher the difficulty, the fewer
shares a client will find.
The --rpc-payment-credits switch selects how many credits are awarded
for each share a client finds.
Considering both options, clients will be awarded credits/difficulty
credits for every hash they calculate. For example, in the command line
above, 0.25 credits per hash. A client mining at 100 H/s will therefore
get an average of 25 credits per second.
For reference, in the current implementation, a credit is enough to
sync 20 blocks, so a 100 H/s client that's just starting to use Monero
and uses this daemon will be able to sync 500 blocks per second.

The wallet can be set to automatically mine if connected to a daemon
which requires payment for RPC usage. It will try to keep a balance
of 50000 credits, stopping mining when it's at this level, and starting
again as credits are spent. With the example above, a new client will
mine this much credits in about half an hour, and this target is enough
to sync 500000 blocks (currently about a third of the monero blockchain).

There are three new settings in the wallet:

 - credits-target: this is the amount of credits a wallet will try to
reach before stopping mining. The default of 0 means 50000 credits.

 - auto-mine-for-rpc-payment-threshold: this controls the minimum
credit rate which the wallet considers worth mining for. If the
daemon credits less than this ratio, the wallet will consider mining
to be not worth it. In the example above, the rate is 0.25

 - persistent-rpc-client-id: if set, this allows the wallet to reuse
a client id across runs. This means a public node can tell a wallet
that's connecting is the same as one that connected previously, but
allows a wallet to keep their credit balance from one run to the
other. Since the wallet only mines to keep a small credit balance,
this is not normally worth doing. However, someone may want to mine
on a fast server, and use that credit balance on a low power device
such as a phone. If left unset, a new client ID is generated at
each wallet start, for privacy reasons.

To mine and use a credit balance on two different devices, you can
use the --rpc-client-secret-key switch. A wallet's client secret key
can be found using the new rpc_payments command in the wallet.
Note: anyone knowing your RPC client secret key is able to use your
credit balance.

The wallet has a few new commands too:

 - start_mining_for_rpc: start mining to acquire more credits,
regardless of the auto mining settings
 - stop_mining_for_rpc: stop mining to acquire more credits
 - rpc_payments: display information about current credits with
the currently selected daemon

The node has an extra command:

 - rpc_payments: display information about clients and their
balances

The node will forget about any balance for clients which have
been inactive for 6 months. Balances carry over on node restart.


Best method of sweeping monero private keys without rescanning the blockchain for a balance? I'm creating a tipping type app where I issue unique monero private keys for all my users like how an exchange has a different monero address for each user. I'm sure they are just using a payment id for each user while all funds goto the same wallet.

But in my case, I'm not using a payment ID. How can I sweep all coins from these addresses to my own without a rescan of the blockchain for each address? FYI, I also have a copy of the private keys for my users.

Scanning for an updated balance takes awhile. Can this be skipped?

To be able to make a transaction, the wallet must know how much it contains.

The approach for you would be to only scan from when the user made the transaction by specifying a restore height or date. Allowing you to only scan i.e. the last 10 blocks.

This technique only works if you are sure that each user only used an address from a specific moment. You can couple it with a remote node to allow multiple scans from multiple wallets without being bothered by the download speed.

However, I still would advise you to really consider the option of a single address as this entire process becomes automated.

Keep yourself informed you still use separated addresses as sub-addresses may be useful for your case once these become a thing.


Are there certain characters unsuitable for passwords? There has been a push in recent years (or maybe we're even past that push now, and everyone pretty much knows the importance) to use complex passwords with not just numbers and a mix of uppercase and lowercase letters, but also to use special characters.  Are there any special characters not suitable for use in a Monero password?

I understand that using $ in your password in monero-wallet-cli will not work.  Are there other "standard" special characters that are unusable?

There are no forbidden characters. However, you might have difficulty with characters such as \r and \n, since they're interpreted as "I'm done" when you type a string, and as terminator when reading from a file. $ works just fine (let me try right now just to double check... yes, it works).

Interesting characters that might cause trouble are non ASCII characters. For instance, depending on whatever terminal you're using, characters such as é will be represented differently (ie, if the terminal is using UTF-8, UTF-16, other Unicode, or some obscure encoding). So unless you're always using the same computer, you should avoid these characters.

0 may also be a bother, since it means end of string in C.

Of course, remember to quote/escape as appropriate for your shell if you specify a password using a shell.

There is no length requirement (within reason - don't go using 4 billion character password or you'll run out of memory, and there might be a standard C++ library string limit, but if there is, it's likely pretty high).


Why is a key image xHp(P), and not something simpler like Hs(x)? I understand how ringCTs work and know that they require a key image of the private key of the input that is actually being spent. How is this created? Couldn’t you just hash the private key of the real input?

An output has public key P and private key x, where P = xG and G is the well-known ed25519 base point.

The key image is I=x*Hp(P) where Hp() is a function that takes a hash of P and returns a valid curve point.

  Couldn’t you just hash the private key of the real input?

Take a look at the section 3.4 Back’s Linkable Spontaneous Anonymous Group (bLSAG)
signatures in Zero-to-Monero

That is the simplest example of a linkable ring signature, and all of Monero's more complex ring signatures are essentially based on this concept.

For the key image to be verified, even the simple bLSAG scheme requires the key image to be the scalar multiplication of the private key x on a point other than G. In simple (non-Monero) situations, that alternate point could be e.g. another universally well-known point H. However, if Monero used H instead of Hp(P), it would be possible for someone that sends you outputs to detect if you've later spent more than one of them (see Notes on the hash function Hp on page 17 of the CryptoNote white paper).


How does the wallet scan for outputs belonging to it? In principle it's clear from the CN whitepaper:

  Bob  checks  every  passing  transaction  with  his  private  key
  (a,b),  and  computes P' = Hs(aR)G + B. If Alice's transaction for
  with Bob as the recipient was among them, then aR = arG = rA and P' =
  P.

What I'm interested in is the particular implementation in the current software. How I see it, there could be 2 options:

For each TX, the wallet fetches R and all Ps from the daemon, and computes P'. The wallet tests P' == P.
For each TX, the wallet fetches only the R from the daemon, computes P' and sends it to the daemon. The daemon tests P' == P and if matching, returns the matching outputs to the wallet.

Which way is currently used? Option 1. is safer but option 2. looks like it would significantly reduce the amount of data that needs to be transferred between the wallet and daemon. Could 2. be implemented for light wallets connecting to a trusted daemon, if not already?

Edit: adding some clarification for reference

As far as I can tell from the code, the option 1 seems to be the case. Most of the core functions of the wallet are implemented in src/wallet/wallet2.cpp. In pull_blocks which is called from within refresh, the wallet fetches individual blocks in its entirety. Subsequent to that function is process_blocks which then calls process_new_blockchain_entry which then calls process_new_transaction. In that function, the wallet generates the key derivation (i.e. the shared secret aR) which is passed to check_acc_out_precomp to test if each output in the given transaction belongs to the wallet. The actual test is performed by cryptonote::is_out_to_acc_precomp defined in src/cryptonote_core/cryptonote_format_utils.cpp.

The option 2 seems to be a natural approach for implementing light wallets and I guess it's quite feasible; I'm curious what the core devs have to say :)


Spam attack to gain control of many outputs and undermine privacy Would it be possible for an attacker to send many transactions to himself with the goal of gaining control of many outputs for the purposes of deanonymizing transactions of others (using low mixins with most outputs sometimes controlled by the attacker) later?

What would be the cost of spamming the network to gain control of 20% of the network outputs today? What about 40% or 60%?

If Monero usage to date already makes this attack prohibitively expensive would it be a concern for another CryptoNote coin (that may be brand new or still has low numbers of existing outputs)? When the network has low levels of available outputs can an attacker gain control of a large percentage of network outputs relatively cheaply?

Is it true that RingCT will allow ring outputs to be comprised of any denomination? Would this mean that it would make it harder for an attacker to gain control of a significant percentage of network outputs compared to pre-RingCT where outputs were grouped by ^10 denominations (and the attacker could focus on gaining control of outputs of specific denomination)?

We can get a rough idea of a cost lower bound by doing the following:

This command looks at the tx_outputs database, which lists all the outputs on the blockchain:

mdb_stat -s tx_outputs ~/.bitmonerod/lmdb

We see that this database holds 17896556 entries. In order to get 20% of the entries, an attacker would have to create about 4.5 million new outputs (100 * 4.5 / (17.9+4.5) == 20). An output requires at least a 32 byte public key on the blockchain, so that'd mean a total of 144 MB to be added. At a cost of 0.01 monero/kB, that gives you a lower bound of 1406 monero in tx fees.

Now, this is a lower bound. You'd need more data. Each transaction needs at least one input (at least one 64 byte signature). The 32 byte public key is not the only thing that is needed per vout (at least 2 extra bytes).

In order to get 40%, you'd need 12 million extra outputs (3750 monero lower bound), and in order to get 60%, you'd need 27 million extra outputs (8437 monero lower bound).

If you want to concentrate on a given denomination, the same reasoning applies, with a twist: there are currently 812877 outputs of size 10 monero. But in that case, you will need to include change (or waste a lot of monero, or have a lot of monero in the first place). In the original case, I took the best case: you take an input of yours, and you divide it into as many outputs as the transaction will allow, quantize, and throw away the rest. I assumed you could perfectly quantize (the varint encoding takes just a byte) and you threw away nothing (otherwise it adds up to the tx fees). Now, if you want all your outputs to be a useful size (for instance, 10 monero), then you need to recover the remainders after splitting, in order to use them as inputs to a subsequent tx, as that remainder is now a significant amount of monero. As example: a 60 kB transaction can hold at most 1875 outputs (using 32 byte per output again, so an overestimate). If you have a single 20000 monero input, you can make 1875 new outputs of size 10, and you have 1250 monero left. You don't want to lose them, so you pay them as change, and then need to consolidate them with other change as inputs for a later tx. All that adds overhead to the amount of data you have to pay for.

Now, the chain is not going to wait, so an adversary will need to get more than that, especially if they want to keep that threshold. If the outputs are created as a one off, the adversary will own less and less of the total outputs are the chain grows.

If such a sustained attack were to happen, transaction fees would most likely be temporarily increased, which would make the cost go up by as much.

RingCT will indeed avoid the need to split amounts by denominations, and any RingCT input will be able to mix with any other. RingCT transaction size will also get larger per output (but also need less inputs). So creating a lot of outputs will cost more, too.


As of 0.10.1.0, how do you use monero-wallet-rpc? Once updating to version 0.10.1.0, in addition to monero-wallet-cli, there is monero-wallet-rpc.  What is the difference in usage between the two?  What type of commands/arguments that were run previously with monero-wallet-cli should now be run instead with monero-wallet-rpc?

If you previously ran simplewallet in CLI mode (or 0.10's monero-wallet-cli in RPC mode) then you would simply transition to using monero-wallet-rpc with the same flags. As always, running the binary with --help will give you a list of all possible flags.


Where can I find a tutorial on how to mine with Monero? I would like to mine monero with my i7 cpu or do I need a gpu? Is there a good tutorial on how to go about mining monero?

Both CPU and GPU can mine monero but GPU is much faster. The best  way to get started with monero mining is by joining a mining pool and following the getting started guide.

Here is a list of mining pools you can join taken from https://www.monero.how/ . I myself is mining at supportxmr.com which is a small pool.

  monero.crypto-pool.fr
  minexmr.com
  xmr.prohash.net
  moneropool.com
  monerohash.com
  supportxmr.com
  xmrpool.net
  monero.miner.center
  xmrpool.eu
  usxmrpool.com
  xmr.poolto.be
  sheepman.mine.bz

The second way you can mine is through solo mining. You need to have a full node and the GUI or CLI wallet. In GUI wallet you just need to click the start mining button while in the CLI you have to type the start_mining command.


Can any CryptoNote coins be merge mined? Do any CryptoNote coins support merged mining?

If so which coins can be merged mined about how would merge mining affect my hashrate?

The Monero community almost unanimously voted against merged mining choosing instead to stand on its own and avoid indirectly supporting another CryptoNote coin, BCN that was 80% premined..

Actually voting is closed now as soon as nearly nobody wants merge mining in BMR

In hindsight measured by network hashrate, the Monero community made a wise decision. No other CryptoNote coin has close to the hashrate of Monero today.
The first CryptoNote coin to heavily advertise merged mining was FantomCoin. It is now largely abandoned with no major exchange listings.
FantomCoin can be merged mined with  Bytecoin's/QuazarCoin's with no hit to network has rate. Its creation appears to have been inspired by the Monero rejection of merged mining:

FCN thread comment: "I think there was no need of another fork just for MM"
TFT: "Community around BitMonero was completely against MM this time and we could not include it in BMR. Amphibian decided to deploy his work this way. MM at least doesn't consume additional energy"


Discrepancy CNS006 and CryptoNote whitepaper one-time key generation CryptoNote 2.0 uses P=Hs(rA)G + B for the generation of a one-time key.

CNS006 seems te change this to P=Hs(rA||n)+B, where n is the transaction index (encoded as varint).

Why is there this additional concatenation; is this to conceal transactions to the same address?

The CNS006 is correct. In the past outputs had to be split into denominations and without concatenations that'd generate multiple identical outputs (of different amounts) to the same wallet, effectively burning all but 1. With the concatenation, it's guaranteed that outputs will be unique, even if going to the same address.


Can you use the same 24 word seed from other wallets like ledger nano s to generate a monero address? Is the generated 24 word seed from a ledger nano s compatible with monero core wallet?

The list of English words available to create a bitcoin seed is not the same as the list of English words available to create a monero seed.

For example, the first few words of the former are "abandon ability able about" whereas the first few words of the latter are  "abbey abducts ability ablaze".

Monero only considers the first three letters of each seed word (for English, four for other languages) - in this case abandon, for example, would result in aba which is not the beginning of any valid monero seed word. That is not going to work well...

And the number of words in each list is not the same either so you could not even convert the words into indices and back.


What is the difference between Sweep All and Sweep Single? The Monero source code specifies sweep single, and sweep all in its RPC Server Commands section. What is the difference?

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.


How to restore a Monero wallet from Private Keys How can one import a Monero wallet via Private Keys (from mymonero.com / moneroaddress.org for example) into the GUI wallet? Is there a possible way via Private Spend- and View-Key?

Importing a wallet from MyMonero into monero-wallet-gui is easy.

Follow these Steps:

Go to mymonero.com, access your account and navigate to Account Details. it will look like this:

Open Monero-wallet-gui and choose the 2nd Option:

Now Enter you Account Details from mymonero.com. As Restore height, use the height of the first transaction to your wallet minus 20k. Thus, if the first transaction to your wallet was included in block 1350000, use 1330000 as restore height. You can check the height of the first transaction to your wallet by entering the transaction ID / hash in a block explorer like, for instance, XMRchain.

Now you can click the Next Button and set a password for your wallet.
On the next page, click "use monero" and you are ready to go.

Please Note:

If you only use your Private View Key, a View-only wallet will be created.
This Feature is only available in monero-wallet-gui beta 2 and higher.
You need to sync up with the network so you can see your transactions and balance.
If you want to use a remote node, use this guide.


Selective transparency in Monero vs Zcash How does the view key functionalist in Monero compare to the view key functionality in Zcash?

Does one system review more or less transaction details than the other? What are the differences?

This question boils to down which selective transparency options both coins offer. I'll start with Monero. In Monero there are three tools for selective transparency, namely the viewkey (called the tracking key in the CryptoNote whitepaper (a,B)), key images (I = xHp(P)), and the private tx key (r). Note that the letters between parentheses correspond to the letters presented in the CryptoNote whitepaper.

The viewkey allows you to see all incoming transactions for a certain account, but not outgoing transactions. More background information as to why can be found here.

The key images allow you to see all outgoing transaction for a certain account. Thus, with a combination of the viewkey and the key images, you will be able to infer a balance of a certain account.

The private tx key can be used as prove of payment on a case by case basis. That is, in case of a dispute, you can prove that you paid the receiver by publishing the private tx key (which you can obtain from the wallet), the transaction ID, and the receiver's address. An auditor can subsequently verify that you paid the receiver.

Basically 1 & 2 are important for auditing certain accounts (e.g. businesses and charities), whereas 3 is important in case of disputes.
There are, however, also a few things to note:

You cannot fake a balance by giving the view key to an auditor but omitting some transactions and key images. For more information, see here.

Instructions on how to prove a balance of a certain account can be found here.

The viewkey and key images won't show an auditor which address the account received the funds from or paid the funds to, respectively.

For this bulletpoint I will quote Luigi:

Oh, and a quibble. Revealing r (the private tx key) doesn't prove that you paid someone, only that that someone has received money. In practice, in an actual dispute, you'd be referencing a particular destination and TXID to a 3rd party, which would come much closer to proving to said 3rd party that you paid the recipient in question.

Now back to Zcash. As far as I know, in Zcash the only option for selective transparency currently is a key that is similar to Monero's private tx key. This makes auditing a certain account virtually impossible.


Practical usages of message signing What are some practical usages of message signing other than proving ownership of a Monero public key?

Proving ownership of a Monero public key is helpful if you solely want to verify ownership but there are other uses. Here are a few possibilities:

"Ownership" and "control" are not always the same thing. A new user may have a Poloniex Monero address which they "own" but a potential donor trying to encourage new users to set up full nodes may require a signed message to verify control of an address before a donation is sent.

Communicating details relating to a business transaction is another use case.  Merchant can use the message signing feature to confirm a package was sent, including a tracking #.

Suppose a buyer regularly sends monthly payments to a wine buyers club. One month the merchant suddenly changes its Monero address without warning. The buyer concerned about a possible MITM attack, could ask the merchant to sign a message confirming control over both their old public key and the new address.


Can I restore my account using just the keys file? Can I restore my account without seed and wallet file, using just the keys file? and do I need to know the password if you can restore from key file?

You DO need your password (which may be empty if you did not set one originally) to use your keys file. The keys file itself is encrypted by a key derived from your password.

If you do not have your seed, and lose your password, the keys file will be useless (unless you can brute force the password).

For the interests of clarity, "restoring" from a keys file is the same as "refreshing the wallet from the first block, rather than last refreshed block". They keys file is needed for both, and the wallet behavior is the same (except the refresh starting point is different). This may help see why your password is needed, since you input it when you open your wallet.


How does input reference the output of some transaction? So I want to understand how does Monero work under the hood.

Input of tx is structured as follows:

 "vin": [ {
      "key": {
        "amount": 0,
        "key_offsets": [ 17927, 10436, 804, 32, 3817
        ],
        "k_image": "67e33ecb9fc4e697248ef57ca88aa626fe670ce1551598f9cbc1565089d43c41"
      }
    }
  ]

Outputs of a given denomination are ordered in blockchain order, and thus can be represented by their index in that list.  Moreover, they're stored as offsets from the previous one (the first one from 0), as this will result in smaller values, which can often result in a yet smaller amount of data, since those numbers are written out in a variable length output. [1]

So I imagine some dictionary where value is a key and a list of offset is a value of that dictionary to exist. Or something similiar to that.

But then, when we inspect the output of the transaction, we have something like this:

"vout": [ {
      "amount": 0,
      "target": {
        "key": "7787bbef1a35b936e439aee4ae97cc245ba55ef35186efa3e9e86076a8fba1a6"
      }
    }, {
      "amount": 0,
      "target": {
        "key": "f981817b20f7a866abb6a9cb29e8062a16fb15f11f0a20c0f0f296eb26e1eab1"
      }
    }
  ]

Now my question is the following:

How can I know if some other transaction is referencing one of those outputs as input to that transaction?

How to link output of this transaction with input of some other transaction?

[1] Understanding the structure of a Monero transaction

The daemon keeps a table of all the transaction outputs in the order where they appear in the blockchain. The offsets in a transaction input allow to quickly recover the indexes of the referenced outputs in this table.

There is no command in the daemon to query the table of outputs directly. But there are some external programs that can be used or modified to make custom blockchain queries. For example, the transactions-export could be a good start.


What's the easiest way to look up a transaction on the blockchain? If I want to check if my transaction has made it to the blockchain, where can I look it up and by what data can I search/filter? Of course there is the transaction id and possibly a payment id, but is there other data I could use to find my transaction?

The best general tool for this is http://moneroblocks.info/.  It is somewhat comparable to the Bitcoin site https://blockchain.info/, and you can conduct searches using a number of different identifiers.

However, if you are focusing on a specific transaction, I think your best bet might actually be a very useful tool developed by one of our community members: http://xmrtests.llcoins.net/checktx.html

By using the transaction hash, viewkey or private transaction key, and the recipient's public address you can prove that a transaction made it to its intended destination.


How does remote node work? How can remote node provide txs for my public key if a key image is generated for every output? Can someone explain in detail what information is revealed in the process of looking up txs

firstly, your wallet gets an index of where your transactions are on the blockchain. So, when you first connect to a node (remote or either) with your wallet, your wallet first scans the chain with your private view and spend keys. it then stores the index information for where your outputs are in a local file... the cache.

When you want to create a transaction, the wallet asks the remote node for a bunch of random outputs. The node then sends these random outputs to the wallet. The wallet then combines these outputs with the ones that you actually own to create a ring signature. Its somewhat more complicated than that, but thats the general idea. For instance, I know there were advancements regarding how the wallet asks for outputs, such that the remote node can't run a differential between the two sets of outputs. I think the wallet is the one responsible for picking outputs, so it requests output information for index 1,2,3,4,5,6,7. Your real output is one of them. The remote node doesn't know which one.

Then, when your transaction is created, your wallet creates a key image.


Are there any CryptoNote Monero forks that have a company backing the project? I'm doing some research on Monero / CryptoNote forks where they have had an ICO or private sale and is backed by a company, like how Zcash is backed by a company and has a payroll.

Still no reply, so I'll post the one I know of, but there might be more.

Electroneum is a fork of Monero, which eschews development in favour of marketing. As https://electroneum.com/about/company/ shows, they have a company.

For those who might be tempted to click on the above, this fork is mostly a scam. See https://captainaltcoin.com/electroneum-price-prediction. It's basically a centralized premined coin with all flash and no trousers, and its "phone mining" does not actually mine, it just wastes your electricity and the company pays you for it. They're basically marketers and liars.


Was my XMR lost or stolen? I installed GUI wallet on windows 10 about 18 months ago and daemon wouldn’t start on its own.
After restarting it manually every time, it synchronized and wallet was working somehow OK. I
received XMR only, never sent any. Hash of the downloaded GUI file was checked.
Just recently, I installed GUI wallet on second PC, using same Ledger Nano S with the same mnemonics
and after lengthy synchronization, it showed 0.000 balance. I reinstalled GUI wallet and after syncing,
zero balance again. Hash of the downloaded file was checked as well. Sending address shows same as on the first wallet.
So I checked the balance on the first computer and there was still proper balance displayed. Then I
upgraded to the latest version of GUI wallet and after syncing, it shows zero balance as well. The sending address again shows same as on the first wallet.
I am 100% sure that mnemonics was not compromised and my Bitcoin and Cardano is still there.
I am doing something wrong or my XMR was stolen on wallet level. If so, there must be major
weakness in GUI wallet and in that case I am done with Monero for good! Used to be my favorite crypto.
Any help with solving this problem would be very appreciated. Thanks.

To get your wallet to display the correct balance, click "Settings", "Info", then look for the line "Wallet restore height" and click the "(Change)" link to the right of the number.  Following the format YYYY-MM-DD, enter a date that is before the time your transactions were made and click the Ok button.  Then wait a while for everything to fully resynch.  It should update to the correct balance.


Monero hard fork - cant mine new transactions So i am trying to do a monero hard fork. I changed the ports, prefixes, etc.
I am running on a bit of an issue. I can't mine new blocks.

Here's the error:

 2019-04-27 22:07:02.425 [miner 0]       WARN    checkpoints     src/checkpoints/checkpoints.cpp:109     CHECKPOINT FAILED FOR HEIGHT 1. EXPECTED HASH: <771fbcd656ec1464d3a02ead5e18644030007a0fc664c0a964d30922821
a8148>, FETCHED HASH: <7989160f55d2b5deeb21f90fd4ae9c105642f2f354cd90c1cd84c4efff018d4a>
2019-04-27 22:07:02.425 [miner 0]       ERROR   blockchain      src/cryptonote_core/blockchain.cpp:3397 CHECKPOINT VALIDATION FAILED
2019-04-27 22:07:02.425 [miner 0]       ERROR   cn      src/cryptonote_core/cryptonote_core.cpp:1310    mined block failed verification
2019-04-27 22:07:02.497 [miner 0]       INFO    global  src/cryptonote_basic/miner.cpp:495      Found block <2ad7c5252afc7d5c6630bcced4c76c911aaab7dc8f8dcc670e6afd8a6735e0bd> at height 1 for difficulty: 1
2019-04-27 22:07:02.497 [miner 0]       INFO    blockchain.db.lmdb      src/blockchain_db/lmdb/db_lmdb.cpp:591  [check_and_resize_for_batch] checking DB size
2019-04-27 22:07:02.497 [miner 0]       INFO    blockchain.db.lmdb      src/blockchain_db/lmdb/db_lmdb.cpp:559  DB map size:     1073741824
2019-04-27 22:07:02.497 [miner 0]       INFO    blockchain.db.lmdb      src/blockchain_db/lmdb/db_lmdb.cpp:560  Space used:      77824
2019-04-27 22:07:02.497 [miner 0]       INFO    blockchain.db.lmdb      src/blockchain_db/lmdb/db_lmdb.cpp:561  Space remaining: 1073664000
2019-04-27 22:07:02.497 [miner 0]       INFO    blockchain.db.lmdb      src/blockchain_db/lmdb/db_lmdb.cpp:562  Size threshold:  92160000
2019-04-27 22:07:02.498 [miner 0]       INFO    blockchain.db.lmdb      src/blockchain_db/lmdb/db_lmdb.cpp:564  Percent used: 0.0001  Percent threshold: 0.9000
2019-04-27 22:07:02.498 [miner 0]       INFO    verify  src/cryptonote_core/blockchain.cpp:3367 No pre-validated hash at height 1, verifying fully

My cryptonote_config.h:

namespace config
{
  uint64_t const DEFAULT_FEE_ATOMIC_XMR_PER_KB = 500; // Just a placeholder!  Change me!
  uint8_t const FEE_CALCULATION_MAX_RETRIES = 10;
  uint64_t const DEFAULT_DUST_THRESHOLD = ((uint64_t)2000000000); // 2 * pow(10, 9)
  uint64_t const BASE_REWARD_CLAMP_THRESHOLD = ((uint64_t)100000000); // pow(10, 8)
  std::string const P2P_REMOTE_DEBUG_TRUSTED_PUB_KEY = "0000000000000000000000000000000000000000000000000000000000000000";

  uint64_t const CRYPTONOTE_PUBLIC_ADDRESS_BASE58_PREFIX = 60;
  uint64_t const CRYPTONOTE_PUBLIC_INTEGRATED_ADDRESS_BASE58_PREFIX = 61;
  uint64_t const CRYPTONOTE_PUBLIC_SUBADDRESS_BASE58_PREFIX = 62;
  uint16_t const P2P_DEFAULT_PORT = 17238;
  uint16_t const RPC_DEFAULT_PORT = 17239;
  uint16_t const ZMQ_RPC_DEFAULT_PORT = 17240;
  boost::uuids::uuid const NETWORK_ID = { {
      0x12 ,0x30, 0x71, 0xF1 , 0x61,  0x41, 0x04, 0x61, 0x31, 0x17, 0x00, 0x82, 0x16, 0xA1, 0x10, 0xA1
    } }; // Bender's nightmare
  std::string const GENESIS_TX = "013c01ff0001ffffffffffff0302BAxepF8U14PC2x98WiaKWuHdnj2dGEQHjYcsPMzRJohS8Yxt8cJtr8aG38A41k8M3ydKBRyc9fkkBHSoG5vW4hhLHGaaheP21017767aafcde9be00dcfd098715ebcf7f410daebc582fda69d24a28e9d0bc890d1";
  uint32_t const GENESIS_NONCE = 10000;

When i run status:
status

Height: 1/1 (100.0%) on mainnet, not mining, net hash 0 H/s, v1, up to date, 0(out)+0(in) connections, uptime 0d 0h 0m 2s

Any idea why can't i mine new blocks?

You could try this:

In file...: monero-${VERSION}/CMakeLists.txt

Change....: set(PER_BLOCK_CHECKPOINT 1)
To........: set(PER_BLOCK_CHECKPOINT 0)


Monero GUI on Linux Mint - how to open wallet file from a separate device / USB stick With the CLI wallet, I can access the wallet file in the same directory, on a USB, due to using the cd command to /media/devicename. However, the GUI does not seem to recognise devices, to open the wallet file from, only the Home directory. Thanks for any help

When opening the GUI, select "Open a wallet from file"

After that, in the file picker you can go to any directory.

You could navigate to /media/yourusb/yourwallet.keys by clicking through the different directories (you might have to go to / first by clicking Computer on the left), or you could just directly type the path /media/yourusb into the File name box and press open.


What Linux flavour to use for AMD GPU mining? After many hours of struggle to install my Sapphire RX 580 gpus on Ubuntu 16.04, I was frustrated when I realised that:

  Installation of AMDGPU-PRO drivers on Ubuntu 16.04.3 will likely
  result in issues, such as black screen hang or defaulting to a lower
  graphics mode without acceleration.  This also applies to Ubuntu
  16.04.2 users who have been upgraded to 16.04.3.

I even tried to install Ubuntu 14.04 to avoid the issue, but it had the same issue.

So I had to switch to Windows 10 in order to make my rig of RX 580 gpus up and running.

However I really like to come back to Linux, as it is my preferred OS and, according to many, it offers better mining performance.

So I appreciate if you can tell me what flavors of Linux do not have issues with amdgpu-pro and can be used as the rig's OS.

Arch Linux has an AUR that you could use (link) that allows you to install the proprietary OpenCL component you need for mining without the need for the closed-source AMDGPU PRO binary blob.


What is the meaning of wallet2::transfer_details::m_global_output_index? I'm new in Monero. While reviewing the codebase of the Monero project, I'm stuck in the m_global_output_index field in transfer_details struct in the 'wallet2.h' file and want to know what it means. Really appreciate if someone can help~

In the CryptoNote protocol, outputs are organized into groups according to their amounts, and m_global_output_index represents the index of a given output in its corresponding group. This reduces the size of the ring signature by only storing those indices of outputs in the signature instead of the actual public keys.

Some examples:

https://xmrchain.net/tx/a32927808b02915060008b6806b0ea4458c61d54566f5bc4eb22347c8e674ca4

In this pre-RingCT transaction, the output amount is denominated into 6 different digits, each having its own group of outputs. The meaning of "amount idx 278059 of 308522" on the right hand side is that there exist 308522 outputs of 0.005 XMR in the blockchain, and this newly generated output is the 278059th one in the group.

https://xmrchain.net/tx/0c951a488193c08f3411f0b7f0023a6b72b22e6f2f376f2c720c8d4c31face6e

After the activation of RingCT, the denomination of outputs is no longer necessary, and all the RingCT outputs (whose amounts are hidden) are stored in the same group (associated with the amount of 0 XMR by convention). There are 1491097
RingCT outputs as of now, and this transaction generated the two latest outputs at indices of 1491095 and 1491096.


Does the Monero wallet distribute the blockchain? Does it send many blocks to other peers? If so how can I turn this off?

Yes, the official Monero app (monerod) also helps the network by distributing the blockchain. This can be turned off by starting monerod with the --hide-my-port argument.

If you haven't set up port-forwarding in your router, most likely you will not distribute the blockchain. You can check how many nodes are connected to your daemon by issuing the following command inside the monerod prompt: status.
This shows something like this:

Height: [...], 8(out)+30(in) connections [...]

The number in front of (in) indicates the number of incoming connections. If this is 0 for you, nobody is connected to your node which means you're not distributing the blockchain.


When did Monero switch to 2 minute blocks? When Monero was launched, it used a 1 minute block time.  In the question Why was the block time changed from 1 to 2 minutes?, reasons for the switch were discussed. When, however, did this switch actually occur?

I am wondering both the block height and date.

The change occured at hard fork 2, on block 1009827 (see the table near the top of src/cryptonote_core/blockchain.cpp). This was in march 2016.


How was the official Monero website hacked to deliver malware at the end of 2019? According to arstechnica, on November 18th 2019 the official Monero website was hacked to deliver compromised binaries. Is any information available on how this attack occurred? Was it the website that was compromised (as the link suggests), or was it the Monero build server?

It was the server hosting the binaries that was compromised during this attack. Luckily signed files with the genuine binary hashes were available on other sources and servers, so the attack was noticed fairly quickly. Here is the announcement on r/monero relating to the compromise: https://www.reddit.com/r/Monero/comments/dyfozs/security_warning_cli_binaries_available_on/ .
Additionally security researcher SerHack published a postmortem on the binaries and the hack itself that goes into some more detail: https://serhack.me/articles/cli-binaries-compromised-monero-analysis/ .


Can't find $HOME/.bitmonero in MacOS I tried searching "$HOME/.bitmonero" and just ".bitmonero" in my finder window and then pressing command+shift+. but I can't find anything...?

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


What is the fee structure introduced in 0.10? In Wolfram Warptangent (Monero v0.10), a new fee structure was introduced, in addition to decreasing the minimum tx fee. What is the current fee structure?

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 does the ring sig work: practical explanation? Is the following correct?:

If I received 5 XMR from Bob, then I wanted to send this 5 XMR to Alice.

Would I create a tx with the input as the 5 XMR from Bob with one output as 5 XMR to alice. Then look for another tx, fetch K inputs and outputs from that tx along with their public keys.

Then add those K inputs as inputs to my tx, along with the corresponding outputs for them. Because if we do not fetch the outputs, then inputs-outputs-fees != 0 and it would be rejected.

The tx is then signed with the ring signature using fetched keys + signer as the ring.

Interim Question: What is stopping me from fetching old inputs plus my own fresh input, then creating new outputs of my choosing, which spend the old inputs + my own? It would be valid since the keyImage I use will be the one for my new input, while the total would add up to my input + old inputs

Then look for another tx, fetch K inputs and outputs from that tx along with their public keys.

You simply find decoy outputs from anywhere on the blockchain. You'd never only choose decoys from a single transaction.

  Then add those K inputs as inputs to my tx, along with the corresponding outputs for them

There is no need to match inputs and outputs from other transactions. The ring signature proves that for at least one combination of inputs, the inputs balance out with the outputs and fees.


Can I sweep funds in mymonero to another wallet? I have too little funds in MyMonero. Is there a way I can sweep those funds into another wallet?

I'm guessing I tried doing this once before, but it didn't like me sending all because it wanted some for fees. I'm really not sure.

You cannot transfer to another wallet with different address without a transfer fee. However, if you want to use a CLI or GUI wallet you can do so.

If using a GUI follow this guide:

How do I use my MyMonero wallet via the Monero Core GUI?

or using a CLI:

If I saved my view key and spend key can I recover my wallet if my mnemonic seed is lost?

FYI. Transfer fee has decreased since the last hard forked in April 15.


How can a View Wallet be implemented in code? I'm interested in implementing a view wallet in code. I've seen this example which worked great, however the only problem is it also requires a public spend key.

I saw this question but I can't really follow what steps I would have to take to extract all that data from a transaction.

Can somone layout in psuedo or actual code the process needed to tell if an output belongs to you in a given transaction? Here's what I have so far, adapted from the github example:

void printTxOutputs(Crypto::Hash transactionHash)
{
  std::vector<TransactionDetails> transactions;
  std::vector<Crypto::Hash> transactionHashes;
  transactionHashes.push_back(transactionHash);

  m_node->getTransactions(transactionHashes, transactions, callback);

  TransactionDetails ourTransaction = transactions[0];

  AccountKeys keys;
  m_wallet->getAccountKeys(keys);

  Crypto::SecretKey privateViewKey = keys.viewSecretKey;
  Crypto::SecretKey privateSpendKey = keys.spendSecretKey;

  /* The transaction public key */
  Crypto::PublicKey publicTransactionKey = ourTransaction.extra.publicKey;

  /* The users public spend key */
  Crypto::PublicKey publicSpendKey;
  Crypto::secret_key_to_public_key(privateSpendKey, publicSpendKey);

  /* Derived key is created from the users private view key and the public
     transaction key */
  Crypto::KeyDerivation derivation;
  Crypto::generate_key_derivation(publicTransactionKey, privateViewKey, derivation);

  Crypto::PublicKey outputPublicKey;

  bool found = false;
  uint64_t sum = 0;

  /* Loop through each output in the transaction */
  for (size_t i = 0; i < ourTransaction.outputs.size(); ++i)
  {
    Crypto::derive_public_key(derivation, i, publicSpendKey, outputPublicKey);

    TransactionOutputTarget target = ourTransaction.outputs[i].output.target;

    KeyOutput targetPubKey = boost::get<CryptoNote::KeyOutput>(target);

    if (targetPubKey.key == outputPublicKey)
    {
      uint64_t amount = ourTransaction.outputs[i].output.amount;

      std::string xmr = m_currency.formatAmount(amount);

      sum += amount;

      found = true;

      logger(INFO, GREEN) << "The transaction output of " << xmr << " XMR belongs to you!";
    }
  }

  if (!found)
  {
    logger(ERROR, BRIGHT_RED) << "No outputs were found that belong to you, searched " << ourTransaction.outputs.size() << " outputs.";
  }
  else
  {
    std::string xmr = m_currency.formatAmount(sum);

    logger(INFO, GREEN) << "Outputs totalling " << xmr << " XMR were sent to your wallet!";
  }
}

The code is slightly pruned to remove cruft.

Your code looks fine to me. Here is an explanation of what it's doing:

For each transaction, get the public key of each output listed in the transaction. Call the public key P.
We need to check whether this output was destined for us. We do this by calculating P' as P' = Hs(aR || i)G + B. If P' == P then the output is destined for us.

The generate_key_derivation method in your code produces aR. The derive_public_key uses that to then calculate P' as Hs(aR || i)G + B.

The only step that I think seems to be missing is to decrypt the amount of the output. For details, see my answer here How the receiver knows the amount that he received from the sender?

You probably also want to extract the public spend key from the user's public wallet address, rather than require that you know their private spend key to derive it. For information on how to extract it, see https://xmr.llcoins.net/addresstests.html


Message "Ours and foreign blockchain have only genesis block in common... o.O" When I'm syncing the blockchain for the fist time, I have this error message 8 times

2016-Sep-26 19:58:50.608535 [P2P3]ERROR /tmp/monero/src/monero-0.10.0/src/cryptonote_core/blockchain.cpp:1835 Ours and foreign blockchain have only genesis block in common... o.O
2016-Sep-26 19:58:51.845898 [P2P9][139.59.11.117:18080 OUT]Sync data returned unknown top block: 1 -> 1144519 [1144518 blocks (888 days) behind]
SYNCHRONIZATION started

and then I only have the regular information message

Synced 401/1144519

Should I care about this error message?

Nothing to worry, when you are starting to sync and theres a node trying to sync with you, it sends the list of blocks it has for catching up but since you have nothing but the genesis block you see this message.


Generate bulk integrated adresses Is there a way in the GUI or CLI to generate a large amount of integrated addresses?
I'd like to have a bunch of addresses on hand so I don't have to open my wallet just to generate one.

You probably should be using subaddresses instead of integrated addresses. You can have a view only wallet so that if your server is compromised, your funds cannot be stolen.

If you really want to generate an integrated address without a wallet see here on how to do so: Generate an integrated address using javascript in the browser?


Monero wallet balance still zero after transfer As a setup test, a friend has attempted to send me 0.3 Monero to my Monero Wallet.

My Wallet was offline at the time.

I have started the server using ./monerod --offline and running ./monero-wallet-cli

On typing balance, the number of coins is still zero.

Questions:

If setup is correct, typically how long before the coins should arrive?
Would there be any issue with my server and wallet being offline at the time?
if the coins don't arrive, is there anyway I can trace this from my end? What information from my friend do I need to trace?
Is there any issue running with the ./monerod daemon with the --offline command

If setup is correct, typically how long before the coins should arrive?

One to five minutes.

  Would there be any issue with my server and wallet being offline at the time?

As long as the daemon (monerod) is synced through the date/time of the transaction, then it doesn't need to be online when using monero-wallet-cli to refresh your wallet's balance.

  if the coins don't arrive, is there anyway I can trace this from my end? What information from my friend do I need to trace?

Transaction ID's are public, so he/she can provide you that.  You could then use a block explorer like xmrchain.net or moneroblocks.info to verify the transaction is recorded in the blockchain.  On certain block explorers, you can input your address and private view key and it'll show you which outputs were sent to your address.

  Is there any issue running with the ./monerod daemon with the --offline command

Taking into account my answer to your second question, no, there's no issue. (Well, that's assuming you don't need to send Monero. If you do need to send, then you should probably not run in --offline mode when you generate the transfer, though I think you don't technically have to be online).

  On typing balance, the number of coins is still zero.

I recommend typing status into the daemon to verify the extent to which it has synced.  I would also verify the transaction sent to you is in fact recorded in the blockchain (and at what block).


How can I back up my node efficiently? I have two external disks, each with a copy of the Monero blockchain. Most of the time, one of the disks sits in a cupboard and its copy of the blockchain lags behind. Every few days, I plug it in and restart monerod with a suitable argument to --data-dir.

My internet connection is slow, so the efficient way to synchronize my lagging copy against my synchronized copy would surely be something purely local. Perhaps I could run two instances of monerod on the same machine, with settings that cause one of my disks to synchronize against the other; but I don't know what command-line arguments to use. Can someone provide an example?

Or, if there's a better way, what is it? For instance, are there generic computer backup protocols that can update the lagging file by reference to the up-to-date file?

Edit: user36303 has previously provided two good answers to this question. I'm accepting jtgrassie's answer (below) though, because it works using monerod itself, i.e. with no requirement to install anything else.

Perhaps I could run two instances of monerod on the same machine, with settings that cause one of my disks to synchronize against the other; but I don't know what command-line arguments to use. Can someone provide an example?

If you start a second monerod instance like:

monerod --p2p-bind-port 38080 --rpc-bind-port 38081 --zmq-rpc-bind-port 38082 \
    --no-igd --hide-my-port --p2p-bind-ip 127.0.0.1 \
    --data-dir /path/to/backup/data \
    --add-exclusive-node 127.0.0.1:18080

It will sync it's blockchain from your main, localhost, instance of monerod.


Wallet RPC (transfer): Empty Transaction Key (tx_key) received I run into an issue where when submitting an RPC request to the transfer method,
the tx_key (that helps prove a tx was made) is not being returned.

I explicitly mention get_tx_key so that the tx_key gets returned. According to the transfer RPC documentation.

Also made sure I set store-tx-info to 1 in the CLI.

Sample request:

array (
  'destinations' =>
  stdClass::__set_state(array(
     'amount' => '0.01314010',
     'address' => '44P8rkTRW5u1i...cEePYi4J5Vr3QLimydCX',
  )),
  'mixin' => 4,
  'get_tx_hex' => true,
  'get_tx_key' => true,
  'payment_id' => 'xxxx...xxxx',
)

What is being returned is:

stdClass::__set_state(array(
   'amount' => 1140160000,
   'fee' => 10785600000,
   'multisig_txset' => '',
   'tx_blob' => '',
   'tx_hash' => 'xxxx...xxxx',
   'tx_key' => '',
   'tx_metadata' => '',
))

As you can see the tx_key property was returned empty. This isn't the desired nor correct behavior.
Any ideas?

Tx keys are stored in the wallet you use to make a transaction.

Tx keys cannot, however, be recovered if you restore a wallet from seed. If you have multiple wallets, only the wallet that you used to make the transaction will have a record of the tx key for that transaction (unless you have manually exported and imported those tx keys to the additional wallet).


Monero GUI Beta 2 Window Covering Entire Screen (Linux, Arch x64) When running the Beta 2 release of GUI on Arch Linux x64 the window is too big and it covers my entire screen! What can I do to fix this?

It's already fixed in the code and you could re-build the GUI with that fix. Next release shouldn't have this problem.

In the meantime, and if you want to avoid re-building, you can edit the start-gui.sh script which came with the package and add the line export QT_AUTO_SCREEN_SCALE_FACTOR=0. Then, open the GUI by running ./start-gui.sh from the console.

After modification, the start-gui.sh file should look like this:

#!/bin/bash
export QT_AUTO_SCREEN_SCALE_FACTOR=0
export LD_LIBRARY_PATH=`pwd`/libs
export QT_PLUGIN_PATH=`pwd`/plugins
export QML2_IMPORT_PATH=`pwd`/qml
./monero-wallet-gui


How do I start accepting monero at my restaurant/store? What is the process for accepting monero at stores?  I would love to start accepting Monero.

There are two main ways you can go:

run your own Monero infrastructure
use a payment processor to do it for you

The first one has you running a Monero node and wallet, and use monero RPC to manage payment ids, track incoming transactions, etc. There are early plugins for some common store software: https://github.com/monero-integrations/monerowp/releases/tag/0.1 for Woocommerce, and a work in progress for Prestashop: https://github.com/monero-integrations/monerops, both by the same author (serhack). You can also do custom integration, and you can find instructions on using the RPC at https://getmonero.org/get-started/accepting/. Likely you will need help if you go this route, and the people in #monero (Freenode IRC) will be able to give a hand should you need to.

A variant of "doing it yourself" if all payments are face to face is to use the monero GUI alone, or Kasisto (What is Kasisto?): those have a "payment tracker", in which you can generate a payment id for a customer, and scan the blockchain for incoming payments matching that payment and owed amount.

The second one requires you to pay a service provider such as https://www.coinpayments.net/ or, at some point in the (hopefully near) future, https://payb.ee to handle Monero-to-fiat conversion.


How to use the sweep_all command with options like ring_size or priority could you please tell me how to use this exactly? For example I want to sweep_all a wallet with low <priority> (in the GUI that would be x.25 I guess) to another address with default <ring_size> parameter

How do I do that inside the monero-wallet-cli ?

Thank you!

First, it should be noted that sweep_all combines all available unspent outputs in the current account in a single transaction. Thus, your transaction may have a lot of inputs, which could be detrimental to your privacy if you received outputs that are close in proximity, i.e., from the same transaction or from multiple transactions in the same block.

Now, if you type help into monero-wallet-cli and look at sweep_all, it will show the following:

sweep_all [index=<N1>[,<N2>,...]] [<priority>] [<ring_size>] <address> [<payment_id>]

Note that [] indicates that the parameter is optional. Thus, index, priority, ring_size, and payment_id are all optional parameters, whereas address is a mandatory parameter. Let's discuss all these parameters separately.

[index=<N1>[,<N2>,...]

The index parameter can take any argument as long as it's an (unsigned) integer that corresponds to a primary address or subaddress that possesses a balance. For example, let's say your current account has three subaddresses all possessing a balance of 0.1 XMR and a main / primary address possessing a balance of 0.5 XMR. If you use sweep_all index=1,2 <address>, it will only spend the 0.1 XMR of subaddress A and the 0.1 XMR of subaddress B for a combined 0.2 XMR. Similarly, if you use sweep_all index=0,3 <address> it will only spend the 0.5 XMR of the main / primary address and the 0.1 XMR of subaddresses C for a combined 0.6 XMR. If this parameter is omitted, sweep_all will use all available unspent outputs within the account.

[<priority>]

The priority parameter has four available arguments, namely unimportant, normal, elevated, and priority. In monero-wallet-cli, the corresponding arguments to the priority parameter can only be passed as string. Put differently, you cannot specify them as (unsigned) integer. In addition, the default will be used if this parameter is omitted. More specifically, by default, the wallet will use the unimportant level if there's low traffic on the network, whereas it will use the normal level if there's considerable traffic on the network. Considerable traffic is defined as 80% of the last blocks being full and the mempool not containing a backlog. Lastly, note that any argument specified by the set priority command (e.g. set priority 1) will override this default behavior.

[<ring_size>]

The ring size parameter can take any argument as long as it's an (unsigned) integer that is equal to or greater than 7 (the current minimum ring size enforced on the protocol level). The default of 7 will be used if this parameter is omitted.

<address>

The address parameter can take a standard / plain address, a subaddress, or an integrated address as argument. Address is a mandatory parameter and thus cannot be omitted.

[<payment_id>]

The payment ID parameter can either take a short, encrypted 8-byte (16 hexadecimal characters) payment ID or a long, unencrypted 32-byte (64 hexadecimal characters) payment ID as argument. Two things to note. First, reusing a long, unencrypted payment ID will result in your transactions (that use the same payment ID) being linkable. Second, an integrated address is basically the result of embedding the short, encrypted payment-ID in the plain / standard address. Therefore, separately specifying the short, encrypted payment ID when sending to an integrated address is redundant and may even result in an error. Lastly, no payment ID will be attached to the sweep_all transaction if the payment ID parameter is omitted.

As a practical example, let's say you want to send an unimportant sweep_all transaction from the main / primary address (within the account) using ring size 10 to the general dev fund with a long, unencrypted payment ID attached (we'll use 1234567890123456789012345678901234567890123456789012345678901234 for this example). The command would then be:

sweep_all index=0 unimportant 10 44AFFq5kSiGBoZ4NMDwYtN18obc8AemS33DBLWs3H7otXft3XjrpDtQGv7SqSsaBYBb98uNbr2VBBEt7f2wfn3RVGQBEP3A 1234567890123456789012345678901234567890123456789012345678901234


Compiling GUI from source differences by OS Has there been a stated reason why instructions to compile the new GUI from source are currently available for Linux and OSX but not Windows? Since Windows users have been most vocal about their desire for a GUI I would like to understand the reason (if any) for the current prioritization of the developers working on the GUI.

https://github.com/mbg033/monero-core#compiling-monero-core-from-source

https://github.com/monero-project/monero-core#compiling-monero-core-from-source

Are compiling instructions more difficult to create for Windows?

Is testing needed more for Linux and OSX than for Windows?

What other reasons can explain the current prioritization?

There is no publicly available reason as far as I know, but compiling on Windows is usually a bit more difficult to compiling on OSX and certainly on Linux. However, Ilya Kitaev has provided Windows build instructions in one of his branches. The instructions have, at the time of writing, not been PRed to master yet. The Windows compile instructions can be found here. The instructions are as follows:

  On Windows:

  Install msys2, follow the instructions on that page on how to update packages to the latest versions
  Install monero dependencies as described in monero documentation
  Install git:

  pacman -S git

  Install Qt5:

  if you need to build x86 application, install:

  pacman -S mingw-w64-i686-qt5

  if you need to build x64 application, install:

  pacman -S mingw-w64-x86_64-qt5

  Open mingw shell. MSYS2 will install start menu items for both mingw32 and mingw64 environments, so    you need to open
  appropriate one:    %MSYS_ROOT%\msys2_shell.cmd -mingw32 for x86
  targed    or     %MSYS_ROOT%\msys2_shell.cmd -mingw64 for x64
  targed

  Where %MSYS_ROOT% will be c:\msys32 if your host OS is
  x86-based or c:\msys64 if your host OS    is x64-based
  Clone git repository:

  git clone https://github.com/monero-project/monero-core.git

  Build the project:

  cd monero-core
  ./build.sh

  Take result binary and dependencies in ./build/release/bin

  important: if you testing application within VirtualBox virtual
  machine, make sure 3D acceleration is enabled    in machine's
  settings:    Machine > Settings > Display > [v] Enable 3D
  Acceleration


How the H_p(x) (Hash to a point on the curve), is calculated in Monero? How the H_p(x) (Hash to a point on the curve), is calculated in Monero?

The reference in [1] state that it calculated directly.

Is it also use keccack?

[1]- Zero to Monero https://getmonero.org/library/Zero-to-Monero-1-0-0.pdf

Hash to point first uses keccak, and then interprets the result as an EC point. The point is multiplied by 8 to ensure that the point is in the group of the base point G. You can see the implementation in the Monero codebase here: https://github.com/monero-project/monero/blob/8f6f674753bae7494e1ee4569004947d47a4e983/src/crypto/crypto.cpp#L481


How does Boolberry's Wild Keccak work? Boolberry uses an algo named Wild Keccak. This is refered to as a blockchain based POW. How does this work?

There is a high-level description of this algorithm at http://cpucoinlist.com/cryptocurrency-algorithms/wild-keccack/ which reports as follows:

  Wild Keccak is a Keccak hybrid which uses blockchain data as
  scratchpad. After each Keccak round, pseudo-randomly addressed [state
  vector used as addresses] data is taken from scratchpad and XORed with
  state. Calculating each block PoW usually hits about 1100 randomly
  addressed reading of blocks by 32 bytes.


How can we view the balance of a cold wallet storage and keep it cold? I have made a cold wallet storage following debruyne's guide: https://www.reddit.com/r/Monero/comments/48cgmd/an_extensive_guide_for_securely_generating_an/

I would like to know what is the procedure to be able to view the balance of my cold wallet storage as it is scary to not know if the funds in the cold wallet storage have been compromised. I want to keep the wallet cold while verifying the balance.

I heard there was a guide that was planned on being made about this but an ETA would be awesome.

This can already be done. You'll need the keyimages of the wallet in order to see the correct current balance of your wallet, this can be dome using the command,

  export_key_images

within the monero-wallet-cli interface, it will then save them to file, and then you can import that file into your watch only wallet using the command

  import_key_images

to update your view-only wallet.


Do I need to redownload the Aeon blockchain for the rebased software? I have a legacy v0.9.14.0 aeond running, fully synchronized. When I install the rebased software, will I need to redownload the Aeon blockchain from scratch, or can I convert the existing blockchain folder to LMDB format directly?

There's currently no way to convert the existing blockchain to LMDB format. Technically, you have to re-download. However, since you already have that legacy blockchain, there's a faster way by using that as the exclusive source for your synchronization.

As a first step, relocate the blockchain directory and start up the legacy aeond daemon using the --data-dir parameter:

mv ${HOME}/.aeon ${HOME}/.aeon-legacy
${PATH_TO_LEGACY}/aeond --data-dir ${HOME}/.aeon-legacy

Next, start up the rebased aeond daemon using the --add-exclusive-node parameter and – temporarily – different TCP ports, e.g.:

${PATH_TO_REBASE}/aeond --add-exclusive-node 127.0.0.1 \
    --p2p-bind-port 11190 --rpc-bind-port 11191

Once the blockchain is fully synchronized, you should see the message SYNCHRONIZED OK. After that, you can stop the legacy aeond daemon with the exit command, and restart the rebased aeond daemon without the extra parameters.

  Note: Optionally, you can remove the legacy blockchain directory ${HOME}/.aeon-legacy if you don't intend to start that up anymore.


Is there a way to import the extra info of outgoing transactions to a restored wallet? Let's say I have a wallet with some outgoing transactions. The transaction history shows the recipients' addresses, the payment ids, etc.

Now let's suppose that the wallet file gets corrupted for some reason. I then create a new wallet file using the mnemonic seed of the corrupted wallet, rescan the blockchain, and I get a restored wallet.

However, the transaction history of the restored wallet doesn't show the recipients' addresses of outgoing transactions because they are neither stored in the blockchain nor computable from blockchain data, but only kept locally in the wallet cache.

Is there a way to export the extra info of outgoing transactions (recipient address, payment id, transaction key) of a wallet to a file, and import that file to a restored wallet in order to get back the fully detailed transaction history?

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

The answer is: make backups.

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

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

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


Is there a way to see the blockheight at a specific point in time? Let's say I wanted to know what the exact blockheight of the Monero blockchain was on March 21st 2019. Is there a way to do this or an easy to follow chart or something?

Monero targets a new block every 2 minutes, so if we set H as the current block height, N as the current timestamp, T as the past timestamp of the datetime you want to know the block height of, then:

H - (N - T) / 120

Gets you very near. Blocks aren't mined exactly every 2 minutes, so there will be fluctuation. To narrow down further, you can then use a block explorer like https://xmrchain.net/, or your local node.

For example, trying to find the first block mined on March 21st 2019:

1885896 - (1564019260 - 1553126400) / 120 = 1795122

Which is a couple of hours off: 2019-03-20 21:42:02. Using the block explorer, you can skip forward and find that block 1795175 was mined at 2019-03-21 00:02:52.


Issues mining on a HD 6850 I've been trying to put an old card into use into my PC. However I can not get it to start mining, After I installed the drivers I launched xmrig-AMD and tried to start mining however after detecting the gpu it just hung, did not respond the keyboard. After closing it and reopening the computer BSODed and gave the error: "thread stuck in device driver". I've tried other miners such as xmr-stak and all fail to start mining. I've also tried attaching a monitor to the gpu but to no avail. I can't think of anything else to try, is the card dead? I can just use it for normal usage though so I can't understand why I can't mine.

I'm mining with HD 6950 in Windows 7 x64 and xmr-stak 2.1.0 using the drivers 14.1 beta, download drivers here: http://www.guru3d.com/files-details/amd-catalyst-14-1-beta-1-6-(13-350-1005-january-31).html

Remember to use an app like MSI Afterbuner to regulate the fan and clocks (I don't recommend to OC), my card is hot and is the reference card so I have to set the fan to 55% and the card does not reach 65°

I get: ~300 h/s

EDIT:

You can download here the binary that I compiled with VS 2017, I didn't modify anything, I just compiled using the guide provided in xmr-stak github, I think it works because I installed the latest AMD APP SDK, with the binary provided from the official github I also get 90 h/s


My name contains a special (non-ASCII) character (e.g. é, ø, â, Ö) and I can't create a wallet with the GUI Basically title. The GUI doesn't let me create a wallet even if I specify a different wallet directory. Is there any workaround so I can use the GUI?

Let's start with explaining in detail why this happens. This issue is basically the result of two bugs and is Windows specific. First, upon creating a new wallet, the GUI creates a temporary wallet file in C:\Users\<username>\AppData\Local\Temp\. It'll use this temporary directory regardless of the directory specified for the wallet. Therefore, even if you specified a different directory, the GUI will be unable to create a wallet because it can't store the temporary file. Second, the GUI only supports UTF-8 input strings for the wallet path and therefore is unable to create a wallet file that contains special characters. Likewise, it'll be unable to load a wallet file that is stored in a directory whose path contains a special character.

Fortunately, however, there is a quick workaround that allows you to create a wallet and use the GUI. Perform the following steps:

Browse to the directory monero-wallet-gui.exe is located.
Open monero-wallet-cli.exe by double clicking on it.
Enter a new wallet name + password. It'll also give you the 25 word mnemonic seed, make sure to note it down, i.e., make a back up of it.
After creating the wallet, exit monero-wallet-cli by typing exit
Open monero-wallet-gui.exe
On the second page of the wizard (first page is the language selection), choose Open a wallet from file
Now browse to the same directory as monero-wallet-gui / monero-wallet-cli. There should be a <wallet-name>.keys file (this is the wallet you just created with monero-wallet-cli). Select it.

You should now be able to use the GUI :)


Raspberry pi 3 set and forget I want to setup a raspberry pi 3, then forget about it. Which software can I use that had an auto update feature or setting up a cron job to update the software?  The reasoning is in case there is a vulnerability that needs to be patched a few months after I set it up.

Thank you,

If you get the daemon up and running after building it then you could just write a script to run git pull and check if there's any updates and if so rebuild then restart the daemon. Or similarly if you're just downloading a binary check the hash of the binary file every day or week to see if it's changed, and if so download new version, stop old one, and start new version. I don't think there's an easy out of the box solution for this though, probably going to have to kind of roll your own.


Does I2P have a test network? Does I2P have a test network ?

If not, how are the major changes tested ?

No. There is no current public I2P testnet.

The I2P protocol already specifies a NETWORK_ID (equal to 2 for mainnet), so it should be easy to add.


Monerod using all server bandwidth I have monerod running on ubuntu linux. After syncing, it continued to upload the blockchain to other users. It is using all of my bandwidth! My VPS has an upload limitation which is rather low (no download limit). I would like to disable this uploading. I tried using out_peers but it gives me an error saying unsuccessful. After googling the error, it was somewhere said that this got fixed.. apparently not. I could also use out_limit but it seems like this is not working properly either (using more bandwidth than I specified). Can I block the ports and have it still download the blockchain? If so, which ports and how can I do this exactly?

This post should help you a lot. It discusses how to set bandwidth limits.

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 (while monerod is already running):

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

I would suggest setting your upload limit to something slow like 10 KB/s. Setting it to 0 would make it hard (maybe even impossible!) for you to find other peers to download from.


How to prove my Monero balance to the world? Viewkey allow to disclose incoming txs.  I need to solve a task of making transparent and provable address for our Monero funds. We are investment fund and this feature is mandatory for us.

This is only feasible with the latest simplewallet from https://github.com/monero-project/bitmonero/, which adds a couple new commands for this (export_key_images and import_key_images).

You, who want to prove balance, need to do a few things:

in simplewallet, run export_key_images key-images

This will save a signed list of key images to the file key-images.

Send the auditor(s) (or make public) your wallet address, the view private key of that wallet, as well as the key-images file you just made.

The auditor then creates a view wallet for your key:

./simplewalet --generate-from-view-key

There will be prompts for address and view key. Then run this command in simplewallet: import_key_images key-images

Include a path to the file if it's not in the current directory.

If all goes well, the view wallet's balance will match the original one.

See Can I fake a balance by giving the view key to an auditor but omitting some transactions and key images? for more information why this cannot be gamed.


What is the proper format for a wallet-cli transfer since 0.11.0.0? I'm trying to send to Shapeshift while stating priority and ring size. I'm either getting Error: failed to parse address or Error: payment id has invalid format. I'm using [] around the priority, ring size, and payment ID, as the example on wallet-cli shows. I'm also copying the address and payment ID straight from Shapeshift. I'm getting these problems without the [] as well.

The [] characters are not meant to represent actual [ and ] characters to type. They are normally used to denote optional parameters, though this not always the case.

If you wanted to send a normal priority transaction for 10 monero to address 4blah with ring size 5 and payment id 1234, then you would use:

transfer normal 5 4blah 10 1234

The real payment ID should be 256 bits (64 hexadecimal characters). If you see one that's only 64 bits (16 hexadecimal characters), it's not meant to be used manually, and should be used as part of an integrated address.


How can I get my own genesis tx to use in my monero fork? I have been searching for ever on how to get my own genesis tx for a monero fork. Everything I have tried has not work. I have tried using a cryptonote currency to generate a genesis tx then replacing the values the same everywhere. I have also tried decoding the genesis block trying to figure out which parts to change "How can I create a new Monero genesis block?". None of this has worked. If anyone has any idea on how to do this I would greatly appreciate it.

The error I get when i put in my own genesis tx and run the daemon is Failed to generate genesis block.

Edit: The article How to generate a new genesis tx? does not seem to explain how to get a genesis tx. It shows how to get a genesis block.

I had the same problem. I had to solve it by writing custom function. It generates new account, save account keys to file, and sends block 0 reward money to it in genesis transaction. It also generates source code line to be changed in the cryptonote config file.

Note: Monero CLI wallet would not see block reward sent in this transaction because it does  not process genesis tx - processing of it has to be forced in wallet code.

I have also added command line option --print-genesis-tx to src/daemon/main.cpp where I call this function.

// Helper function to generate genesis transaction
void print_genesis_tx_hex(uint8_t nettype) {

using namespace cryptonote;

account_base miner_acc1;
miner_acc1.generate();

std::cout << "Gennerating miner wallet..." << std::endl;
std::cout << "Miner account address:" << std::endl;
std::cout << cryptonote::get_account_address_as_str((network_type)nettype, false, miner_acc1.get_keys().m_account_address);
std::cout << std::endl << "Miner spend secret key:"  << std::endl;
epee::to_hex::formatted(std::cout, epee::as_byte_span(miner_acc1.get_keys().m_spend_secret_key));
std::cout << std::endl << "Miner view secret key:" << std::endl;
epee::to_hex::formatted(std::cout, epee::as_byte_span(miner_acc1.get_keys().m_view_secret_key));
std::cout << std::endl << std::endl;

//Create file with miner keys information
auto t = std::time(nullptr);
auto tm = *std::localtime(&t);
std::stringstream key_fine_name_ss;
key_fine_name_ss << "./miner01_keys" << std::put_time(&tm, "%Y%m%d%H%M%S") << ".dat";
std::string key_file_name = key_fine_name_ss.str();
std::ofstream miner_key_file;
miner_key_file.open (key_file_name);
miner_key_file << "Miner account address:" << std::endl;
miner_key_file << cryptonote::get_account_address_as_str((network_type)nettype, false, miner_acc1.get_keys().m_account_address);
miner_key_file << std::endl<< "Miner spend secret key:"  << std::endl;
epee::to_hex::formatted(miner_key_file, epee::as_byte_span(miner_acc1.get_keys().m_spend_secret_key));
miner_key_file << std::endl << "Miner view secret key:" << std::endl;
epee::to_hex::formatted(miner_key_file, epee::as_byte_span(miner_acc1.get_keys().m_view_secret_key));
miner_key_file << std::endl << std::endl;
miner_key_file.close();

//Prepare genesis_tx
cryptonote::transaction tx_genesis;
cryptonote::construct_miner_tx(0, 0, 0, 10, 0, miner_acc1.get_keys().m_account_address, tx_genesis);

std::cout << "Object:" << std::endl;
std::cout << obj_to_json_str(tx_genesis) << std::endl << std::endl;

std::stringstream ss;
binary_archive<true> ba(ss);
::serialization::serialize(ba, tx_genesis);
std::string tx_hex = ss.str();
std::cout << "Insert this line into your coin configuration file: " << std::endl;
std::cout << "std::string const GENESIS_TX = \"" << string_tools::buff_to_hex_nodelimer(tx_hex) << "\";" << std::endl;

return;
}


Aeon support at https://xmr.llcoins.net/ According to a message found on the https://xmr.llcoins.net/ website:

  Only XMR is fully supported by this site. Use at your own risk, there is no warranty, etc.

Despite this warning message, in addition to XMR addresses (standard, testnet, truncated and integrated addresses), AEON is supported.

What specific risk is there in using the site to generate standard AEON addresses? Is the cryptography or formatting used to create standard AEON addresses any different than what is used to create standard XMR addresses?

When I create an Aeon address must I always select the Electrum (Aeon Default) Mnemonic Dictionary or can the English (Monero Default), Spanish Portuguese or Japanese Mnemonic Dictionary also be used?

Looks like that in the past the page offered only English dictionary. It did generate valid keys and addresses but you couldn't import it into Aeon simplewallet because it works only with Electrum mnemonics. The page was then upgraded to support changing the wordlist, and is now compatible with Aeon simplewallet if default options are used (Electrum dictionary).

Note that, in theory, you should be ok whatever dictionary you choose because on the protocol level private keys and address is all that matters. However, when changing the dictionary you could run into trouble just because the current Aeon simplewallet (0.9.6.0) doesn't have the option to restore directly from keys and you'd have to hack your way into restoring the wallet generated by non-conventional means.

See here for some background info on what was the problem when generating wallets with that page and when / how it was fixed.


What does "transaction failed" mean in simplewallet? When I opened my account in simplewallet, it said that my transaction failed even though I saw them in a transaction pool on a block explorer. What does the message mean in simplewallet?

Once the wallet creates a transaction, it can fail at several steps.

The first one is to be rejected by the daemon. This can happen if the daemon sees that transction uses already spent key images, has too low a fee, etc. Normally, this should not happen, and the ringCT branch contains fixes for a few of these problems - hopefully fixing all of it.

When this happens, the wallet will warn you with a red message when trying to send.

The second one is that the transaction will never be mined. It may be that the daemon accepted the transction, but other nodes will not accept it, or will never mine it, or simply were never told about it (the latter one could be a temporary problem if using a new daemon with an older wallet).

When this happens, the wallet will first show the transaction as pending
in the transactions history (show_transfers), while the transaction is waiting to be mined in the pool. If it is dropped by the pool, and was not added to the blockchain, this status will then change to failed. At this point, you used to need to run rescan_spent as the wallet became confused about which coins were spent and which were not, but this is now fixed in the RingCT branch (this one does seem to fix a lot of things, doesn't it).


Can I quickly move my node from my Windows box to a virtualbox Ubuntu guest by making the blockchain path a shared folder? That's. That's pretty much it. I'm just wondering if I can do this and whether it'll work properly. Just shut down the Ubuntu guest, go into the VBox manager, make the folder with the extant blockchain files shared and mount it to Ubuntu's default localnode path, then go back into the virtual Ubuntu machine and start node setup with the blockchain already in place.

P.S.: I would just export/duplicate the files onto the virtual machine instead of linking them but the blockchain is already a good order of magnitude larger than my average size for entire *nix hard drives.

I'm pretty sure you're not going to be able to share a folder on Windows and mount it in a VirtualBox guest Ubuntu, using the blockchain from that mounted shared folder. This is because the blockchain file is memory mapped when opened and I'm pretty certain vboxsf (which is the kernel module that handles the share), doesn't support this.

You could create the share and copy/move the file(s) to a non-vboxsf mounted folder, just not use it from the mounted share. If space is your concern, start monerod from scratch on your VM with --prune-blockchain. That will give you a much smaller blockchain on disk.


How to use the view key to see amount sent to cold storage? I know that you can't view both incoming and outgoing transactions of a cold wallet, but I'm still confused as to how I can see if my previous transactions I made have actually reached my cold storage address. I know I should use the view key, but don't know if I should use the view key for the cold wallet in simple wallet or in a block explorer.

The CryptoNote protocol allows you to verify that your funds arrived safely at your cold wallet address. This is done as follows. You can verify that your funds arrived safely at your cold wallet address using this tool or this explorer/tool. The former tool is created by luigi1111, who is one of the core-team members of Monero, and fetches data from Moneroblocks. The latter tool uses its own explorer to fetch data, namely Monero Explorer.

First, make sure to save the transaction hash shapeshift, an exchange such as Poloniex, MyMonero, or simplewallet provided you with.
Fill in the cold wallet address, the viewkey that belongs to the cold wallet address (MoneroAddress provides this), and the transaction hash of the specific transaction. It should show you:

  This address owns output x with pubkey: xxxxxxxxxxxxxxxxxxxxxxxxx for amount x.xx

The sum of those outputs should be equal to the amount that was sent. An example of how it should look like can be found here. Generally it is suggested using a test amount first to try out the tool and get a bit familiar with it. Furthermore, the tool will check if the viewkey matches the address. Thus, in case you made a typo when noting down the addressor viewkey it will show you an error message to prevent you from sending funds into  limbo. Alternatively, if you made a typo when typing over the address or viewkey from either the printed page or the page were you noted down everything it will show you an error message too. Using this tool you can be certain that your funds arrived safely at your freshly generated cold (paper) wallet. Even if you are filling your "real" wallet, it is generally advised to first send a small transaction to test if "everything works". Furthermore, it is advised to first make a test wallet (e.g. 1 XMR) and restore that, so you can also verify with your own eyes that the funds arrived safely at the address.

Lastly, if you are looking for a guide on how to  securely generate an offline cold paper wallet, it can be found here.

  outgoing transactions of a cold wallet

For clarity, there are possibilities to do this. These have been discussed extensively before and implications have been posted in this thread. Furthermore, an important "feature" to do so has been merged into master a few weeks ago. From the pull request:

  They are used to export a signed set of key images from a wallet with a private spend key, so an auditor with the matching view key may see which of those are spent, and which are not.

It should be noted though that key images only work in a adversarial way.


Logic behind selecting even square root for fe_sqrtm1 = sqrt(-1) That is the logic behind selecting even square root for fe_sqrtm1 = sqrt(-1)
x = sqrt(-1)

x = 547cdb7fb03e20f4d4b2ff66c2042858d0bce7f952d01b873b11e4d8b5f15f3d
x = 2b8324804fc1df0b2b4d00993dfbd7a72f431806ad2fe478c4ee1b274a0ea0b0

Value 2b8324804fc1df0b2b4d00993dfbd7a72f431806ad2fe478c4ee1b274a0ea0b0 is used here: https://github.com/monero-project/monero/blob/v0.17.1.9/src/crypto/crypto-ops-data.c#L38

I believe you'll find that it's the positive (as opposed to "even"), that's chosen (by convention). The positive one has the sign-bit set as 0.


Do all Monero private spend keys start with a 3? What other patterns are there? Is there a pattern to a Monero private spend key? Do they all start with 3?

No. Private keys are created from 32 random bytes.


What is a disposable address? There is info here about disposable addresses https://github.com/monero-project/monero/pull/1345 and looks like it will be going into testing soon but how do they work really? If I use a disposable address will I need back up those keys or will my main wallet be able to recover all my disposable addresses with my original wallet seed?

I will first quote the abstract of MRL-0006 draft by kenshi84:

In the CryptoNote protocol, wallet addresses never appear in the blockchain, protecting users' privacy from blockchain analysis. However, wallet addresses are inevitably known to senders and can be kept by them locally, which may become privacy concerns. Consider a typical example: a user buys Monero at an account-less exchange service more than once. If the user reuses the same wallet address, the exchange would know the total amount of Monero transferred to that address, which is generally not desirable for the user. A naive solution to this problem is to create a temporary wallet for each fund receipt, which is not only tedious and error-prone, but also vulnerable to temporal association analysis.
In this research bulletin, we propose a new scheme where a single wallet can generate a one-time address for each fund receipt by making use of the payment ID. Two kinds of such one-time addresses are proposed: one is in the current standard address format with a 256bit payment ID attached separately, which is useful in that the sender's wallet software does not need to be upgraded. The other one uses a new address format where a 64bit payment ID is integrated into the address, which is easy to use but requires upgrading the sender's wallet software. The scheme is already implemented and confirmed to work.

In short, it works like this:

Receiving wallet generates a new set of keys and a payment ID. The newly generated set of keys is deterministic and it's generated from the root keys and the payment ID. The root keys are the keys of your standard Monero address.
A disposable address is derived from those new, disposable keys
The sender pays to the disposable address as normal, but he must attach the payment ID from 1. The integrated format proposed makes this easy.
The receiving wallet sees the payment ID, recreates the matching disposable keys and and checks if any of the outputs in the transaction belongs to it.
If yes, you can spend this output as usual. The wallet can combine it with others from your wallet, as it makes no difference. All outputs are created the same, but here we have a bit different scheme on how to retrieve the private key of an output.

It's important to note that it's sensitive to correct implementation of payment ID. If the sender omits payment ID, the recipient has no way of knowing which disposable key to generate. He could recover the funds by trying with all previously issued payment IDs, but it could take a long time. If the sender would provide a TXID, it would make it easier to recover the funds - in case of some dispute or accident.
Also, a new integrated format is required because the payment ID must remain plain-text, while the existing integrated format uses stealth payment ID which encrypts it so it's not fit for purpose.
Re-use should be discouraged because 2 TX-es sent to the same integrated address could then be linked together with high probability. Although, there's still a slight plausible deniability because anyone could be re-using payment IDs already found on the blockchain, only it's not likely.
Also, for the record, here's the history of this development.

If I use a disposable address will I need back up those keys or will my main wallet be able to recover all my disposable addresses with my original wallet seed?

No. Your main wallet will be able to recover all of them because the information required is actually "saved" in the payment ID of the transaction sent to the disposable address. Only in case of faulty implementation where the sender doesn't specify the PID would you need to recover the funds "manually" and send to yourself so you could access them later.


How to check balance of monero paper wallet from nodejs? I'm taking address and viewkey as input then want to return its balance in my expressjs project.  How to call monero blockchain from nodejs for checking balance of any paper wallet?

There are several nodejs packages for working with wallets. They essentially just wrap the JSON-RPC methods on the daemon / wallet RPC interfaces.

You don't actually need a wrapper though as you can just call the JSON-RPC methods directly. For getting the balance, you would call this. The examples use cURL at the command line, but if you know how to make HTTP requests in nodejs, it should be pretty obvious what request payloads to use and the example responses show what JSON data you'll get back.


Monero Genesis transaction & nonce - clarification This is a case of explain like i'm five.

I pretty much got the idea, thanks to knaccc in answer Monero Genesis transaction & nonce.

But just to be clear. If I wanted to generate a new "empty" monero blockchain,

I should generate a new wallet, and transfer "some" monero to this wallet, right?

So I got this wallet, with a few XMR in it, from mining. Could I use this wallet, and for example, the last incoming transaction, for the new genesis block?

In the wallet, I issue [wallet 4xxxxx]: show_transfers in

and get response:

1234567 in YYYY-MM-DD 0.100000000000 0123456789abcdef0123456789abcdef0123456789abcdef0123456789abcdef 0000000000000000 0 -

This (long hex thing) is the transaction (tx public key).
Is this the one I need for my new genesis block?

There's mention of a output one-time public key. How/Where do I find that one?

Looking at the transaction, in block explorer, I cant find anything matching any keys in my wallet.

There's a lot of Public Keys:

Inputs(2) Key Image: Public Keys 14
Outputs(21) Public Keys.

So, where do I go from here?

Or, do I have to do an actual transfer, to get the output one-time public key?

First you need to send yourself some funds on the real Monero blockchain. It doesn't matter how much.

show_transfers in is displaying your transaction id, which is also known as the transaction hash (because the transaction id is a hash of the transaction). This is not the same as the transaction public key.

Look up this transaction id at xmrchain.net. Here is an example transaction: https://xmrchain.net/tx/06576b3b6862818ba23c74a1a40769be695ea417d19c717e3313f6cf1a137eff

The transaction id is 06576b3b6862818ba23c74a1a40769be695ea417d19c717e3313f6cf1a137eff and the transaction public key is 52ac230076b1257cfd12eab526671ab6460656be7f95274450fc78968e64f4fe.

You'll see a list of "stealth addresses". These stealth addresses are also known as one-time output public keys, or output public keys.

You then need to replace the transaction public key and the output public key in the genesis transaction with the transaction public key and the first output public key (first stealth address) listed in the xmrchain.net transaction.

To know how to replace these in the genesis transaction, you need to know the transaction format, which is described here: How can I create a new Monero genesis block?

That description uses the term output #1 key to mean the one-time output public key.


How to limit CPU load on mining pool My pool's CPU load is too high. It has a 24 thread CPU. What is a good solution to use other servers to share the load calculation or together ?

You can try applying the help-to-your-door patch:

https://github.com/moneromooo-monero/bitmonero/tree/cache-block-template

It caches block templates, which helps mining pools a lot.


What would be reasons to further increase block time? I saw in the discussion on the previous increase in block time that some people were suggesting 4 minutes.

What would be good reasons to further increase block time in the future?
Are there scenarios where really high block times would be a good idea? Really high as in 10x the current time or more.

My main interest in this is how it changes the time transactions with unlock_time at a specific block number would be unlocked.

If orphan levels increased or were above some tolerable threshold, an increase in block time would help alleviate the situation. This answer to a question about unlocked balances explains Monero's greater sensitivity to reorganizations.