Summary
In The Graph’s Core Devs Call #17 we receive an update The Graph’s fee system and improvements coming to The Graph’s billing UX, recap the recent Code4rena audit contest and resurface some older GIPs that need to hit the spotlight once again.
Topics Include:
- Introduction
- Scalar Update
- The Graphs Billing UX updates
- Code4rena Recap
- Review Older GIPs
Detailed notes regarding each topic with timestamps can be found below.
Scalar Update (4:33)
Scalar is The Graph’s fee system that has been worked on behind the scenes. It enables fees to flow from gateways to Indexers. Scalar utilizes a custom fee system because every query is enabled by a fee; and The Graph’s hosted service is currently serving more than 1 Billion queries per day. The Graph’s custom fee system should:
- Support more than 1Billlion queries per day
- Be highly concurrent and support requests happening in parallel
- Utilize an efficient dispute system to ensure that when Indexers serve queries, they get paid.
What should be noted about these design goals:
“And what I want you to notice about these design goals is that highly concurrent state channels and efficient disputes seem to be at odds with one another. And these are the things that we need Scalar to be. This is a problem. If we’re solving the problem of parallel requests by spinning up lots of state channels, then the more state channels that you have, the more you have to do on chain when there’s a dispute, because each of those state channels that you spun up needs to be disputed on chain, at a cost that is typically linear in the number of channels now just becoming more and more expensive, the more parallelism that you are enabling. And then because of that, as of today, Scalar is considered incomplete. We’re not really satisfied with the cost of disputes, and scalar does have the most efficient dispute system of any state channel protocol that exists. But even the best is not good enough for The Graph.” – Zac
One solution to this problem that has been in production is called Shell Proofs (announced at Graph Day). As the background work continues for Shell Proofs, the cryptography team at Semiotic AI have come up with a better approach than snarks.
H2S2 (Internal Name)
Holographic Homomorphic Signature Scheme is a cheaper verifier and prover and faster to market than shell proofs. The cost of engineering and maintaining the solution will be much lower, and there’s less cognitive overhead for the core developers or people involved in using this system. It will be resizable and have less infrastructure costs than shell proofs.
“The key insight is that with homomorphic signatures, messages are aggregated by taking their sum. And the piece of data that we want to extract from the roof is the total amount of query fees that are owed to the Indexer. So that’s the sum of the fees and all channels. If each channel is only a fee and a signature, then we can extract the total fees basically, for free with this scheme, because the aggregated message just happens to be the total number of fees. And that’s the data that we wanted to get out of it. And so, you know, if we, if we have that data, all we need to do to verify the proof is just verify a single signature. And we have our succinct proof like that’s it. No complicated polynomial math with snarks and whatever it is just very easy to understand what’s going on here. I am glossing over a lot of detail. But you know, the core idea is just that simple. And because it’s so simple, you know, we think that we can deliver this solution much faster than any snark-based snark powered solution.” - Zac
The Graph’s Billing UX updates (18:31)
The Graph’s Billing UX has been undergoing improvements over the past two-three months. The payment process can be complex with too many steps, so there are several ways this will be improved upon. Price predictability is also hard, with developers having a hard time budgeting. The new billing system will be in Subgraph Studio.
The process will include three steps, buy ETH and GRT, move them to polygon and then pay the bill on polygon. One of the ways to make this process is simpler is to make these three steps into a one click transaction/set of transactions. Once the billing contract is moved to Arbitrum, work will start on this. There is also work to get a FIAT onramp up and coming so users do not need to wait for longer periods of time to receive their GRT from exchanges. The third option is allowing those who hold stable coins to set up an automatic process that drips GRT into their billing balance once it hits a certain threshold. Overall, the same flow will be implemented, but with much less complexity.
There has been improvements made to the past payments history chart as well as email registration for other members of an organization that would need to receive billing updates.
Code4rena Contest (34:20)
The Graph hosted an audit contest through Code4rena in October with a $50,000 USDC prize pool. “Wardens”, or permissionless auditors, find bugs in code. The more unique the bug, the higher the reward. Overall, the contest found 79 valid reports, with there being no high severity issues. Many of the medium severity issues have been fixed and there will be a public report available soon.
GRT Arbitrum Bridge Updates (38:22)
Since the OpenZepellin audit of the brige and now the Code4rena test, the bridge has been deployed to Goerli test net and the team is running tests on that deployment. The GIPs required to start L2 deployment are currently up for a snapshot vote by The Graph Council.
GIP-0040: L2 Bridge and Protocol Deployment
Adding Support for Multi-Chain Indexing Rewards (45:16)
Included below are some older GIPs that are necessary for people to leave.
Will introduce a feature matrix.
Unlocks indexing Rewards for new chains.
Stay Tuned!
Join us next month for Core R&D call #18!
Keep up to date by joining discussions in the forum, following The Graph on Twitter or joining the Discord server.