kelili

Trustless computing only needs four primitives:

• Get the result of another computation
• A way to authenticate results as coming from a specific public computation.

It also needs an incentive for blocks to be easily accessible and mintable.

People should pay block providers for blocks.

To publish a block, you have to include proof that you received its dependencies, and that you know what their result is.

Each block would include payment to the people who provided the blocks.

Block-providers would send blocks with the payment to themselves attached. Basically, the blocks would have a check that checks they are paid X amount.

However, they would be cryptographically inseparable.

I know how this could be done.

blocks, when minted, already contain the necessary architecture to support payment.

block-providers would only want to store blocks that support payment.

parametrized blocks!

I don't know how this would work, cryptographically.

What I want is a hash that uniquely identifies a group of blocks.

maybe it could work by promise?

so "if you give me this block, this transaction will be considered signed"

three-way validation.

how can I prove that I received something from someone?

or that I sent something to someone?

I know! the send-transaction, and the receive-transaction is bundled with the data itself.

Thus, everyone who wants to acknowledge the receive-transaction would have to know the data.

This is basically signing unknown data that with a known hash.

when the contract is published, then it must contain the data.

it has to be signed