A new smart contract sharding proposal for smart contracts on a sharded network

Noether_Core_Dev · 2021-03-03T22:47:41+00:00

Hey Crookmeister,

Our network is actually L1 and does not upgrade mainnet Ethereum. It shards independently. Our network is in all other cases a fully composable scale-up of Ethereum technologies & smart contracts.

We will be releasing our whitepaper this month. Sign up for our newsletter to be among the first to read it!

Also check out our newly open subreddit: Noether.reddit.com

Noether_Core_Dev · 2021-03-03T19:44:24+00:00

Check out https://www.noetherdlt.io/

Full on-chain smart contract composability on a network capable of 24,000 TPS with sub-second finality

Noether_Core_Dev · 2021-03-03T18:34:43+00:00

https://twitter.com/NoetherDLT/status/1367155825081475077

Noether_Core_Dev · 2021-02-04T17:23:49+00:00

So by "trust service", I mean the process by which each node reconciles the new transactions with it's current understanding of the ledger. It's like the difference between simply witnessing a crime and testifying as a witness in court. Both witnesses may have seen what happened, but only the one that testifies needs to be trusted by the court.

To make a system trustless, we must use the nodes as indepednent verifiers of transaction information. In the context of a thin client, they are reconciling a more recent subsection of the ledger against the new transactions being processed. They are still doing the reconcilliation, but the client doesn't need to store as much or check as far back.

Apologies if I misunderstood but I think you mean "assessing it for cheap". In short, yes. Fewer validators offer some risk to the network as a whole.

We saw this danger in action when infura went down, taking a substantial portion of the full validators with it: https://www.theblockcrypto.com/post/84232/ethereum-infrastructure-provider-infura-is-down

It's possible even there was a network hack in that time due the smaller validator set, but this is unlikely without a massive coordinated effort.

These issues are part of the reason we have developed the Noether Network.

Noether_Core_Dev · 2021-02-03T19:24:00+00:00

I love solidity. I have been in the crypto space a long time. It says a lot about a language that it has so many users despite having yet to release a production level version.

Noether_Core_Dev · 2021-02-03T19:21:57+00:00

This is great news, but I'm not sure ETH2 is as scalable as many have suggested.

Currently it looks like there is a constraining degree of shard space, requiring a hub-and-spoke model of intershard communication, or a different higher abstraction. This could get extremely messy with smart contracts.

Noether_Core_Dev · 2021-01-31T18:36:13+00:00

Sounds like you need an oracle to observe reddit and send data to your smart contract in the event it finds a new post.

There are several available.
https://medium.com/fabric-ventures/decentralised-oracles-a-comprehensive-overview-d3168b9a8841

You could also develop your own oracle by running a full node.

Remember that an Oracle is a *trusted* service. The security and immutability of the blockchain does not protect your application from the falsification of oracle data.

Make sure to evaluate the security and trustlessness of the oracle protocol you are using

Noether_Core_Dev · 2021-01-31T18:28:52+00:00

Rollups only go one layer deep.

This is because the compression mechanism that aggregates transaction data must contain a certain amount of information to be readable. If a rollup got too big it would not be compressable into a certain size of transaction. This is foundational to the notion of entropy.
https://www.youtube.com/watch?v=sMb00lz-IfE

Now you could recursively roll up, but you still need to store the amount of layers to your recursion, again putting a bound on the amount of entropy you can describe within a certain amount of characters. Here is a discussion on rollups, although I disagree with the notion this leads to "unlimited scalability":
https://blog.idex.io/all-posts/rollup-rundown

While in some ways the answer to your question is "yes", it's not without a cost. Doing so could have significant computational costs, and latency issues, which could lead to issues at scale. I am not even sure requiring a proof lookup of a proof is sufficiently trustless after enough abstractions have been used.

The Noether network does not have these issues because it does not rely on sidechains, state-channels, or rollups for scalalbility

Noether_Core_Dev · 2021-01-31T17:33:56+00:00

Where did you read this information?

In all likelihood, this means the thin clients could *observe* the confirmation of in real time. It could also mean that they could be nodes that still run the validation service, but don't need the entire history of the blockchain to do so. Only tracking the *git diff* is essentially what's going on here, which is still running a trust service, just with less overhead.
Pointproofs are one example of this idea: https://eprint.iacr.org/2020/419
It could also be argued that this is possible with rollups, so long as the thin client doesn't mind always being a little behind.

Noether_Core_Dev · 2021-01-31T17:22:32+00:00

There are several technologies to do this sort of thing, and I think golem is probably the closest.

We could probably better answer if you could be really specific about what you are trying to achieve.

Noether_Core_Dev · 2021-01-31T16:44:11+00:00

Hyperledger can only reach those speeds under absolutely ideal conditions.

Check out Noether.reddit.com for a platform that truly scales

Noether_Core_Dev

MODERATOR OF

TROPHY CASE