good night i would like to know how i am part of monero i used google translator i am brazilian help me my country is in shit a lot of misery

please someone

Wrong channel, Lucas Soares,, but feel free to join #monero instead!

how am i part

I need to give the little one a better life

Hi all, I have 3 feature suggestions, should I talk about them here or submit them somewhere else (eg the Monero Subreddit)?

Hi all, I have 3 feature suggestions, should I talk about them here or submit them somewhere else (eg the Monero Subreddit)?

File a request on github.

Assuming it's well formed enough. Otherwise, you can talk about it in #monero too.

moneromooo: Thanks, will do.

Since subaddresses are stored in the wallet file and some merchants depend on it, wouldn't it make sense to have a way of forgetting a subaddresses?

<Siren[m]> "Since subaddresses are stored in..." <- If we have a bunch of subaddresses that we no longer use, afaik our only option currently is restoring the wallet from seed

It would be very convenient to have another way of ignoring/removing these addresses from the wallet file without having to restore

Why would you want that ?

Aren't integrated addresses getting deprecated?

Siren: Can you describe the use case in very general terms? Is this an issue that has affected you?

There are some payment gateways/processors that generate new subaddresses per invoice/transaction

Some people would like to deprecate integrated addresses. It's not clear whether they're going to be.

In theory shouldn't it be a problem if someone were to abuse this feature and generate a bunch of subaddresses?

Ah, you mean if a merchant lets a user request a new address repeatedly ?

Some wallet rpc methods seem to loop over subaddresses

moneromooo: Yes

Yes, if they allow that indefinitely, it could become annoying.

Is it possible to have a wallet rpc method in the future to forget these addresses?

Maybe forget isn't the right term here, I hope the point gets through

Yes. Not sure it'd be a good idea though.

Just don't allow a user to make you generate them.

Forgetting sounds like papering over the cracks of the problem in the first place.

Right, it's more of a responsibility of the higher level application

moneromooo: Was there a conversation about encoding the address index in jamtis somehow so that a payment reciever would know what address it went to without a lookup table?

I think for this to occur naturally without abuse is unlikely

What could be useful maybe is a "did this address ever receive anything" flag. Then a merchant can allow a new address iff the current address received something.

spirobel

Though there's not really much point in generating a new address. We're not bitcoin, that's the point.

wernervasquez[m]: I do not know.

moneromooo: This could be implemented by an higher level application as well. Stnby what do you think?

I think we should do this

Allocate a certain amount of time for the transfer to be made, in case we don't receive anything after the time has passed we should reuse that address

I think the flag I mentioned is already there, in a way: check transfers, whether spent or not, and their address, which I think is available. Might be slow though.

Then again, is there a good reason to give a user power to generate a new address ?

If you can find a good reason, adding such a flag may be of use.

(if checking for transfers is too slow)

Siren[m]: That wouldn't work, we cant wait to see if we can reuse the subaddress because if 5 clients come at the same time we have to generate 5 subaddresses no matter what

We can't just put clients on hold for 4 minutes or so

Stnby[m]: We can ignore the last ever created subaddress and look for previous ones

Shouldn't block? No?

The question is when we create a bunch of subaddresses aren't they all stored in runtime memory?

s/block/blockfor too long/

* Shouldn't block for too long? No?

I think they are

So what do we do with them after a successful payment for a service?

Subaddresses are in RAM. They do not *need* to be though, but moving them to storage would take some change in the way the wallet scans.

How do we remove them from cache as we no longer care if someone actually sends something on that long forgotten subaddresses

ie, scan 1e5 txes, generate their subaddresses, then stream your local subaddress store looking for them.

Stnby[m]: I don't see how it can be a privacy issue to reuse those but some people did not like the idea of it

If we had a feature to get rid of them from cache it would be a perfect solution in my opinion

I think the best way would be that, yes

<Siren[m]> "I don't see how it can be a..." <- if you read the original PR you can see that recycling subaddresses would defeat their purpose: monero-project/monero #2056 just use integrated addresses and forget about this whole mess. Subadddresses are not the right tool for this kind of merchant usecase. xmr.to also used integrated addresses for this reason:

spirobel[m]: We are not using subaddresses for the sake of anonymity and privacy

Neither the 99% of the merchants out there do

Siren[m]: you use them because somebody said that integrated addresses might be deprecated for unclear reasons?

Why would you care about your subaddresses being linked to your applications?

Actually xmr.to moved to subaddress only later on, it did the job perfectly

spirobel[m]: Reasons are, having a Payment ID is a waste of space on everyone Hard Drive

spirobel[m]: I will not explain that to you a fourth time

Because su addresses exist

* Because subaddresses exist

* Reasons are, having a Payment ID is a waste of space on everyone's Hard Drive

binaryFate: yeah xmr.to might not be the best example for this. I think where it really makes a difference is when it comes to non custodial marketplaces.

I can see a use case for this: generate a subaddress on every page load, for accountless things. But in this case I think the high level code should remember what's "used", as it seems fairly dependent on what you're doing.

And you'd need to make it clear to the clients that there'd be a timeout for using such an address.

Maybe the ability to set a "used/unused" flag in the monero wallet to support this might be useful. Unclear.

What you'd do if an old customer sends to an address that'd been reused though, that'd be entirely up to the merchant, nothing monero can do there.

Sounds like it's not the merchant's responsibility

As it's not logical for an old customer to do that

People do non logical things. You gotta expect it :)

Accept it as a donation :)

As long as it's clear at the outset, that's a perfectly acceptable solution.

But you have to ebsure it doesn't monkey with the new user's usage too.

ensure*

We will be implementing the "used/unused" flag in our high level application, shouldn't be too hard since we already keep track of the total amount received and the amount we expected.

Thanks

the question is if it is worth to go through all of this. I dont think this issue is as bad if you used integrated addresses.

We have to do little work to get a flag like that to work for us

Integrated addresses are risky to implement currently and would require us to rewrite the polling part of our application

When there's a clear decision to keep them or to deprecate them, then we might consider it

Siren: If a customer requests a new subaddress, but hasnt used the last one given to them, do you / would you give them the same address, or generate a new one?

The way how things are currently, we are generating new addresses

We haven't experienced anything negative related to this

Jamtis allows you to generate addressed randomly. There is no subaddress lookup table.

btc/bch wallets (electrum/electron) create payment requests ( a sub address which is considered 'used' for x minutes ) . generating a new sub address there is 'getting an un-used address' - and after x minutes without payment, its marked as being unused again. They have a look-ahead value (sometimes 20) where - if 20 consecutive addresses are found with 0 balance it will stop searching and consider the wallet synced which is why they care

so much about re-using addresses.

Personally, i consider the customer/donators experience more than the merchants so i generate unique addresses each time and just handle it on the back end.

The problem of customers spamming 'create new address' requests to your website == ddos , so i just try to mitigate that - e.g. 1 ip can request 20 per day . max 1 per second (ip database deleted every 24 hours)

note it's easy to generate millions of addresses in advance, or on a different server than where your wallet for the webservice is running. Then you don't need to hit wallet-rpc with an address creation request each time, you just grab the next one from those you've saved to your DB

Perfect solution ^ for scaling / anti ddos binaryFate, (ill have to implement that myself) probably useful for customers also - to verify that the address theyve been given belongs to the merchant also (if there was some front end where they can input it to access that pre-generated DB - or the merchant provides the address + index

<binaryFate> "note it's easy to generate..." <- seems clunky but okay. 🙂

<Siren[m]> "Is it possible to have a..." <- Each time there is a new wanabee customer, my merchant website proposes him a (new) subaddress (SA).

However this SA is only removed from being proposed when it is really used, ie it gets a real payment.

Notice also that, from the merchant side, quite everything can be done using SA indexes.

<moneromooo> "What could be useful maybe is a..." <- That's exactly what I'm doing.

Hey what is the general sentiment around adding docstrings in the code, specifically in src/cryptonote_basic?

Do you mean... comments ? If so, if the comments are good, they're a good thing. If they're bad, they're a bad thing.

Do yall have a certain format for the comments that you try to adhere to?

Well, /* */ for C, for C++ typically // but /* */ also works. The important part is the content, which should be useful.

As a general rule, we tend to recommend using the style of the code you're changing, if that helps.

Of course, some code you might want to modify might be horrendous enough that a new style could be warranted :D

The following is a personal preference, but I really hate huge comment walls that prevent me from reading the code. Be succint. Don't write pointless stuff that anyone with a clue can infer from reading the code. It just wastes space.

Useless shite like: uint64_t amount; // the amount

is useless.

Useful comments like void foo(uint64_t amount) /* if 0, the amount was not set and we use a default value */ is useful.

Apologies if this is all obvious, but it's not to everyone and I don't know you :)

In general, adding useful comments would be good.