Editing Permissioned resource coins (section)

=== Paying for storage space ===

In our sample coin pseudo-code I introduced an algorithm for allocating storage space, but what is missing from this is a protocol for the clients to use for making payments. In practice, all existing storage-based resource coins start by proving custody of a large amount of data.

The way they do this is to generate a large random number to use as a challenge and then prepend it to a piece of content to hash for an answer. To prove that a host still has the content they must be able to reproduce the same answer hash after given the random number.

While this challenge-response game works well for large amounts of content, for smaller pieces of content it is over-kill. What would be interesting is a storage system for smaller pieces of information such as those produced by sensors and other IoT devices.

Because the data is small, my protocol for this is to randomly sample data and check what farmers still have. The client would sign data under the same pub key and record an ID to identify it. That way they only have to maintain an index of metadata to verify bulk data sent over a unique period.

If you wanted to, you could also set a percentage ratio here to adjust how vital the data is to make it more like UDP. It might be okay if you lose one or two sensor readings along the way but not if you lose all of them!

<pre>audits = []
priv_key = &quot;private&quot;
pub_key = &quot;pub&quot;
swarm = coin.allocate_storage(20, pub_key)

def random_audit(swarm, pub_key):
    # An hour ago.
    start_time = time() - (60 * 60)
    end_time = start_time + ((60 + 60) * 2)
    
    # Get a list of data signatures for all data sent over the last
    # hour or so. Yes, I'm getting lazy here.
    offset = audits.get_offset_closet_to_start_time(start_time)
    challenges = []
    while 1:
        audit = audits[offset]
        if audit[&quot;timestamp&quot;] &gt; end_time:
            break
            
        challenges.append(audit)
        
    # Audit swarm nodes for data pieces.
    for farmer in swarm:
        responses = farmer.retrieve(start_time, end_time)
        if len(responses) &lt; len(challenges) * 0.8:
            farmer.micro_payment = &quot;break&quot;
        else:
            total_correct = 0
            for response in responses:
                if response not in challenges:
                    continue
                
                if not valid_sig(response, pub_key):
                    continue
                    
            if total_correct &lt;= len(challenges) * 0.8:
                farmer.micro_payment = &quot;break&quot;
    
def store_content(content, priv_key, swarm):
    for farmer in swarm:
        # Skip this farmer.
        if farmer.micro_payment == &quot;broken&quot;:
            continue
    
        # Sign the data chunk
        nonce = random()
        sig = sign(chunk, nonce, priv_key)
        
        # Pay the farmer for this 
        farmer.store(chunk, sig)
        
        # Record meta data
        timestamp = time()
        audits.append({&quot;timestamp&quot;: timestamp, &quot;nonce&quot;: nonce, &quot;sig&quot;: sig})</pre>
The payment protocol then follows a basic micropayment channel: if a farmer fails an audit, the client closes their channel. Likewise, if a client fails to make payment, the farmer drops storing data for that client. Either side can close the channel at any time to unlock their pending balances (storage space or reserved payment in micropayment channels.)

<span id="optimising-data-usage"></span>