As it is right now, are you planning to have byzantine consensus for these contracts? Or just try to do verifiable computation?
The contract ensures that the state is valid both before and after any change and every peer who sees the state will ensure it is valid, so it is verifiable computation in that sense.
Happy to chat - you can pm me on reddit or twitter, username "sanity" in both cases.
For example let's say I set of a chat room, and someone spams multiple GBs of data into a channel, can my moderators (in principle) remove those messages without essentially just publishing a new message saying "please ignore all this spam"?
How do you deal with "network splits", that is a smart contract that could have two equally valid states?
You say you use contracts as the key in a key-value store, can you have the same contract with two different data sets? Like two different chat rooms that work the same way but which have different moderators and different message histories?
Correct, in Locutus contract state is mutable, with the contract determining whether changes are permitted and how they are applied to the state.
> For example let's say I set of a chat room, and someone spams multiple GBs of data into a channel, can my moderators (in principle) remove those messages without essentially just publishing a new message saying "please ignore all this spam"?
Yes (although such spamming shouldn't be possible in the first place thanks to the reputation system).
> How do you deal with "network splits", that is a smart contract that could have two equally valid states?
It should be very rare, but contract states that get out of sync can always be "merged" to produce a new state, peers will do this automatically as soon as they figure out the mismatch. The small world protocol that determines network topology should make network splits very unlikely.
> You say you use contracts as the key in a key-value store, can you have the same contract with two different data sets? Like two different chat rooms that work the same way but which have different moderators and different message histories?
Yes, a contract consists of web assembly code to specify the contract functionality, and also "parameters" which are arbitrary data that "configures" the contract (chat room name, owner, etc).
I'll be keeping a close eye on it!
Not possible, or just disincentivized?
Not sure we're going to stick with the name "Locutus" when we launch, so for now it's just a working title for the project.
Also, although web assembly can theoretically be highly optimized by compiling to native code, there are hard limits on scalability especially since many things need to be executed in a specific order. So you have some mechanism for sharding, or are all computations repeated by 100% of the network? Also is there a mechanism for sharding data?
Anyway, I believe that the future of cryptocurrencies, money, and new types of browsers or even normal web applications will all skew heavily towards web assembly.
It should be possible to build a cryptocurrency on Locutus, using the arbiter mechanism to prevent double-spending.
> So you have some mechanism for sharding, or are all computations repeated by 100% of the network? Also is there a mechanism for sharding data?
Computations are not replicated across the network. There is a mechanism that serves a similar purpose to sharding but is more "organic".
Peers are assigned locations in the network when they join (a number between 0.0 and 1.0). Contracts also have locations determined from a hash of the contract code itself, and peers store contracts that are close to their location. The more people using a contract the more widely cached it will be, as a form of auto-scaling.
Locutus uses a small-world network to allow contracts to be found very quickly in an entirely decentralized way.
Since this is written in rust: is there also a version of freenet in rust in the works?
That is an example of the contract API - you can find a better explanation of it here: https://github.com/freenet/locutus/issues/9
We're not re-implementing Freenet in Rust, this is a separate project with related but different goals - however it does borrow a number of ideas from Freenet (like using a small-world network as a DHT).
Just curious. :)
With respect to reading more, currently there isn't too much beyond the Github project, although you can learn more about my previous work here: https://en.wikipedia.org/wiki/Freenet
It's most closely related to https://freenetproject.org/ - which was a previous project of mine.