DeFi on StarkNet#
- This event will discuss DeFi development on StarkNet.
- Representatives from Hashtag, ZKX, and Nostra will be introduced along with the protocols they represent.
- Hashtag is a ZK-native money market protocol that allows for 3x collateralization.
- ZKX is a trading platform that provides complex financial instruments for professional agents.
- Nostra is building a liquidity layer that includes Nostra money markets, undercollateralized stablecoins, and a Stablecoin DEX.
- Undercollateralized loans can be achieved on the blockchain, with an example of incentivizing users to deposit $100 by allowing them to partially invest $230 on the platform.
- Institutions that require KYC and credit score checks can also obtain support from Maple.
The Journey of StarkNet Release#
- The group discussed various technical and social challenges throughout the project lifecycle and how to overcome them.
- Fresh Pizza mentioned that while various innovations can be tried when there is a test network available, developers can only develop simple applications once on the mainnet.
- Julian discussed external barriers, including creating protocols based on rapid changes and visualizing technology through standards and documentation.
- Elias stated that the development in certain regions is not entirely predictable, and community workers also need to be involved in maintaining the project.
- Abdel summarized that developers need to make every possible effort to ensure the successful launch of the project, making it safe and efficient.
StarkNet Community Updates#
- Tom Brand feels excited and thrilled, as he feels that participating in StarkNet events is bigger than himself.
- Priorities set three months ago in Lisbon: improving performance (especially throughput), releasing Cairo 1.0 Alpha 2, and making progress towards seamless Regenesis.
- Cairo 1.0 Alpha 2 was released two weeks ago, and while it is not the most stable version, the development speed has been quite fast.
AirScript (Polygon Miden) Zero-Knowledge DSL Language#
• AirScript is a DSL used to describe AIR constraints.
• AIR constraints describe computations as algebraic or polynomial expressions.
• AIR constraints are used in the process of generating Stark proofs.
• AIR constraints can be categorized into boundary constraints, validity constraints, and transformation constraints.
• Taking the Fibonacci sequence as an example, boundary constraints specify the input and output, while transformation constraints describe the relationship between two columns in a row.
• AirScript is used to write the aforementioned AIR constraints.
• AirScript makes it convenient to write constraints and efficiently complete proof tasks.
Aztec Privacy Chain#
• Aztec specializes in using zero-knowledge proofs to achieve end-to-end encryption for blockchain transactions.
• This talk focuses on exploring how zero-knowledge proofs can be used to achieve privacy-preserving programmable blockchain architectures without using asymmetric encryption.
• The blockchain can be seen as a state machine that can receive transaction inputs and update the state according to predefined rules.
• However, with privacy in place, not only encryption is needed, but also considerations for ownership.
• To ensure that the network can be programmed by developers rather than cryptographers, support is needed for contracts to call other contracts without understanding abstract concepts.
• They are using Merkle trees to store encrypted states, but this also needs to consider protecting user information and preventing transaction monitoring.
• Therefore, they believe that combining zero-knowledge proofs with existing traditional smart contract programming semantics is the best choice.
Homomorphic Encryption Privacy Smart Contracts#
• Proposed by cryptographic technologist Pascal, the current prevalent fully public nature on the blockchain may have negative implications.
• Homomorphic Encryption is an encryption technique that allows for processing data under encryption without the need for decryption.
• At Zama, the technical team is leveraging this technique to mitigate the negative implications on the blockchain.
• By utilizing FH, blockchain data and states can be encrypted without being made public.
• This technology can be used to establish an encrypted marketplace for data processing, protecting the underlying data.
• Other novel applications such as identity recognition, authentication, and blind auctions can also be easily achieved with FH.
• Furthermore, FH can be used to create games like poker and e-auctions, which would not be possible without FH.
Lookup Protocols#
- Lookup protocols are techniques used to prove that a given value is within a certain range.
- Traditional lookup protocols require n+1 constraints, but recent research has reduced the cost to m+N constraints.
- If the number of lookups is equal to the size of the table, the cost of each lookup can be reduced to 1 constraint.
- The technology used to implement these lookups is called CachedQuotients.
- CachedQuotients is based on the KZG polynomial commitment scheme, which requires a setup phase where a sequence of group elements is generated based on a hidden random number X.
- With this, the technology can check if an element is in the table with minimal constraint cost given the table.
- This line of research is very interesting and may change the future of lookup protocols.
Sandstorm Cairo Prover for Consumer Devices#
• Sandstorm is a Cairo prover designed to run quickly on consumer devices.
• The Cairo Runner takes some Cairo source code, input information, and produces output while generating memory.bin and trace.bin files.
• During the approval process, the Cairo approver extracts values from these two files and elevates them to a massive table called an execution trace, which is necessary for generating Stark proofs.
• The memory.bin is also loaded into this table, and a set of constraints is defined to map the corresponding correct state transition.
• The taller the table stack, the more time it takes, but the smaller the proof.
• Sandstorm passes this table and a set of constraints to Stark Brewer to generate the proof.
• With the source code, the table and its constraints can be verified for the correct execution of the Cairo program.
