How do you know P for a movie ticket or a beer? You remember how much you usually paid recently. If you’re short on money, you may offer a bit less at first, if you absolutely need to have it done and right away, you may offer a bit more to make sure. Again, it’s like a free market.
All of this needs to be handled by the client software of course. Users could set things like “I want my money last for at least 200 GB” or similar and the client software would set P accordingly (though preferably as low as possible). Warning should appear if the request is unrealistic or if rising storage costs make it become so. Something like the mobile data indicator on phones would be useful and already familiar.
If we wanted to take the market idea real far, we could implement a limit order book with users on the bid side and vaults on the ask side, chunks waiting to be accepted for storage. Just musing, not suggesting.
Exposed by whom? I imagined the client would attach it with the request.
Though not absolutely necessary, there could be an informational API call for getting the recent average price, the price at which 99% of the requests were accepted, the last accepted price, or something else that’s both useful and easy to keep track of. As it’s just informational, there’s no need trying to get it absolutely correct about it.
If we want to stick to the “saved once, stored for ever” paradigm, the result must be a flat out rejection. I’m not personally convinced that’s a useful paradigm in the general case but redundancy can only be tuned in very coarse steps when using simple copies as we do so I’m not sure your suggestion is viable here.
TL;DR The request should be refused.
I’m not sure if that’s what you also meant, but having a free market would remove almost all metrics from the network since we no longer need to invent the perfect government. Individual agents would keep their various metrics but, since all that is outside the core, it’s a very different situation.
But they are. It’s just, the close group (currently with size N) must be a bit larger (M) to accommodate a market process where only N<M nodes will get to store any given chunk.
How do we know the address map to an actually existing chunk though? That is, how do we know if we need to punish a vault for not being able to return data for a given request? So, the problem of storing some information about chunks already exists, at which point it takes little more than an additional bitmap in that entry to also note which N of the M nodes should keep a copy of it.
In a distributed network, the best consistency we can hope for is “eventual”. I don’t believe any sufficiently flexible method could result in a more globally consistent value than a free market. Or, that a free market could give that with better consistency than any hand-coded method, for that matter. However, it has desirable properties that rigid hand-coded methods lack.
Within any time period, each client will interact with many random vaults and each vault will interact with many random clients. If that won’t result in some global consistency, I don’t know what would.
The same. People don’t care about chunks. They store files that may span multiple chunks (thus, sections) so a single upload would already need to deal with multiple payments of potentially different amounts.
Many great questions here. I vote for assigning orphaned chunks to the cheapest vault in their new close group and paying the difference from network balance.
What should happen if the given section runs out of money? It isn’t all that different from running out of space as a result of a vault leaving the section though so there may already be some ideas floating around.