In recognition of these efforts, community members received Voyage NFTs distributed in five categories—Alpha, Beta, Gamma, Delta, and Omega —each reflecting different levels of engagement and contribution within the community.

Now the time has come to drop LXP to those Voyage NFT holders.

We have been listening to community suggestions regarding LXP on social media. Many of our longest-term and daily community members – the hardcore Linea maxis who have participated in LXP campaigns since Testnet Voyage and even more importantly have become vital community members active outside of the Voyage campaigns – have frequently shared valuable insights on how to manage our point system. We’ve taken that feedback into consideration in this case and are happy to announce we’re incorporating much of what we heard from you into our planned drop.

TL;DR -

After reviewing the holders of Testnet Voyage NFTs, it became clear that if we stacked the drop linearly and equally, the majority of Testnet Voyage holders would collect a small amount of LXP, while a tiny minority (less than 1% of holding addresses) would collect a large amount.

To prioritize the majority of our community members, we have conducted a stacked logarithmic distribution for the LXP to Voyage NFTs.

ND;WR (Need Details; Wanna Read) -

Analysis of Voyage NFT distribution reveals that while 99% of users hold between one and two NFTs per category, the top 1% own significantly more. This makes a linear scale approach unsuitable as it would disproportionately tilt to these few users.

However, a logarithmic scale approach ensures a balanced distribution, where amounts increase at a diminishing rate with more NFTs held.

Example distribution if we used a linear approach, using older data. We can see the majority of users would receive minimal LXP, which would be concentrated into the hands of large holders.

We feel therefore that the logarithmic approach is the optimal solution for distributing LXP due to its balanced structure. By incorporating a curve factor along with stacking, this approach is specifically designed to have a tipping point at the 99th percentile of NFT holders.

This ensures the vast majority of the community collects the lion’s share of LXP in this drop. Simultaneously, it maintains the promise of stackability for users with multiple NFTs.

Example distribution using the Logarithmic approach, using older data,  which showcases that the majority of the community receives most of the LXP distributed, while maintaining stackability for bigger holders.

LXP Collection Breakdown:

We plan to drop LXP to holders of the various Voyage NFTs using the following principles:

• Snapshot Date and Time: Collection based on the snapshot for the Testnet Voyage NFT taken October 23, 2024 at 12:40 UTC (block height: 11113454).

• Global Maximum: The maximum amount any NFT holder will receive is 7,317 LXP, which was the highest LXP amount held when crafting this allocation.

• The breakdown for each category is as follows for the first NFT you hold:

  • Alpha: 1715 LXP

  • Beta: 945 LXP

  • Gamma: 525 LXP

  • Delta: 245 LXP

  • Omega: 70 LXP

• Additional NFTs: If you hold more than one NFT in any category, the additional LXP you receive will not be the same as the first. Instead, the amount of LXP for additional NFTs will be calculated using a logarithmic formula, which means the LXP amount will stack but at a decreasing rate. This approach should ensure a fair LXP collection among all holders and is based around the following weights:

  • Alpha NFT: 49%

  • Beta NFT: 27%

  • Gamma NFT: 15%

  • Delta NFT: 7%

  • Omega NFT: 2%

• The curve factor: A curve factor of 0.3 is applied to the logarithmic function, ensuring the drop falls to the majority of holders.

For the math heads out there, the formula to determine the LXP of a user is the following:min_points + (max_points - min_points) * log(nft_balance) / log(max_nft_count) ** curve_factor

Where:

• min_points and max_points are the minimum for holding 1 of each NFT tier, meaning 5 NFTs total, (3,500) and maximum amount any NFT holder can receive (7,317) * weight.

• Nft_balance is the user balance of this NFT.

• Max_nft_count is the balance of the top holder of this NFT.

Examples:

A user holds 2 Alpha NFTs.They will get 1715 (first alpha NFT) + 1012 (second NFT) for a total of 2727 LXP.

Another user holds 1 Alpha NFT, 1 Beta NFT and 3 Gamma NFTs.

They will get 1715 (first alpha NFT) + 945 (first beta NFT) + 525 (first gamma NFT) + 342 (second and third gamma NFTs) for a total of 3527 LXP.

The drop of LXP for Testnet Voyage NFTs marks an important milestone in the Linea Voyage that started over a year ago. Thanks to the joint effort of users and developers, the Voyages have helped us build a robust ecosystem with innovative applications in DeFi, Gaming, and the creation of communities around meme projects within the Linea ecosystem.

November 11th: De.Fi World

Join us at De.Fi World 2024 in Bangkok, where experts, developers, and web3 community gather to explore the latest trends in decentralized finance. The event offers insightful keynotes, hands-on workshops, and valuable networking opportunities with leaders in the DeFi space. The Linea team will be on-site to connect with DeFi teams and enthusiasts, answer questions, and showcase how Linea is enabling innovation within the DeFi ecosystem.

Location: The Athenee Hotel, Bangkok

RSVP: https://lu.ma/g6osektm 

November 12th - 15th: Devcon 7

Devcon is the premier gathering of thousands of Ethereum developers and the wider web3 community. Linea will have a strong presence on the ground with Joseph Lubin, Consensys CEO, speaking on "Decentralizing Consensys to Catalyze a Network State in the Emerging Decentralized Web3 + AI Global Economy." You’ll also hear from other Linea team members, including Alexandre Belling, Youssef El Housni and others.

Don’t forget to also stop by the Linea booth to learn more about what we’ve built and where we’re going next.

Location: Queen Sirikit National Convention Center (QSNCC), Bangkok

RSVP: https://devcon.org/en/tickets

November 13th: L2Con

Look for a big announcement from Linea at L2Con, the largest event dedicated to Ethereum scaling, modularity, and infrastructure. With over 800 registered attendees, including developers, technical founders, researchers, and web3 business specialists, L2Con offers an unmatched opportunity to connect with leading minds in the space.

Expect multiple keynotes and news from Linea, including major updates and strategic partnerships that will further shape the Ethereum ecosystem.

Location: Waldorf Astoria, Bangkok

RSVP: https://lu.ma/l2conbangkok

November 13th: Builder Nights

Linea will co-host another installment of Builder Nights, a popular, builder-focused event bringing together web3 builders and leaders to foster innovation and co-creation in a non-commercial, inclusive environment. Attendees can engage in interactive activities like the Builder Rap Battle and Builder Chess while deepening their knowledge of decentralized technology.

Location: EmWonder @ Level 5 EmSphere

RSVP: https://lu.ma/80mtze59 

November 13th: AltLayer Rollup Day

Get ready for Rollup Day by AltLayer. This highly anticipated event will bring together Linea leaders with leading minds like Vitalik Buterin from the rollup, staking, and restaking spaces for engaging discussions, showcases, and insights. Attendees can expect exciting announcements from top innovators in the space.

Location: Carlton Hotel Bangkok Sukhumvit

RSVP: https://lu.ma/d5720aov

November 13th -14th: Thailand Web3 Conference (THW3)

THW3 is a founder-focused event, bringing together the global and SEA web3 communities. Supported by partners including Consensys, Maven11, and 1kx, the conference offers a platform for founders to network, share insights and explore trends across four key themes: abstraction, consumer apps, modularity and rollups. Linea thought leaders will be on hand and on stage.

Location: Samyan Mirtown, Bangkok

RSVP: https://lu.ma/thw3

November 15th: Linea X BitKub Meetup

Join the Linea team for a meetup with BitKub, Thailand’s largest CEX, to connect with the Thai web3 community, and explore opportunities in the SEA region. Attendees will hear from expert speakers on local market trends while networking with developers, key opinion leaders, and industry leaders.

This event offers valuable insights into building on Linea and provides opportunities to explore its ecosystem, including reward programs, campaigns, and trending dapps.

Location: 2525 FYI Center Building 2, 11th Floor, Rama IV Road, Khlong Toei Subdistrict, Khlong Toei District, Bangkok 10110

RSVP: https://lu.ma/7zgt2on0

November 15th - 17th: ETHGlobal Bangkok

ETHGlobal is back and Linea is bringing the heat with bounties for hackathon participants! With top DevRels on-site to mentor, support, and judge, you'll have everything you need to turn your wildest dapp ideas into reality on Linea’s zkEVM. Unleash your creativity, build big, and push the limits!

Location: Queen Sirikit National Convention Center (QSNCC), Bangkok

RSVP: https://ethglobal.com/events/bangkok/apply

See You at Devcon 7 in Bangkok, Builders

We look forward to connecting with you at Devcon 7 and engaging in conversations that will shape the future of Linea, Ethereum and blockchain technology.

Digital identity is crucial to how we live our onchain lives. At baseline, taking control of one’s digital identity means you have the authority, autonomy, and tools to manage your personal information, decide who can access it, and control how it is used across digital platforms. It enables you to protect your privacy, verify your identity, and manage how you interact in the digital world without relying on third-party control or centralized entities.

Taking things farther, in web3 you can prove your humanity and leverage your digital reputation for seamless onchain transactions and diverse interactions with dapps; and you can also foster personal connections by expressing your affiliation with onchain communities.

On Linea, we are building a human-centric identity system – composed of Verax, Proof of Humanity (PoH), and Linea Names – empowering you to take full control and optimize the management of your onchain identity in order to set the terms for your digital and financial life.

Read on to learn how.

Verax: Your Onchain Attestation Registry

Verax is an onchain attestation registry, which is a consolidated location onchain for storing pieces of data called attestations. The community-maintained initiative was originally built by teams including Consensys, Clique, Aspecta, Hapi, and Karma3 Labs. Currently, Verax is one of the largest attestation registries in web3 and a major provider of PoH attestations, with nearly 6 million attestations and over 1.5 million unique users.

Attestations are claims or verifiable credentials issued by one entity about another. A government could, for example, attest to a person’s citizenship or age, allowing them to access specific services that require proof of age or residency without revealing sensitive personal data. Employers and educational institutions could issue credentials such as degrees, certificates, and employment history to streamline job application or background check processes.

Within a web3 context specifically, attestations can enable a decentralized reputation system. For users, attestations accumulated over time from different sources can vouch for their behavior, trustworthiness, or skill levels. Dapps or P2P DeFi users could then rely on onchain reputation scores based on attestations to make lending, borrowing, or trading decisions—establishing trust without centralized intermediaries.

While this sort of data is traditionally minted onchain as soulbound tokens (SBTs) / non-transferable NFTs, attestations offer several advantages: they are easily discoverable, structured for easy consumption, and can expire, be revoked, replaced, or linked together.

For builders on Linea, Verax allows them to make one single integration, and subsequently consume and compose attestations from multiple sources.  Human verification attestations in particular are extremely valuable because they enable Linea dapps to confirm they are interacting with real-world humans—something much more interesting than interacting with pseudonymous wallet addresses.

Behavioral attestations could then be used by dapps to create and offer tailored experiences for certain users, including assigning unique rewards and discounts. For example a KYC’d user with a good lending reputation could access undercollaterialized lending offers from DeFi dapps on Linea.

Verax’s unique module architecture means it can be used for virtually any use case, so these examples are really just the beginning.

The first Verax use case to gain traction on Linea is Proof-of-Humanity.

Proof of Humanity: An Inclusive Approach to Verifying Digital Identity

We built Proof of Humanity to help protect communities against sybils and bots. Our PoH system allows users to prove they are human by selecting the verification approach that best suits their individual journeys in web3.

For users, attaining PoH verification provides a credential that can be used across the ecosystem, granting access to increasing benefits. For builders, Linea’s PoH system offers a free-to-use database of real users in the ecosystem, helping protect dapps against bots and sybils.

To obtain PoH, users navigate to the Proof of Humanity portal and select three PoH providers for attestations, choosing at least one from Group A and two from Group B. This flexible approach recognizes that not all methods suit everyone; some may avoid sharing sensitive biometrics, while others may reuse KYC from a CEX or rely on onchain analytics. By offering multiple options, Linea accommodates different preferences and journeys. Whether you are an OG or new to web3, we provide this choice because we recognize everyone’s experience is unique.

Linea Names: Human-Readable Wallet Addresses

Earlier this year, ENS domains launched on Linea, allowing users to begin switching their 42-character Ethereum wallet addresses to a human-readable domain. Now, everyone can obtain an ENS under the Linea ENS subdomain, such as username.linea.eth, by visiting the Linea ENS portal to register their username. The portal requires users to prove their humanity to prevent bot squatting and limits usernames to one per account. Additionally, Linea names are resolvable on L1 via an offchain resolver.

Linea Names represents a significant advancement in enabling users to claim their onchain identity, simplifying the process of registering ENS names and building user profiles. By providing a single canonical identifier for real users across the ecosystem, developers can create consistent and coherent user experiences, making navigating Linea feel natural and intuitive.

For users, registering a *.linea.eth name provides a human-readable identifier that is natively integrated on Linea. This identifier can be associated with your address to receive funds. Moreover, your Linea ENS name allows you to build a profile that can be used by dapps when you log in using your wallet. Once you have your *.linea.eth name, you can click on “Edit profile” and “Add more to profile” to include additional fields.

Expanded use cases of Linea Names have already begun to spring up, serving as identifiers for some of Linea’s strongest communities. Efrogs, an OG PFP collection on Linea, integrated with CCIP Read to automatically provide NFT holders with personalized ENS subdomains like 1.efrogs.eth. Project-specific subnames like this allow users to tie their membership to their web3 identity, serving as a status symbol and enhancing their sense of belonging within the community.

Looking Ahead

We stand at the frontier of this space, innovating to deliver more exceptional experiences and increased value to both Linea users and dapps.

On top of the foundation of the tools outlined above, we are working to expand utility so that each individual can do more with their digital identity. We aim to create even richer experiences for each person interacting onchain with verified humanity and credentials.

For a look at the full contest instructions, read this blog.

Get instant rewards by sharing your content as an NFT

Boost your Life on Linea contest votes

To receive a 20% bonus on the total number of votes your post will get from curators, you must mint your submission as an NFT drop on Linea on Phosphor.xyz and include the Phosphor link in your post’s caption on socials.

Receive a share of the mint fees

Additionally, for every one of your NFTs that are minted, you will automatically receive 45% of the mint fees paid by collectors (0.000111 ETH on Linea, around $0.30). So share the claim link widely to your network!

Compete in collecting the most NFTs to win Phosphor’s “Collector Prize Pool”

Your NFT and all the others created as part of the contest will appear on Phosphor Feed where collectors can discover and mint them. For each mint, we are setting aside the remaining 55% of the mint fee and we are going to redistribute this pool of funds to the most active collectors. If you want a chance to win a share of the reward pool, while also supporting your fellow Life on Linea contestants, mint as many drops as you can!

Step 1: Create content

Create content (see guidelines) representing your submission for either "Life on Linea" or "Build on Linea". If you intend on submitting it as an NFT on Phosphor, make sure the file size is less than 50MB.

Step 2: Sign up on Studio.Phosphor.xyz (desktop only)

Step 3: Select the “Your Life on Linea” Recipe

Step 4: Upload your content and details

1. Select your content, either “Life on Linea” or “Build on Linea”. Not sure? Read this

2. Give a title to your NFT or leave the default option

3. Upload your media file (JPG, PNG, GIF, MP4 formats are recommended). The file should be less than 50MB. If you upload a video, you will be asked to also upload a thumbnail image.

4. Important: add the wallet address where you would like to receive your creator payout, i.e. 45% of the mint fees paid by collectors of your NFT.

Step 5: Share your original content on social media, including Phosphor claim link\ Share as as post on X, Youtube, Instagram, Warpcast, TikTok or LinkedIn and include the Phosphor claim link in your social post’s caption

Step 6: Share on Discord\ Share the link to your post on the above social platform in the appropriate Discord channel:

• Life on Linea Channel for user-focused content and submission in the Life on Linea contest.

• Build on Linea Channel for developer-focused content and submission in the Build on Linea contest.

Note: To access the above Discord channels, you must first verify on guild.xyz/linea to be assigned the Life on Linea Ambassador and/or Build on Linea Ambassador Discord roles.

-

Follow Phosphor on X to stay updated on the leaderboard of collectors.

We can’t wait to see what you create!

The contests last a total of 5 weeks starting on October 21st. Each round runs weekly from Monday to the following Monday, starting at 9:00 EST. At the end of each week, participants in each contest can win a share of a 2.5 ETH prize pool, awarded based on the number of votes they receive from curators.

Remember to support your fellow Lineans by reacting and commenting on each other's posts on socials! Increased engagement will enhance your posts visibility and will be taken into account by curators when they select the winning submissions.

What To Create

This contest is about each of you and the ways you spend your days on Linea: whether investing in DeFi, making payments IRL with the MetaMask Card, using your Linea Name and building your onchain profile, or leaning on our developer resources to bring your projects to life.  You know Linea best, and we want to see what your life on Linea looks like.

Life on Linea

How do you spend your time on Linea?  Answer this question however you see fit. We’re sure you have better ideas than we do but here are some suggestions:

• Personal stories about your favorite things to do on Linea.

• Tutorials and tips for newcomers, shedding light on why you choose Linea and how it’s different from web2 and other L2s.

• Use of MetaMask Card and the last unique or meaningful thing you bought. (Add a link to the corresponding onchain transaction to your post).

• Wildest projects and art including use cases, artistic creations, video, gaming sessions, or innovative creative projects built on or mentioning Linea. For example, you can play with the Linea logo, animate it, etc. or showcase your new artistic creation on Phosphor.

• Fun and engaging content like memes or entertaining content related to Linea and its ecosystem.

Build on Linea

What are you building on Linea? This is your chance to share all the innovative worlds you’re creating, including:

• Showcases of dapps, tools, or projects developed on Linea.

• Technical walkthroughs including Insights, video tutorials, or detailed article of the building process on Linea. E.g How to build a Linea Dapp faster using AI

• Development updates featuring milestones reached by your dapp (daily active users, TVL …).

• Open-source contributions to Linea’s or Verax open-source repositories.

How to Compete

• Create content: Create content (see above) representing your submission for either "Life on Linea" or "Build on Linea".

• Share on X, Youtube, Instagram, Warpcast, TikTok or LinkedIn.

  • Share on Discord: Share the link to your post on the above social platform in the appropriate Discord channel

    • Life on Linea Channel for user-focused content and submission in the Life on Linea contest.

    • Build on Linea Channel for developer-focused content and submission in the Build on Linea contest.

  • Note: To access the above Discord channels, you must first verify on guild.xyz/linea to be assigned the Life on Linea Ambassador and/or Build on Linea Ambassador  Discord roles.

  • (Optional) Mint your submission as an NFT on Phosphor.xyz and share the link in your social post’s captions for bonus points.

Contest Guidelines

Remember these important guidelines:

✅ Include Linea! We’re here to learn about your life on Linea! Give your best Linea mention or shout-out to be considered.

✅ Accepted mediums: videos, animations, any type of art, text posts, threads, images, and basically anything engaging you can share on your chosen social platform.

✅ One submission per contest: Only one submission on Discord per participant per week for each contest. (That means you can have a total of two submissions if you participate in both contests). Focus on quality over quantity.

✅ Submission format: Your submission should include a caption or short text along with a link to your social media post. Example: Just uploaded a video on TikTok showing how I used the MetaMask Card to pay for my coffee ☕️. Watch it here: [Link to your TikTok video]

✅ Submit only once: Once your submission is shared on Discord, it will count as final and cannot be edited. Be sure to review your entry before submitting!

❌We don’t want to see: Violence and threats, hate speech, harassment and abuse, sensitive media, misinformation, or spam. This will disqualify you and prohibit you from participating in future rounds and other contests.

How Winners are Determined

Curators will analyze all submissions shared in the Discord channel and select the winning submissions at the end of each week.

Evaluations will be based on:

• Quality and creativity: Originality and appeal of your submission.

• Use case presentation: How well you showcase the possibilities of Linea.

• Community engagement: Engagement your post receives on socials.

• Phosphor Bonus: Mint your submission as an NFT drop on Linea on Phosphor.xyz and include the Phosphor link in your post’s caption on socials to receive a +20% bonus on the total number of votes your post will get from curators.

• Adherence to the contest guidelines.

Submissions with the most curator votes will share the 2.5 ETH prize pool each week, distributed proportionally based on votes received from curators.

Head over to guild.xyz/linea to access your Discord roles and submit your submission on Linea Discord. To join Linea Discord, visit https://linea.build/ and find the Discord icon.

The vision for Linea began seven years ago with deep research into zero-knowledge technology. Five years later, that research came to life with the launch of Linea’s testnet, followed by Linea’s Alpha mainnet, and the explosive growth of gaming, DeFi and NFT sectors.

In the 15 months since our mainnet launch, many of you have taken to dapps on Linea to buy, sell, swap, and stake; thousands have built non-stop to fulfill visions of new permissionless systems; others have found communities and grown their digital identity with memes and gaming; and as of recently, even killed zombies.

Over this time we’ve been listening and learning from your continuous feedback across our social and support channels; from the wide variety of requests and collaboration with partners and builders; from the explosive growth you spurred during the Voyage quests—in an effort to realize Linea’s mission: to empower the world to live onchain.

To live onchain, web3 natives and explorers alike need a home. This is what we are striving to build and offer the world: a home network.

Building and Growing the Home Network

Spearheaded by Ethereum ecosystem leaders and core developers, Linea’s leading ZK technology makes life on Ethereum effortless, starting with high-performance speed, cost, and scale. Beyond these L2 essentials, we've been laser-focused on delivering exceptional user experiences for all kinds of web3 interactions. We’ve put our best minds to work and leveraged our close connection to MetaMask and Consensys to develop game-changing innovations in web3 security, digital identity, payments, and community, making Linea feel like home.

For Builders: We’ve invested heavily in a rich set of tools, resources, and support, including key MetaMask Developer integrations, to help builders create, deploy, and grow more powerful, stickier dapps.

At the center of all this is you—the main driver that will direct the future of our ecosystem, the home network for the world. As Linea progresses toward decentralization, your experience and your voice will determine our path forward.

Over the next few weeks, you will discover what the starting point looks like. We will walk through how we’ve approached solutions to web3’s most pressing technical, cultural, and coordination challenges. We will outline where we are today and what’s coming in the near future. Beyond that, you’ll help decide how your home network evolves.

Welcome to your life on Linea!

Explore the ecosystem.

Your Security on Linea

There is no life onchain without security. Since day one, Linea has prioritized building the safest place from which to interact with web3, working with over 20 security partners on threat prevention, real-time monitoring, post-incident tracing, user protection, and trust and reputation systems.

Linea’s zkEVM is the most secure L2 solution, inheriting the security of Ethereum validators and outperforming Optimistic rollups by using mathematical validity proofs to constantly verify L2 activity on the mainnet. At the dapp, community, and protocol level, we’re building the most robust security system in web3, enabling you to transact safely onchain.

Your Identity on Linea

Linea is dedicated to building a human-centric network. The Linea Identity Stack—composed of Verax, Proof of Humanity, and Linea Names—empowers you to take full control and begin to unlock the value of your digital identity. Whether you’re collecting a new NFT to tie your identity to a project or leveraging on-chain attestations to interact seamlessly with dapps, Linea’s tools are in place to help you harness the value of your reputation.

Verax, an open-source, public registry for storing on-chain attestations is designed for enhanced discoverability and composability. Proof of Humanity, meanwhile, allows for the verification of unique human identities, preventing sybil attacks and ensuring that each identity is tied to a real person.

And as vocalized by Vitalik Buterin, standardization across chain-specific addresses is a next frontier for the ecosystem. The launch of Linea Names answers this call, translating blockchain addresses to human-readable labels, and establishing a new outlet for decentralized digital identities.

Your Money on Linea

Linea is home to a robust network of DeFi dapps, enabling you to buy, sell, swap, trade and stake tokens. But your money on Linea doesn’t stop there. With the recently introduced MetaMask Debit card, you can make everyday purchases with your crypto anywhere Visa and Mastercard are accepted, creating a seamless payment solution to off-ramp tokens and use them IRL.

This is a game changer, giving you more control over your funds while benefiting from Linea’s lower gas fees and fast transaction speeds, making it the ideal network for instant payments. It’s new life, both on and off chain, for your activity with DEXs like Lynex and Nile, lending protocols like Mendi and ZeroLend, optimization protocols like Clip Finance, and LRTs like Renzo and KelpDAO.

Your Projects on Linea

Builders are the pillars of Linea and we’re dedicated to empowering you to create more powerful, stickier dapps with the tools, resources, and support of the Linea Builder Stack. With 100% EVM bytecode compatibility, developing on Linea is identical to developing on Ethereum, allowing you to use current infrastructure, tooling, IDEs, and wallets to deploy bytecode, smart contracts, and apps as they are.

Our developer resources include hackathon bounties, our monthly developer cook-off, capital funding through the Linea Ecosystem Investment Alliance (LEIA), vibrant community forums, comprehensive documentation, 24/7 support in multiple languages, and white-glove technical enablement teams—Everything you need to build, deploy, and grow your dapp on Linea.

As the home network for the world, Linea is where web3 culture and community thrive. The collective input and creativity of the community are integral to Linea and web3 at large—we are all building, collaborating, and refining as we go.

Communities around memecoins and NFT projects are particularly active on Linea. This is why we put focus on empowering creator communities. Just last month, the first ever Linea Guild Games saw gaming platform Hyperplay host a zombie killing marathon on The Unfettered for the first four Linea Guilds. These Guilds were originally meme projects on Linea that were elevated to Guild status thanks to votes from the community. Guilds Efrogs, Linus ,FrogwithCat, and Foxy are pushing the culture forward and championing Linea by rallying like-minded believers in their mission.

Outside of Linea-hosted activities, community on Linea is always bubbling. Our network wouldn’t be the same without actors like The Linea Champions, a volunteer group who dedicate their onchain lives to helping other users. Whether it's user-to-user interaction, the growth of meme culture, or ideas that snowball into projects, community keeps Linea going.

Looking Ahead

In moving toward our mission to empower everyone to live onchain, Linea’s approach has been to take web3 user, builder, and community experience to higher levels. With innovations in security, digital identity, payments, and DeFi, as well as community nurturing and organization, we’ve aimed to lower barriers to entry, create the most secure environment, streamline everyday processes, and elevate the whole web3 experience.

And again, this is only the starting point. Watch this space over the following weeks as we dive into each of the innovation areas we are driving forward, and showcase some of the coolest elements of your home network.

In the meantime, bridge to Linea, your home network.

In this tutorial, we will build a simple voting dapp on linea, a zkEVM layer 2 blockchain solution. You will learn how to write, deploy and interact with a smart contract which is designed for decentralized voting process. By the end of this tutorial, you’ll have a solid understanding of the tools and features provided by linea for decentralized applications.

Understanding the Voting Dapp Architecture

The voting dapp has three main components: smart contracts, smart contracts integration and the frontend interface.

The smart contract is one of the main components of the application. This can handle critical functionalities such as registering candidates, allowing users to give their votes based on candidates index numbers, enforcing a one vote per wallet address policy and managing voting period by automatically closing the voting period after a specified duration. The smart contract makes sure that the voting process is secure, transparent and tamper-proof by recording all votes on the blockchain.

The frontend interface is the user-facing part of the application where users will be able to interact and cast their votes by inputting the candidate index number. It also can show the information about remaining time period. By offering a clear and responsive design, it encourages user participation and trust in the voting process.

To ensure smooth interaction with the Linea blockchain, we'll utilize the MetaMask SDK along with libraries like Wagmi and connect through Infura RPC providers. These tools allow the frontend to communicate with the blockchain, enabling users to sign transactions and interact with the smart contracts directly from their web browsers. This integration is crucial for maintaining the decentralized nature of the application while providing a user-friendly experience.

Setting Up the Environment

Before we start building our decentralized voting dapp, we'll set up the development environment using Consensys's Create Web3 Template CLI. This tool streamlines the process by generating a monorepo structure that includes both the frontend and backend components needed for our application.

Prerequisites

• Node.js and pnpm/any other package manager installed on your system.

• Basic familiarity with the command line.

Initializing the Project

Let's create a new project using the Create Web3 Template CLI by Consensys.

This command-line tool simplifies the setup process by providing all the necessary tools and integrations out of the box, including MetaMask SDK, Linea support, Infura integration, and a selection of templates to choose from.

1. Open your terminal and run the following command:

pnpm create @consensys/create-web3-template

2. You'll be prompted to specify a name for your project. We'll name it simple-voting-dapp:

? Please specify a name for your project: simple-voting-dapp

3. Next, select the framework for your frontend. We'll choose Next.js:

? Please select the framework you want to use:
  HardHat Vanilla
  React
❯ Next.js

Selected framework: Next.js

4. Choose the smart contract development environment. We'll go with HardHat:

? Would you like to use HardHat or Foundry?
❯ HardHat
  Foundry

Selected tooling: HardHat

5. Select your preferred package manager. We'll use pnpm:

? Please select the package manager you want to use:
  Yarn
  NPM
❯ pnpm

6. The CLI will generate the project based on your selections.

Project Structure

After the setup is complete, your project directory simple-voting-dapp will have the following structure:

simple-voting-dapp
├── packages
│   ├── site          # Frontend built with Next.js
│   └── blockchain    # Smart contracts using HardHat
├── pnpm-workspace.yaml
├── package.json

• packages/site: Contains the frontend code of the dApp, built with Next.js.

• packages/blockchain: Contains the smart contracts and related scripts using HardHat.

• pnpm-workspace.yaml: Defines the workspace configuration for the monorepo.

Installing Dependencies

Navigate into your project directory:

cd simple-voting-dapp

Install all the necessary dependencies:

This command will install all packages for both the frontend and backend components.

Understanding the Monorepo

A monorepo (monolithic repository) is a single repository that stores code for multiple projects or packages. In our case, it allows us to manage both the frontend and backend in a unified codebase, making development and maintenance more efficient.

Verifying the Setup

To ensure everything is set up correctly, let's run the development servers.

For the Frontend:

1. Navigate to the site directory:

cd packages/site

2. Start the Next.js development server:

Start the Next.js development server:

3. Open your browser and go to http://localhost:3000 to see the frontend running.

For the Backend:

1. Open a new terminal window.

2. Navigate to the blockchain directory:

   cd packages/blockchain
   

3.Compile the default smart contracts:

pnpm hardhat compile

This will compile the sample contracts included in the HardHat setup.

Write the Smart Contract

Let’s create a Voting.sol file and add the following code:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

/// @title A contract for a voting system
/// @author [Your Name]
/// @notice This contract allows for the creation and management of a voting system
contract Voting {
    /// @dev Struct to represent a candidate
    struct Candidate {
        string name;
        uint256 voteCount;
    }

    /// @notice Array to store all candidates
    Candidate[] public candidates;
    
    /// @notice Address of the contract owner
    address owner;
    
    /// @notice Mapping to track if an address has voted
    mapping(address => bool) public voters;

    /// @notice Timestamp when voting starts
    uint256 public votingStart;
    
    /// @notice Timestamp when voting ends
    uint256 public votingEnd;

    /// @notice Constructor to initialize the voting contract
    /// @param _candidateNames Array of candidate names
    /// @param _durationInMinutes Duration of the voting period in minutes
    constructor(string[] memory _candidateNames, uint256 _durationInMinutes) {
        for (uint256 i = 0; i < _candidateNames.length; i++) {
            candidates.push(Candidate({
                name: _candidateNames[i],
                voteCount: 0
            }));
        }
        owner = msg.sender;
        votingStart = block.timestamp;
        votingEnd = block.timestamp + (_durationInMinutes * 1 minutes);
    }

    /// @notice Modifier to restrict function access to the contract owner
    modifier onlyOwner {
        require(msg.sender == owner);
        _;
    }

    /// @notice Adds a new candidate to the election
    /// @param _name Name of the new candidate
    function addCandidate(string memory _name) public onlyOwner {
        candidates.push(Candidate({
                name: _name,
                voteCount: 0
        }));
    }

    /// @notice Allows a voter to cast their vote
    /// @param _candidateIndex Index of the candidate in the candidates array
    function vote(uint256 _candidateIndex) public {
        require(!voters[msg.sender], "You have already voted.");
        require(_candidateIndex < candidates.length, "Invalid candidate index.");

        candidates[_candidateIndex].voteCount++;
        voters[msg.sender] = true;
    }

    /// @notice Retrieves all candidates and their vote counts
    /// @return An array of Candidate structs
    function getAllVotesOfCandiates() public view returns (Candidate[] memory){
        return candidates;
    }

    /// @notice Checks if voting is currently active
    /// @return Boolean indicating if voting is active
    function getVotingStatus() public view returns (bool) {
        return (block.timestamp >= votingStart && block.timestamp < votingEnd);
    }

    /// @notice Calculates the remaining time in the voting period
    /// @return The remaining time in seconds
    function getRemainingTime() public view returns (uint256) {
        require(block.timestamp >= votingStart, "Voting has not started yet.");
        if (block.timestamp >= votingEnd) {
            return 0;
        }
        return votingEnd - block.timestamp;
    }
}

This contract provides a basic framework for a decentralized voting system where users can cast votes for candidates securely and transparently. It ensures that each user can vote only once by tracking voter addresses, and it maintains a record of all votes on the blockchain. The contract manages the voting period by specifying start and end times, enforces voting rules, and provides functions to retrieve voting results and status. Let’s explore the concept of the smart contract a bit more:

1. Contract Initialization and Candidate Setup

The Voting contract initializes with an array of candidate names provided during deployment.

Each candidate is represented by a Candidate struct containing a name and a voteCount.

The constructor sets the votingStart time to the current block timestamp.

It calculates the votingEnd time by adding the specified duration in minutes to the start time.

1. Access Control and Owner Functions

The contract stores the deployer's address as owner.

An onlyOwner modifier restricts certain functions to the contract owner.

The addCandidate function allows the owner to add new candidates after hardhat deployment.This ensures only authorized users can modify the list of candidates.

1. Voting Mechanism

The vote function lets users cast a vote by specifying a candidate's index.

A voters mapping tracks whether an address has already voted.

The function checks if the voter hasn't voted before and if the candidate index is valid.

Upon a valid vote, it increments the candidate's voteCount and marks the voter as having voted.

1. Utility Functions and Voting Status

getAllVotesOfCandidates returns all candidates and their current vote counts.

getVotingStatus returns true if voting is active based on the current time.

getRemainingTime calculates and returns how much time is left in the voting period.

These functions provide users with real-time information about the election.

This smart contract facilitates a decentralized voting system where users can vote for candidates securely, with all votes and results recorded on the blockchain.

Deploying the Smart Contract with Hardhat Ignition In the ignition folder, let's create a file named Voting.ts to deploy our contract. Add the following code:

import { buildModule } from "@nomicfoundation/hardhat-ignition/modules";

const VotingModule = buildModule("VotingModule", (m) => {
  // Default values
  const DEFAULT_CANDIDATES = ["Candidate 1", "Candidate 2", "Candidate 3"];
  const DEFAULT_DURATION_MINUTES = 60; // 1 hour

  // Get parameters with default values
  const candidateNames = m.getParameter("candidateNames", DEFAULT_CANDIDATES);
  const durationInMinutes = m.getParameter(
    "durationInMinutes",
    DEFAULT_DURATION_MINUTES
  );

  // Deploy the Voting contract
  const voting = m.contract("Voting", [
    candidateNames,
    durationInMinutes,
  ]);

  return { voting };
});

export default VotingModule;

In this deployment script, we utilize Hardhat Ignition to manage the deployment of our Voting contract. We set default candidates and a default voting duration but also allow these values to be customized through parameters if needed.

Compiling the Contract

Before deploying, compile the contract by running the following command in the blockchain directory:

npx hardhat compile

This will compile your Solidity code and prepare it for deployment.

Setting Up Environment Variables

Before deploying the smart contract, ensure that your .env file in the packages/blockchain directory is updated with the necessary environment variables:

This will compile your Solidity code and prepare it for deployment.

Setting Up Environment Variables Before deploying the smart contract, ensure that your .env file in the packages/blockchain directory is updated with the necessary environment variables:

# Infura API key for connecting to Ethereum networks INFURA_API_KEY=your_infura_api_key_here

# Private key of the account to be used for deployments and transactions
ACCOUNT_PRIVATE_KEY=your_account_private_key_here

• Replace your_infura_api_key_here with your actual Infura API key.

• Replace your_account_private_key_here with the private key of the Ethereum account you will use for deploying the contract.

Deploying the Smart Contract

To deploy the smart contract to the Linea testnet, run the following command from the blockchain directory:

npx hardhat ignition deploy ignition/modules/Voting.ts --network linea-testnet

This command tells Hardhat to use Ignition to deploy the Voting module to the linea-testnet network.

Alternatively, you can add a deployment script to your package.json to simplify the process. Add the following line under the "scripts" section:

"scripts": {
  "deploy:testnet": "npx hardhat ignition deploy ignition/modules/Voting.ts --network linea-testnet"
}

Now you can deploy the contract by simply running:

pnpm run deploy:testnet

After deployment, you'll receive the contract address. Keep this address safe, as we'll need it when integrating with the frontend.

Frontend Integration with Next.js and Shadcn UI

Setting Up the Frontend Project

Navigate to the site directory in your monorepo:

cd packages/site

Since we've already set up the frontend using the Create Web3 Template CLI, we can proceed to integrate our smart contract.

Configuring Wagmi and MetaMask SDK

Create a wagmi.config.ts file in the src directory with the following content:

import { http, createConfig } from "wagmi";
import { lineaSepolia } from "wagmi/chains";
import { metaMask } from "wagmi/connectors";

export const config = createConfig({
  chains: [lineaSepolia],
  connectors: [metaMask()],
  transports: {
    [lineaSepolia.id]: http(),
  },
});

This configuration sets up the connection to the Linea testnet and enables wallet integration using MetaMask.

Adding Contract Constants

In the src directory, create a file named constants.ts and add the following:

export const CONTRACT_ADDRESS = 'your_deployed_contract_address_here';

export const ABI = [
  // Paste the ABI of your Voting contract here
];

• Replace 'your_deployed_contract_address_here' with the actual contract address you obtained after deployment.

• For the ABI, you can find it in the artifacts folder generated by Hardhat after compilation.

  React and Hooks Usage

  "use client";
  
  import { useState } from "react";
  import { useAccount, useWalletClient } from "wagmi";
  import { ConnectButton } from "@consensys/connect-button";
  import { Button } from "@/components/ui/button";
  import { Input } from "@/components/ui/input";
  import { useReadContract, useWriteContract } from "wagmi";
  import { Card, CardContent } from "@/components/ui/card";
  import { contractAddress, contractAbi } from "../../constants";
  

  
  is Next.js client-side component uses React's useState for state management, Wagmi hooks (useAccount, useWalletClient, useReadContract, useWriteContract) for wallet and contract interactions, imports UI elements (Button, Input, Card, CardContent) from Shadcn UI, includes a ConnectButton for MetaMask connection, and brings in contractAddress and contractAbi from constants for contract use.

  Interface Definition

  is Next.js client-side component uses React's useState for state management, Wagmi hooks (useAccount, useWalletClient, useReadContract, useWriteContract) for wallet and contract interactions, imports UI elements (Button, Input, Card, CardContent) from Shadcn UI, includes a ConnectButton for MetaMask connection, and brings in contractAddress and contractAbi from constants for contract use.
  

  • Defines a TypeScript interface named Candidate.

  • Specifies the structure for candidate objects:

    • index: The candidate's index number.

    • name: The candidate's name.

    • voteCount: The number of votes the candidate has received.

      Component Initialization

      export default function Home() {
        const { address } = useAccount();
        const { data: walletClient } = useWalletClient();
        const [number, setNumber] = useState("");
      

      • Function Component: Defines the Home component as the default export.

      • Wallet Information:

        • address: The user's wallet address obtained from useAccount.

        • walletClient: The wallet client used for signing transactions.

      • State Management:

        • number: A state variable to store the candidate index input by the user for voting.

        • setNumber: Function to update the number state.

      Smart Contract Interaction - Reading Data

      const { writeContract } = useWriteContract();
      
      const { data: votingStatus } = useReadContract({
        address: contractAddress,
        abi: contractAbi,
        functionName: "getVotingStatus",
      }) as { data: boolean };
      
      const { data: canVote } = useReadContract({
        address: contractAddress,
        abi: contractAbi,
        functionName: "voters",
        args: [address],
      });
      
      const { data: remainingTime } = useReadContract({
        address: contractAddress,
        abi: contractAbi,
        functionName: "getRemainingTime",
      }) as { data: bigint };
      
      const { data: candidates } = useReadContract({
        address: contractAddress,
        abi: contractAbi,
        functionName: "getAllVotesOfCandiates",
      }) as { data: Candidate[] };
      

      • Writing to Contract:

        • writeContract is prepared for sending transactions to the smart contract.

      • Reading Contract Data:

        • votingStatus: Retrieves whether the voting is currently active.

        • canVote: Checks if the current user has already voted.

        • remainingTime: Gets the time remaining before the voting period ends.

        • candidates: Fetches the list of all candidates and their vote counts.

      • Type Assertions:

        • Uses TypeScript as syntax to specify the expected data type for better type safety.

      Early Return for Missing Data

      if (!candidates) return;
      

      • Checks if the candidates data is available.

      • If candidates is undefined or null, the component returns early to prevent rendering errors.

      Voting Functionality

      async function vote() {
        if (!walletClient || !address || number === "") {
          console.error("Missing required data for voting");
          return;
        }
        if (
          isNaN(Number(number)) ||
          Number(number) < 0 ||
          Number(number) >= candidates.length
        ) {
          console.error("Invalid candidate index");
          return;
        }
        if (!votingStatus) {
          console.error("Voting is not currently active");
          return;
        }
        try {
          console.log("Attempting to vote for candidate index:", number);
          writeContract({
            address: contractAddress,
            abi: contractAbi,
            functionName: "vote",
            args: [BigInt(number)],
            account: address,
          });
        } catch (error) {
          console.error("Detailed error in vote function:", error);
        }
      }
      

      • Input Validation:

        • Checks if the wallet client, user address, and candidate number are available.

        • Validates that the candidate index is a valid number within the range of available candidates.

        • Ensures that voting is currently active.

      • Voting Process:

        • Uses writeContract to call the vote function on the smart contract.

        • Passes the candidate index as a BigInt.

        • Uses the user's wallet address as the account.

      • Error Handling:

        • Wraps the contract interaction in a try-catch block to handle any errors that occur during the voting process.

        • Logs detailed error information to the console.

          UI Rendering

          return (
            <main className="container mx-auto p-4">
              <h1 className="text-2xl font-bold mb-4">
                Decentralized Voting Application
              </h1>
              <ConnectButton />
          
              {votingStatus ? (
                address ? (
                  <Card className="mt-4">
                    <CardContent>
                      <p>Connected Account: {address}</p>
                      <p>Remaining Time: {Number(remainingTime)} seconds</p>
                      {!canVote ? (
                        <div className="mt-4">
                          <Input
                            type="number"
                            placeholder="Enter Candidate Index"
                            value={number}
                            onChange={(e) => setNumber(e.target.value)}
                            className="mb-2"
                          />
                          <Button onClick={vote}>Vote</Button>
                        </div>
                      ) : (
                        <p>You have already voted</p>
                      )}
                      <div className="mt-4">
                        <h2 className="text-xl font-semibold mb-2">Candidates</h2>
                        <ul>
                          {candidates.map((candidate) => (
                            <li key={candidate.index}>
                              {candidates.indexOf(candidate)}: {candidate.name} -{" "}
                              {Number(candidate.voteCount)} votes
                            </li>
                          ))}
                        </ul>
                      </div>
                    </CardContent>
                  </Card>
                ) : (
                  <p>Please connect your wallet to vote</p>
                )
              ) : (
                <p>Voting has finished</p>
              )}
            </main>
          );
          

          
          The component features a styled main container with a header and a ConnectButton for MetaMask integration. It conditionally renders content based on votingStatus and user connection: if voting is active and the user is connected, it displays their address, remaining time, and voting options; if they've already voted, it notifies them and lists all candidates. If the user isn't connected, it prompts them to connect their wallet. When voting has ended, it shows "Voting has finished".

          Error Handling and Validation

          • Input Validation:

            • Ensures the candidate index entered is a valid number within the acceptable range.

          • Error Messages:

            • Uses console.error to log meaningful error messages for debugging purposes.

          • User Feedback:

            • Provides real-time feedback to the user based on their actions and the application's state.

          View full code here: https://github.com/meowyx/simple-voting-dapp

          Run the Development Server

          npm run dev
          

          Your Next.js application with Shadcn UI should now be running at http://localhost:3000.

          Now, you have a decentralized voting DAPP where users can vote for the candidates by using their index number. These votes are secure, transparent and recorded on Linea blockchain.

          In this tutorial, we built a simple decentralized voting application on Linea, while leveraging zkEVM technology for scalability, security, and cost efficiency. We covered everything from setting up the environment by using the CLI to writing and deploying smart contracts, and integrating the frontend with Next.js and Shadcn UI.

          As you continue to explore and expand upon this foundational knowledge, consider potential enhancements such as adding voter registration, implementing vote delegation, enhancing security measures, or improving the user interface for better accessibility. The possibilities for decentralized applications (dApps) are endless, and voting systems are just one of the many impactful use cases.

          Happy coding!

However, the applications don't stop there. The Linea ENS repository that was created to bring ENS to Linea has component libraries that can be applied in other contexts. The functionality of these associated components enables any L1 application to query L2 data using CCIP Read (ERC-3668), equipping developers for cross-chain retrieval and opening up up a range of use cases which we explored here.

As of today, Efrogs, an OG PFP collection and community on Linea, is putting this potential into action. Marking the first time a builder on Linea integrates with CCIP Read, the new feature for Efrogs automatically provides Efrogs NFT holders with personalized ENS subdomains, such as 1.efrogs.eth. This feature is achieved by deploying a custom resolver, which directly verifies NFT ownership on the Linea blockchain, in a seamless experience that is automated for Efrogs NFT holders.

“At Efrogs we always look forward to experimenting with innovative things ahead of everyone else, that's how we are able to provide value and incentives to our community members. We really think ENS is a great technology as it provides a variety of functionalities which web2 lacks,” says Shama, Founder and Chief Frog Officer at Efrogs.

The rollout includes two novel mechanisms: an ENS attached to its respective NFT, and the attachment of an NFT so that a holder’s PFP is also associated with their onchain subname. This means if a holder sells their NFT, the associated ENS subname is also transferred.

Subdomains will be issued to Efrogs holders for free. “By assigning subdomains to Efrogs holders we are basically naming their wallets, which is human-readable instead of the long hex address, so they can easily use their subdomain to send and receive payments and transfer NFTs,” explains Pran, Community Manager at Efrogs. Community members can begin to display their subdomain as their profile name on social platforms to show and have a sense of belonging to the culture.

These developments are part of a wider ecosystem push that aims to improve cross-chain transaction and standardization, with CCIP Read (ERC-3668) and ERC-7683 as the bedrock. “At Linea, we continue to explore and deliver innovative solutions that move the entire crypto industry forward. This feature provides builders another tool in the toolbox to deliver more meaningful user experiences to their communities, and I believe we're only scratching the surface on what these primitives will unlock for cross-chain interoperability,” says Declan Fox, product lead at Linea.

Impact on the Ecosystem

NFT projects are constantly looking for new innovation to create a stronger experience for their collectors and community. In delivering functionality for partner subnames, Linea is creating new primitive ways for these projects to provide better user experiences for their communities, with benefits for projects and users alike.

User benefits:

• Automated Subdomain Assignment: The solution is highly user-friendly as it automates subdomain assignment based on NFT ownership. e.g., if a user owns eFrog #1064, they automatically own 1064.efrogs.eth. NFT owners don't need to take any additional steps to acquire or manage their subdomains.

• Human-Readable Addresses: A more human-readable address allows for faster payments.

• Community and Identity Integration: Individuals often collect NFTs because they align with a project's values or want to join its unique community. With a project-specific subname, users can tie their membership to their web3 identity serving as a status symbol and enhancing a sense of belonging.

NFT project benefits:

• User Retention: Enhanced user experience incentivizes user retention.

• Simpler Distribution of Benefits: The new feature enables a more streamlined process to distribute benefits and perks to collection holders.

• Automated Subname Distribution: Users have no additional action points to claim their subname. Simple ownership of an Efrogs NFT grants them ownership of their NFT's token ID allocated domain.

Technical advantages:

• Simplified Architecture: By utilizing a custom L1 resolver, the solution avoids the complexity of multi-step resolution and provides a streamlined process for subdomain management.

• Direct Ownership Validation: The resolver directly queries the smart contract on Linea, ensuring that the subdomain always reflects the accurate and up-to-date ownership of eFrogs NFTs.

• Efficiency and Scalability: This approach reduces potential bottlenecks and ensures that the system can scale effectively as the number of queries or NFTs increases.

How the Custom L1 Resolver for Efrogs.eth Works

To make this new feature possible, Linea is setting up a custom ENS resolver on Layer 1 for the Efrogs.eth domain. This resolver is configured to directly query the ownership of Efrogs NFTs on the Linea blockchain. By doing so, we eliminate the need for a complex multi-step resolution process and ensure efficient, accurate subdomain management. This approach leverages the robustness of Ethereum mainnet (L1) while maintaining the integrity of ownership data hosted on the Linea L2 blockchain.

The process works as follows. When a user queries an ENS subdomain, such as 1.efrogs.eth, the process begins with the user sending a query to the ENS resolver on L1. The ENS resolver then interacts with the Linea blockchain to verify the ownership of the corresponding eFrog NFT. Linea fetches the current ownership data by interacting with the Efrogs NFT contract. This ownership data, which includes the wallet address of the current NFT owner, is returned from the Efrogs NFT contract to Linea, and subsequently from Linea to the ENS resolver on L1. Finally, the ENS resolver on L1 returns the wallet address of the NFT owner to the user, completing the query.

Builders can now create their own subnames on Linea using our CCIP Read integration – learn more here. 

“We’re thrilled that Linea has integrated Chainlink CCIP and are excited to see how they will leverage it to drive innovation and expand the multi-chain ecosystem. This integration represents a significant advancement for Linea, enabling developers to create novel cross-chain applications and push the blockchain industry forward.”—Thodoris Karakostas, Head of Blockchain Partnerships at Chainlink Labs

We selected CCIP as our interoperability solution due to Chainlink’s exceptional track record in security and reliability. CCIP is uniquely distinguished as the only interoperability solution with level-5 cross-chain security. Additionally, it is supported by the Risk Management Network, an independent network that rigorously monitors and verifies cross-chain activities for suspicious behavior. This added layer of security is crucial, given the history of substantial losses in user funds caused by unreliable cross-chain infrastructure.

Chainlink has built one of the largest ecosystems in the blockchain industry and is being established as the industry-standard blockchain connectivity standard within capital markets. Connecting Linea to the Chainlink community and ecosystem offers a multitude of growth opportunities that help Linea get closer to its goals and increase ecosystem adoption.

Linea is the Ethereum L2 empowering the world to live onchain. As an EVM-compatible platform, Linea enables users to deploy and develop applications at a fraction of the cost and with greater speed. The protocol is built around three core components: the Sequencer, Prover, and Bridge Relayer, which together optimize execution while maintaining Ethereum’s security through zk-rollups. By rolling up its transactions and providing zk-proofs to Ethereum, Linea enhances scalability without compromising on security.

In order to help enable cross-chain interoperability for our ecosystem, we needed access to a highly secure and reliable interoperability solution. After reviewing various solutions, we integrated Chainlink CCIP because it provides a multitude of important benefits and features, such as:

• Defense-in-depth security—CCIP’s consensus and interoperability layer is powered by Chainlink decentralized oracle networks, which have already secured tens of billions of dollars for smart contracts and enabled over $12 trillion in onchain transaction value. CCIP also features additional layers of protection and reliability via the Risk Management Network.

• Programmable Token Transfers—CCIP messages are programmable, meaning token transfers and arbitrary data transfers can be one atomic transaction. This enables instructions to be passed in the data payload regarding what to do with the tokens once they arrive at the destination chain.

• Secure Token Transfers—CCIP features a plug-and-play solution consisting of audited token pool contracts that handle the complexity of burning and minting or locking and unlocking tokens across chains. CCIP token transfers also have additional security features like rate limits, and enable ecosystem partners to easily build new capabilities around a supported token via a single CCIP interface.

• Arbitrary Messaging—CCIP enables the ability to send arbitrary data (encoded as bytes) to a receiving smart contract on a different blockchain. The developer is free to encode any data they wish to send. Typically, developers use arbitrary messaging to trigger an informed action on the receiving smart contract, such as rebalancing an index, minting a specific NFT, or calling an arbitrary function with the sent data as custom parameters. Developers can encode multiple instructions in a single message, enabling them to orchestrate complex, multi-step, multi-chain tasks.

• Extendable and future-proof—CCIP is built to support continuous updates, such as the integration of new blockchains, the introduction of advanced functionalities, and the addition of other defense-in-depth approaches to security. Thus,  integrating CCIP eliminates future switching costs should new cross-chain functionalities be required.

"We are excited to integrate industry-standard Chainlink CCIP, reinforcing our commitment to providing top-tier infrastructure for our ecosystem developers. This integration not only expands Linea’s cross-chain accessibility but also aligns us with Chainlink’s extensive ecosystem, accelerating our journey toward greater adoption and innovation in the blockchain industry."—Declan Fox, Head of Product, Linea

About Chainlink

Chainlink is the universal platform for pioneering the future of global markets onchain. Chainlink has enabled over $15 trillion in transaction value by providing financial institutions, startups, and developers worldwide with access to real-world data, offchain computation, and secure cross-chain interoperability across any blockchain. Chainlink powers verifiable applications and high-integrity markets for banking, DeFi, global trade, gaming, and other major sectors.

Learn more about Chainlink by visiting chain.link or reading the developer documentation at docs.chain.link.

About Linea

Linea is the home network for the world. One where users are in control, empowered to set the terms for their digital and financial lives. Our leading ZK technology makes Ethereum effortless, unlocking web2-like speed, cost, and scale. We offer rich builder support, including Metamask Developer integrations, to help builders create more powerful, stickier dapps. Spearheaded by Ethereum ecosystem leaders, and together with the Linea community—we drive significant advancements across onchain experience for everyone.

Aryze's E-Assets: The Foundation for Innovation

At the core of this partnership are Aryze E-Assets: eUSD, eEUR, eGBP, and recently added eGOLD. Fully backed by their real-world counterparts, these digital assets offer stability and trust for users and businesses. By tokenizing currencies and commodities, Aryze makes global assets accessible and usable within the digital economy. The $RYZE token, a native token to Aryze, helps unite liquidity across E-Assets, with a built-in revenue-sharing mechanism and an automated way to collect rewards and provide incentives to E-Asset users.

These E-Assets enable Aryze to rapidly create custom Stablecoin-as-a-Service solutions. Businesses can leverage this infrastructure to develop their own branded stablecoins, tailored to their specific needs and seamlessly integrated into their operations.

"Our live E-Assets are the building blocks that allow us to offer customized financial solutions quickly and effectively," explains Jodi Husain, CTO of Aryze.

Introducing reForge: Accelerating Asset Integration

Aryze's reForge is an innovative function embedded in their E-Assets, designed to offer convertibility and cross-chain support. reForge simplifies the launch of new tokens like eGOLD and enables seamless onchain conversions between all E-Assets.

Users can choose from a wide range of stablecoins and tokenized assets on any supported blockchain, enhancing flexibility and adaptability in today's dynamic financial landscape."reForge is the engine driving our innovation, allowing us to integrate new real-world assets swiftly and provide clients with the financial tools they need," shares Jack Nikogosian, CEO of Aryze.

Enhancing the Linea Ecosystem

Our partnership aims to make Aryze E-Assets operational within the Linea ecosystem, significantly increasing the utility and accessibility of digital assets for users. Integration with platforms like MetaMask and the MetaMask Debit Card will eventually enable users to manage and spend their Aryze E-Assets with ease.

"I like to think we're entering an exciting era where we're not just talking about web3 anymore — we're talking about web0, aka 'Real Life.' I've seen a lot of innovation in this space, but what we're seeing now across stables, L2 throughput, and easier wallet experiences means real transformation,” says Daniel Lynch, MetaMask.

By leveraging Aryze's solutions, businesses and individuals in the Linea network gain immediate access to stable, reliable digital currencies and assets. This integration supports a wide range of financial activities, from everyday transactions to complex corporate operations.

Empowering Businesses with Custom Financial Solutions

Empowering businesses with custom financial solutions, Aryze offers innovative Stablecoin-as-a-Service solutions that enable companies to create their own branded E-Assets for use in closed ecosystems, internal transactions, loyalty programs, and more. At the heart of this infrastructure is reForge, which plays a crucial role in unifying liquidity across E-Asset pairs, and the $RYZE token, which serves as a liquidity unifier, and incentive mechanism, and includes a built-in buyback and burn component.

By leveraging Aryze’s capabilities alongside Linea’s scalable blockchain infrastructure, businesses can easily deploy stablecoins and utilize $RYZE to access deep liquidity for their solutions. This partnership fosters innovation and competitive differentiation, advancing the adoption of stablecoins and tokenized real-world assets (RWAs) to build a more inclusive and dynamic financial ecosystem.

Commitment to Compliance and Security

Building trust is paramount. Aryze operates under strict Know Your Customer (KYC) and Anti-Money Laundering (AML) regulations, ensuring full compliance with international standards. Regular audits by firms like Grant Thornton affirm their commitment to transparency, while a robust legal framework safeguards transaction integrity. "Upholding the highest standards of compliance and security is vital to our mission of transforming the financial landscape," shares Morten Nielsen, CFO of Aryze.

Join Our Live AMA Session

Interested in how Aryze E-Assets and Stablecoin-as-a-Service can benefit you or your business? Join us on October 9th from 15:00 to 16:00 CEST on X Spaces for a live AMA session with Linea and Aryze. Engage directly with our teams and have your questions answered.

Fast-Track Stablecoin Offer for Linea dApps

To celebrate our integration with Linea, Aryze is offering two dApps within the Linea ecosystem a unique opportunity to fast-track the creation of their own stablecoin. This initiative is designed to empower innovative projects by leveraging Aryze's Stablecoin-as-a-Service (SaaS) solutions. Selected projects will receive dedicated support to build and launch their custom stablecoin, driving forward the future of digital finance.

Interested dApps can apply by visiting this **submission form **and sharing details about their initiative.

The whole experience was made possible by Linea, Unfettered Ecosystem, Hyperplay, and Game7. Guilds and individuals competed for a total of $100,000 in ETH (to be distributed later this week) from Linea, $SOULS tokens from Unfettered Ecosystem, and various meme tokens supplied by each of the four guilds.

By now, you’ve got a bag full of $FOXY, $CROAK, $LINUS, $WEF and $SOULS and if you're a degen you're likely figuring out how to get the best yield. We've got you covered! Here's some of Linea’s top defi dapps where you can exercise those tokens.

Lynex, Powered by Clip Finance

Users can earn attractive yields on $SOULS by providing liquidity through the SOULS/WETH gauge on Lynex. This gauge is expertly managed by Clip Finance, which simplifies the complexities of concentrated liquidity, allowing LPs to stake and earn passively with ease.

Additionally, Lynex supports $LINUS, $FOXY, and $CROAK. Each token has its own dedicated gauge, allowing users to provide liquidity and earn Lynex rewards while benefiting from veLYNX voter engagement. This creates a sustainable and dynamic flywheel between users, protocols, and liquidity providers, fostering long-term growth and collaboration.

Lynex - The native liquidity market on Linea

Lynex is the DeFi native Liquidity layer on Linea Blockchain. An advanced automated market maker (AMM) that seamlessly integrates the finest elements derived from Curve, Convex, and Velodrome

https://www.lynex.fi

Maestro

The original TG trading bot allows users to swap memes without leaving the comfort of Telegram. Its automatic buy and sell options make trading easier by letting your strategy do the work for you, maximizing your returns while effectively managing risks and unexpected costs. For future meme investments, be sure to take advantage of its snipe capability, which gives degens the ability to buy memes faster than on other markets.

Maestro

The leading Telegram sniping and trading Bot for DeFi

https://www.maestrobots.com

Zerolend

This lending and borrowing protocol has created unique meme markets exclusively on Linea, allowing users to deposit or borrow against their memes. They currently support $FOXY & $CROAK.

-

Stay tuned as Linea’s entertainment multiverse continues to grow and connect with your fellow guild members on X and Discord.

Yet, despite the inclusive vision and technological innovation, web3 is currently under attack in the US. Reckless regulation for crypto is currently threatening to unplug US builders from web3.

Now is the time to protect our industry and all the people and innovation behind it. Join us as we celebrate the people and the projects that make this technology worth fighting for. Today, we’re asking you to be part of the movement: Web3 for All.

Why protecting web3 matters

In April 2024, Consensys (Linea’s founding member) announced a lawsuit against the SEC seeking to end an inappropriate investigation into the Ethereum ecosystem and to get clarity that blockchain software developers like Consensys were not brokers under the U.S. securities laws.

The SEC elected to end its investigation into Ethereum, which was a huge win for the entire blockchain space, but proceeded with bringing an enforcement action in which it asserted that MetaMask was an unlicensed broker of unregistered securities.

This not only demonstrates a lack of understanding by the SEC about what a crypto wallet is and does, but also reveals a serious and systemic threat to blockchain software development in the U.S.  This action is an example of a policy choice to go after the technological innovation of web3 builders. And it is the web3 builders that are here for the technology, using the technology, that are most at risk from this misguided use of enforcement powers.

Since the onset of this litigation, the entire Consensys team has been fighting for our right to innovate, and not just for our company, but for the entire crypto community around the world.

Join us as as we stand up for web3 builders in the US and the world

Over the next several weeks we will be using Consensys and Linea channels to share stories of the builders behind web3 in the Builder Stories series. If you caught the first series, you already know they provide an indepth look at the people and innovative projects at the heart of web3.

This new season features a diverse set of builders – some veterans and some emerging – in an effort to show policymakers the people, talent, and technological innovation at stake if the SEC’s overreach evolves into regulation. Check out SheFi Founder,  Maggie Love’s story here.

Ready to join the conversation?

Be sure to use the hashtag #Web3forAll when sharing on social media. Learn more about Consensys’ lawsuit against the SEC here and check out Web3ForAll to learn how you can get involved today.

Linea’s Discord moderators work their magic engaging and answering all the questions, queries, and quandaries users may have. But they’re not the only ones that keep the Linea Discord running. Once we cut through all the requisite friendly (and sometimes not-so-friendly) banter on Linea, we get to one of the other factors that establish Linea as a community: users helping users. Over the years, an especially generous group of volunteers have emerged: The Linea Champions.

This group is made up of Lineans who have dedicated their online lives to helping other users, and offering support and guidance from how to navigate their favorite dapps to onchain events they are participating in.

“The Champions are a dedicated and awesome group of volunteers. Their support and engagement bring an incredible liveliness to our Discord, and many of them offer great ideas and recommendations on how they'd like to see the community improve,” says Kbee, part of Linea’s community support team.

Exactly what it takes to become a Champion is complex, but the common denominator is that these users are dedicated to maintaining a secure and supportive community. They operate with compassion and inclusivity, embracing challenging inquiries and genuinely enjoy helping others and solving problems.

Here, we give a rare behind the scenes spotlight interview with nine Champions.

Linea: Tell us something about yourself so we can (anonymously) know who you are!

Sugo: An interesting fact about me is I can’t stand drinking coffee, but I absolutely love the smell of it. It’s a strange contradiction I can’t explain, but it's true! :D

Oxsoltani: Well, I have many interesting facts in my life: I love the earth, the place that is the home of all of us and the earth that breathes and gives breath to us humans. Sometimes I get so lost in the beauty of the earth and I talk to myself, I think I'm crazy.

cb03c66: Through my onchain experience, I've learned a great deal! When I was younger, I launched my first project on the Fantom Blockchain (now sonic), which turned out to be a great success as I remember it generated a TVL of around $8m at its peak and this all started as a idea which I thought users were going to be interested in. Now, I've chosen to apply the knowledge and experience I've gained over the years to support projects I believe in and that I see as the future of crypto.

Rocket: Onchain, I have a genuine passion for the Web3 space and I am eager to contribute by educating others and helping secure it from bad actors in any way I can while learning alongside, with a deep passion in community management.

Dave: I'm just a guy with interest in tech, especially in the blockchain technology

Mirmalnir: I love helping people, it's like the purpose of my life.

Kacperrr0: I’m from a Polish village, and I’m a bit weird, but people can’t tell.

Linea: What first attracted you to life onchain?

Mirmalnir: To be honest, it was money.

Rocket: Anonymity, decentralization, security, transparency, and the amazing people ofc!

Kacperrr0: Freedom. I hate being restricted, I cannot be confined. Onchain, I can do whatever I want, whenever I want. I enjoy working for dozens of hours a day on things that drive me, but on other days, I find something else interesting, and my focus involuntarily shifts completely elsewhere.

Linea: How did you first come across Linea? Recall the moment the best you can!

Rocket: I came across Linea on X, during the private testnet registration, I was super excited to participate in the private testnet. It was zkEvm back then :)

Mr itachi: I first learned about linea on X when I read that there was a special campaign for testent phase on Galxe consisting of nine weeks. Then my passion took off. I love participating in new challenges. They were wonderful and unforgettable days. I learned a lot in the field of web3 thanks to Linea.

Cb03c66: As a volunteer, I love contributing my time to the community because I believe in decentralization and the power of a system where users support one another, creating an environment for learning and growth. I truly enjoy sharing my experience and knowledge with others, while also helping to troubleshoot any issues.

Anon I: Helping each other make[s] me happy.

Rocket: My passion for the community is driven by the power of shared growth and collaboration. I’m inspired by the potential of people coming together to solve problems, exchange ideas, and create meaningful impact.

Cb03c66: Honestly, what drives me the most is the satisfaction of helping users and seeing their issues resolved. I believe the key to onboarding users from web2 to web3 is creating a system that simplifies the learning process and makes getting assistance more accessible. Supporting users and solving problems keeps me motivated, knowing that we're making their experience smoother and more user-friendly.

Linea: What has been your favorite Discord moment?

oxsoltani: In my opinion, the best moment was when I got to know Linea, because before that I had been to the Discord accounts of many projects and I saw that the admins did not respond to the users or they responded very late, some of them were even frauds. They did not pay attention and ignored the users, even some admins behaved as if they were space shuttle engineers, but Linea has never done this.

Kacperrr0: This may sound weird, but I enjoy working in a buzzing, wild chat rather than in a slow and regular environment. I would say my favorite time was during DeFi Voyage, where a lot of users participated and encountered all kinds of issues. In such an environment, I can really turn it up to the max.

Cb03c66: I think my favorite was when I first became a champion and was recognized for my efforts. I remember right after I was selected, the server was really active, and a lot was happening. I jumped in to help, and it was just me and a few admins going all out in the chat. It felt like a race to see who could answer users the fastest, and also being free from the 10 minute slow mode meant I could assist a lot more haha! It was such an awesome feeling to be part of that and provide support—it was a blast!

Linea: As a Champion, what do you wish people would stop doing?

Dave: Spamming and engagement in scams or any related actions in the server.

Sugo: I really wish people would cut out the scam attempts and stop spreading misinformation. Scams not only put users at risk but also shake the trust within our community, while misinformation can stir up confusion and unnecessary chaos. It’s all about keeping our space safe and informed, so we can all stay engaged and have each other’s backs ♡

Linea: What have been some of your favorite projects on Linea or campaigns you really like?

Rocket: All the projects on Linea are amazing! Here are my top picks; Efrogs 🐸, Element market, Ether.fi, Mendi Finance, and Pheasant Network.

​​Mirmalnir: Linea Park was my favorite! It was where my Linea journey began.

Linea: What are you looking forward to for the future of Linea?

Anon I: Mass adoption using Linea.

Mr itachi: As I said I believe in decentralization and that is something that attracted me to Linea I am really looking forward to achieving full decentralization on Linea.

-

If you’re not part of the fam already, join Linea on Discord here!

Native yield trading allows users to split their yield-bearing tokens into two distinct components: Principal Tokens (PTs) and Yield Tokens (YTs). This approach provides flexibility and maximizes earning potential by enabling users to choose between fixed and variable yields.

Here’s how it works and what you need to know about Splice.

Splitting Interest-Bearing Tokens

Splice allows users to earn fixed yields or variable yields by splitting yield-bearing tokens into two:

• A Principal Token (PT) which can be redeemed for 1 unit worth of the accounting token at maturity.

  • i.e. 1 PT weETH can be redeemed for 1 ETH worth of weETH at maturity.

  • PTs can be bought at a discount to lock in fixed yields i.e. you pay 10 ETH for 12 PTs which matures in 1 year, earning you 2 ETH or 20% APY.

• A Yield Token (YT) which accumulates all the yield and points of the yield-bearing token.

  • i.e. 1 YT weETH accumulates the ETH staking yield and LRT points of 1 weETH until maturity.

  • YTs on Linea also receive LXP-L on top of the base yields.

  • YTs expire worthless at maturity as all yields and points have been distributed.

Splice Liquidity Providers

Liquidity providers on Splice earn extra trading fees on their tokens, earning high yield points without giving up point exposure. Liquidity providers hold a mix of PTs and YTs in a liquidity pool, continuing to earn the underlying yield while earning trading fees from those who buy or sell PTs and YTs. By using Splice, liquidity providers also earn extra LXP-L and LRT points due to partner boosts, as compared to just holding the asset.

By launching a yield trading hub on Linea, Splice enables Linea users to access a new asset class and primitive on the chain. Not only does Splice introduce more ways to earn yield, it opens up more potential integrations in yield derivatives vertical on Linea.

Visit app.splice.fi for more information.

Many Layer 2 (L2) blockchains, including Linea, rely on zero-knowledge (ZK) infrastructure. This infrastructure is highly complex ("moon math") and critical for the correct operation of these chains. In other words, even a single bug can result in catastrophic financial and reputational damage. Even though we have not seen a catastrophic incident in ZK-based L2s comparable to TheDAO hack in 2016, it requires great engineering discipline and rigorous testing to bulletproof such software components, given their inherent complexity.

Linea is well aware of this responsibility and highly prioritizes security. Currently, Linea works with over 20 security partners on threat prevention, real-time monitoring, post-incident tracing, user protection, and trust and reputation systems.

The Rio fuzzer is the latest result of an ongoing collaboration between Diligence, Linea, and TU Vienna with the goal of strengthening the security of the Linea ecosystem. Diligence is a collective of like-minded white hats, security researchers and engineers dedicated to safeguarding the Ethereum ecosystem. This team has already been instrumental in reviewing critical Linea components, with fuzzing acting as a second safety net beyond manual security reviews and audits.

Fuzzing, as an automated testing technique, is already widely used in the web2 industry (for instance, through large-scale continuous fuzzing efforts at Microsoft, Google, and Meta) to catch bugs before hackers can exploit them.

Over the last few years, Diligence has developed the Harvey fuzzer to catch bugs in smart contracts for any EVM-based chain. Harvey powers the Diligence Fuzzing service and is one of the most effective fuzzers on the market. 

Today, we're happy to provide a sneak peek at Rio, a new fuzzer the Dilligience team has been working on. Rio is designed to identify potential million-dollar bugs in Linea's ZK infrastructure. More specifically, it targets the gnark infrastructure, a library used by Linea as well as many other projects for designing, executing, proving, and verifying circuits.

Rio has been continuously fuzzing gnark’s codebase over the past year; it has already identified 10 issues that helped the Linea development team to improve gnark. For instance, Rio identified crashes and a specific circuit operation for which gnark tracked unnecessary constraints.

What about potential million-dollar bugs? Rio has already found several critical issues; for instance, in gnark’s AssertIsLessOrEqual primitive. More specifically, it found cases where gnark behaved differently for two logically equivalent but syntactically different circuits; it verified one of them for a given input but not the other one. In other words, gnark's constraint tracking was over- or under-constrained for one of the two circuits. Both types of issues are critical because they may affect the liveness/completeness (over-constrained) or safety/soundness (under-constrained) of the system.

“The issues that the Rio fuzzer is designed to catch are critical and can lead to catastrophic consequences. Linea currently uses additional safeguards to limit the impact of such issues; for instance, manual protocol upgrades in case of liveness issues and a centralized prover in case of safety issues. However, avoiding them in the first place is a top priority for Linea, and fuzzing is one of our security measures for catching them,” shares Gautam Botrel, gnark team lead.

Diligence continuously fuzzes gnark to catch such issues in every new commit and are creating new fuzzers for other ZK infrastructure in Linea.

Stay tuned for more technical details about Rio!

-

Acknowledgments: Diligence team (Pedro Santos, Tobias Vogel, and Valentin Wüstholz), gnark team (especially, Gautam Botrel and Ivo Kubjas), TU Vienna team (Maria Christakis, Christoph Hochrainer, and Anastasia Isychev).

In this tutorial, we will build a simple marketplace dapp on Linea, a Layer 2 zkEVM technology that offers a scalable and cost-efficient environment while maintaining the security of Ethereum.

This guide covers both front-end and smart contract development.

Understanding the Marketplace Dapp Architecture

We will be diving into the architecture of the marketplace dapp and its components.

The marketplace will incorporate smart contracts, frontend, and blockchain integration. The smart contract will include features such as listing items, buying items, and transferring ownership of an item.

The frontend serves as the user interface where buyers and sellers can interact with each other using the smart contract. While having a frontend and backend is important, the way the dapp interacts with the Linea blockchain is also crucial. We will be using the Metamask SDK along with Wagmi and Infura RPC providers.

Setting Up the Environment

We will start by initializing a monorepo. A monorepo (short for monolithic repository) is a software development strategy where code for multiple projects is stored in a single version control repository.

Let’s create a monorepo with pnpm:

Create a new directory for your monorepo and initialize it:

mkdir web3-marketplace-linea
cd web3-marketplace-linea
pnpm init

Create a pnpm-workspace.yaml file in the root to define your workspace structure:

packages:
  - 'packages/*'

Here’s what our workspace file structure will be like:

packages
├── site         # Frontend built with Next.js, Tailwind CSS, and Shadcn UI
└── blockchain   # Smart contracts using Hardhat

Let’s head over to the blockchain directory and initialize a hardhat project.

cd blockchain
npx hardhat init

You'll be presented with several options:

? What do you want to do? …
❯ Create a JavaScript project
  Create a TypeScript project
  Create a TypeScript project (with Viem)
  Create an empty hardhat.config.js
  Quit

For this tutorial we’ll be using TypeScript project. Hardhat will automatically install the necessary dependencies for you.

Project Structure

After initialization, you'll have a project structure that includes:

• contracts/: Solidity contracts

• ignition/: Ignition deployment modules

• test/: Test files

• hardhat.config.js: Hardhat configuration

Write the Smart Contract

Let’s start writing the smart contract:

// SPDX-License-Identifier: MIT
pragma solidity ^0.8.0;

/// @title Marketplace
/// @notice A simple marketplace contract for listing, purchasing, and transferring items
/// @dev This contract manages items, their ownership, and transactions
contract Marketplace {
    /// @notice Structure to represent an item in the marketplace
    /// @dev Each item has a unique ID, name, price, seller, owner, and sale status
    struct Item {
        uint id;
        string name;
        uint price;
        address payable seller;
        address owner;
        bool isSold;
    }

    /// @notice Total number of items listed in the marketplace
    uint public itemCount = 0;

    /// @notice Mapping of item IDs to Item structs
    mapping(uint => Item) public items;

    /// @notice Mapping of owner addresses to arrays of owned item IDs
    mapping(address => uint[]) public ownedItems;

    /// @notice Lists a new item in the marketplace
    /// @param _name The name of the item
    /// @param _price The price of the item in wei
    /// @dev Increments itemCount and adds the new item to the items mapping
    function listItem(string memory _name, uint _price) public {
        require(_price > 0, "Price must be greater than zero");

        itemCount++;
        items[itemCount] = Item(itemCount, _name, _price, payable(msg.sender), msg.sender, false);
        ownedItems[msg.sender].push(itemCount);
    }

    /// @notice Allows a user to purchase an item
    /// @param _id The ID of the item to purchase
    /// @dev Transfers the item's price to the seller and updates ownership
    function purchaseItem(uint _id) public payable {
        Item storage item = items[_id];
        require(_id > 0 && _id <= itemCount, "Item does not exist");
        require(msg.value == item.price, "Incorrect price");
        require(!item.isSold, "Item already sold");
        require(msg.sender != item.seller, "Seller cannot buy their own item");

        item.isSold = true;
        item.seller.transfer(msg.value);

        // Transfer ownership
        _transferOwnership(_id, item.seller, msg.sender);
    }

    /// @notice Internal function to transfer ownership of an item
    /// @param _id The ID of the item
    /// @param _from The current owner's address
    /// @param _to The new owner's address
    /// @dev Updates the item's owner and adjusts the ownedItems mappings
    function _transferOwnership(uint _id, address _from, address _to) internal {
        Item storage item = items[_id];
        item.owner = _to;

        // Remove item from the previous owner's list
        uint[] storage fromItems = ownedItems[_from];
        for (uint i = 0; i < fromItems.length; i++) {
            if (fromItems[i] == _id) {
                fromItems[i] = fromItems[fromItems.length - 1];
                fromItems.pop();
                break;
            }
        }

        // Add item to the new owner's list
        ownedItems[_to].push(_id);
    }

    /// @notice Allows the owner to transfer an item to another address
    /// @param _id The ID of the item to transfer
    /// @param _to The address of the recipient
    /// @dev Calls the internal _transferOwnership function
    function transferItem(uint _id, address _to) public {
        Item storage item = items[_id];
        require(_id > 0 && _id <= itemCount, "Item does not exist");
        require(msg.sender == item.owner, "You do not own this item");

        _transferOwnership(_id, msg.sender, _to);
    }

    /// @notice Retrieves all item IDs owned by a specific address
    /// @param _owner The address of the owner
    /// @return An array of item IDs owned by the specified address
    function getItemsByOwner(address _owner) public view returns (uint[] memory) {
        return ownedItems[_owner];
    }
}

This contract provides a basic framework for a decentralized marketplace where users can list items for sale, purchase items, and transfer ownership of items. It maintains a record of item ownership and ensures that only valid transactions can occur. Let’s explore the concept of the smart contract a bit more:

• Seller:

  • Listing an Item:

    • Sellers can list items for sale by calling the listItem function.

    • This function requires a name and price for the item.

    • The item is added to the marketplace with a unique ID, and the seller is recorded as the owner.

• Buyer:

  • Purchasing an Item:

  • Buyers can purchase items using the purchaseItem function.

  • The function checks that the item exists, the price is correct, and that the item is not already sold.

  • The payment is transferred to the seller, and ownership of the item is updated.

• Transferring Ownership:

  • Ownership Transfer:

    • The _transferOwnership function handles the internal logic for transferring item ownership.

    • It updates the owner in the items mapping and adjusts the ownedItems lists for both the previous and new owners.

  • Manual Transfer:

    • The transferItem function allows current owners to transfer their items to another address.

    • It ensures the sender is the current owner before calling the _transferOwnership function.

• Retrieving Owned Items:

  • Ownership Transfer:

    • The getItemsByOwner function returns a list of item IDs owned by a specific address.

This smart contract facilitates a decentralized marketplace where items can be listed, purchased, and transferred securely, with all transactions and ownership changes recorded on the blockchain.

On the ignition folder let’s create Marketplace.ts to deploy our contract and add the following code:

import { buildModule } from "@nomicfoundation/hardhat-ignition/modules";

const MarketplaceModule = buildModule("MarketplaceModule", (m) => {
  // Deploy the Marketplace contract
  const marketplace = m.contract("Marketplace");

  // Return the deployed contract instance
  return { marketplace };
});

export default MarketplaceModule;

To compile the contract run the following command:

.env Variables

Before deploying the smart contract, make sure to update the .env file in the packages/blockchain directory with the following values:

# Infura API key for connecting to Ethereum networks
INFURA_API_KEY=your_infura_api_key_here

# Private key of the account to be used for deployments and transactions
ACCOUNT_PRIVATE_KEY=your_account_private_key_here

Deploy the Smart Contract

To deploy the smart contract to the Linea testnet, run the following command:

npx hardhat ignition deploy ignition/modules/Marketplace.ts --network linea-testnet

This will deploy the marketplace smart contract on Linea Sepolia. You can always write a script to deploy quicker by writing small commands like this on package.json file:

"deploy:testnet": "npx hardhat ignition deploy ignition/modules/Marketplace.ts --network linea-testnet"

After the deployment we’ll get the contract address. Let’s keep that. We will need it soon while integrating with the frontend.

Frontend: Next.js with Shadcn UI

Create and Navigate to the Project Directory

mkdir site
cd site

When prompted, choose the following options:

• TypeScript: Yes

• ESLint: Yes

• Tailwind CSS: Yes

• src/ directory: No (or Yes, if you prefer)

• App Router: Yes

• Import alias: Yes (default @/*)

Install Shadcn UI CLI

npx shadcn-ui@latest init

Install the necessary UI components like button, card and input as needed.

We will create a wagmi.config.ts and add the following code:

import { http, createConfig } from "wagmi";
import { lineaSepolia } from "wagmi/chains";
import { metaMask } from "wagmi/connectors";

export const config = createConfig({
  chains: [lineaSepolia],
  connectors: [metaMask()],
  transports: {
    [lineaSepolia.id]: http(),
  },
});

We will be using wagmi and metamask sdk to connect our wallet and make transactions. Now all that is left is to create a ConnectWallet.tsx UI component.

In the site/src directory let’s create a file called constants.ts and add the following:

export const CONTRACT_ADDRESS = //paste deployed contract here
export const ABI = 
  // Paste the ABI here

Remember the deployed contract that we’ve saved earlier, we’ll add it here. Head over to blockchain/ignition module and find the artifacts folder to find the ABI.

Let’s break down the code app.tsx and explain its key aspects in more detail:

React and Hooks Usage

import { useState, useEffect } from "react";
import { useAccount, useWalletClient } from "wagmi";

• The component uses React's useState for local state management and useEffect for side effects.

• It also uses custom hooks from wagmi (useAccount and useWalletClient) for blockchain wallet integration.

State Management

const [items, setItems] = useState<any[]>([]);
const [ownedItems, setOwnedItems] = useState<any[]>([]);
const [newItemName, setNewItemName] = useState("");
const [newItemPrice, setNewItemPrice] = useState("");

• Multiple state variables are defined to manage the component's data.

• items and ownedItems are arrays to store marketplace items.

• newItemName and newItemPrice are for form inputs when listing a new item.

useEffect for Data Loading

useEffect(() => {
  loadItems();
  loadOwnedItems();
}, []);

• This effect runs once when the component mounts.

• It calls loadItems() and loadOwnedItems() to populate the state with data from the blockchain.

Smart Contract Interaction

const loadItems = async () => {
  try {
    const itemCount = await client.readContract({
      address: CONTRACT_ADDRESS,
      abi: ABI_STRING_ARRAY,
      functionName: "itemCount",
    });
    // ... (fetching individual items)
  } catch (error) {
    console.error("Error loading items:", error);
  }
};

• This function reads data from the smart contract using client.readContract.

• It first gets the total item count, then fetches details for each item.

Writing to the Blockchain

const listItem = async () => {
  try {
    if (!walletClient) return;
    const { request } = await client.simulateContract({
      // ... contract call details
    });
    await walletClient.writeContract(request);
    loadItems();
  } catch (error) {
    console.error("Error listing item:", error);
  }
};

• This function writes data to the blockchain (listing a new item).

• It first simulates the contract call, then uses walletClient.writeContract to execute the transaction.

UI Components and Styling

<Card className="p-4 sm:p-6" key={index}>
  <li key={item.id} className=" p-4">
    <p><strong>Name:</strong> {item.name}</p>
    {/* ... other item details */}
    <Button
      variant="outline"
      onClick={() => purchaseItem(item.id, item.price)}
      className="border-2 border-green-500 text-green-500 hover:bg-green-500 hover:text-white py-2 px-4 rounded  duration-200 hover:shadow-xl"
    >
      Purchase
    </Button>
  </li>
</Card>

• The component uses custom UI components like Card and Button.

• Tailwind CSS classes are used for styling (className props).

• Conditional rendering is used to show/hide the purchase button based on item status and ownership.

Form Handling

<Input
  type="text"
  placeholder="Item Name"
  value={newItemName}
  onChange={(e) => setNewItemName(e.target.value)}
  className="border p-2 flex-1"
/>

• Controlled inputs are used for the form fields.

• The value and onChange props connect the input to the component's state.

Error Handling

try {
  // ... contract interaction
} catch (error) {
  console.error("Error loading items:", error);
}

• Try-catch blocks are used throughout the code to handle potential errors in asynchronous operations, especially during blockchain interactions.

The app.tsx can become quite large so we can also refactor the code insite/src/app/components/ directory.

/components
  - ListItem.tsx
  - AvailableItems.tsx
  - OwnedItems.tsx
/hooks
  - useItems.ts

View the full code here.

Also view the refactored code here.

This component demonstrates advanced React patterns, integration with blockchain technology, and modern UI practices. It showcases how to build a decentralized application frontend that interacts with a smart contract while providing a user-friendly interface.

Run the Development Server

npm run dev

Your Next.js application with Shadcn UI should now be running at http://localhost:3000.

Now we should be able to list and item, buy, and transfer ownership. See the built live website here.

In this guide, we built a simple decentralized marketplace dapp on Linea, leveraging zkEVM technology for scalability and cost efficiency. We covered everything from setting up the environment to writing and deploying smart contracts, and integrating the frontend with Next.js and ShadcnUI.

As we continue to explore and expand on this foundational knowledge, consider the potential for further enhancements, such as integrating additional features or optimizing the user experience, bidding on items, and auctions.

In this post, we will explore the complex components that make up Linea Prover, including arithmetization, Arcane, polynomial-IOPs, lattices, hash functions, error-correcting codes, and Vortex. Together, these elements create a secure, scalable, and efficient system that is revolutionizing the blockchain landscape.

The Journey Begins: Arithmetization

Our journey begins with arithmetization, a method that transforms complex computer programs into simple mathematical equations. Think of a virtual machine running a program and leaving a sequence of operations like footprints on a path. Arithmetization captures these sequences and converts them into mathematical problems, allowing the creation of proofs that can be confirmed without analyzing the entire computation.

Consider a virtual machine tasked with computing x 2^256. This seemingly daunting task is broken down into manageable steps: starting with x, squaring it to get x2, then x4, and so on, until reaching x 2^256. Each step is represented by an equation, ensuring the computation is executed correctly. This process is akin to following each step in a recipe precisely to achieve the desired outcome.

Arcane and Polynomial-IOPs: Simplifying the Complex

The process of arithmetization creates a statement with several equations and a potential solution, known as a trace. A trace is considered valid if it satisfies all the equations. Put simply, a valid trace shows that the EVM (Ethereum Virtual Machine) executed correctly.

Proving the execution of the EVM is the same as proving that "the prover knows a valid trace" for a specific block and state transition.

The proof system is built in several stages.

The first stage, called Arcane, creates a proof system that is only secure in an ideal, unrealistic setting where both the prover and the verifier communicate through a trusted third party known as the polynomial oracle.

You can think of the polynomial oracle as a trusted friend of both the prover and verifier. However, the oracle can only answer specific types of questions. The prover sends a polynomial to the oracle, who confirms to the verifier that they received it and provides the verifier with evaluations of the polynomial at chosen points. But the oracle doesn’t directly verify the arithmetization equations.

Arcane explains how to use the oracle’s limited power to convince the verifier that the equations hold true. It uses clever mathematical techniques involving polynomials to do this.

In the following stages, the oracle will be replaced with cryptographic protocols, such as polynomial commitments, to make the proof.

Lattices and Hash Functions: The Guardians of Security

Lattice cryptography is a foundational area of post-quantum cryptography, with roots dating back to the 1990s and continued advancements, including recent standardizations in the NIST PQC competition. In Linea, lattices play a crucial role through a hash function built on the Short Integer Solution (SIS) problem. This SIS-based hash function is a core component of the polynomial commitment scheme, Vortex, which powers Linea's prover.

This approach has several key advantages:

1. It is highly optimized for recursion, making it an efficient choice in proof systems.

2. It is extremely fast, achieving speeds up to 2.7GB/sec.

3. It leverages decades of research into the security of SIS, ensuring strong cryptographic guarantees.

4. It is post-quantum secure, making it future-proof against quantum attacks.

Lattice-based cryptography, therefore, is not only a strong solution for Linea's cryptographic needs but also a key element in ensuring the security and efficiency of the Vortex polynomial commitment. As the dimensions of a lattice increase, finding the shortest vector becomes exponentially harder, making lattice-based cryptography critical against attacks.

Lattice-based hashing is significant due to its speed compared to traditional elliptic curve cryptography, as well as its optimization for recursion. Additionally, it has the potential to resist quantum computing attacks, making it a future-proof option. Hash functions enhance security by transforming data into a consistent and irreversible form. When paired with lattices, they establish a solid cryptographic foundation that is both fast to compute and resistant to threats.

Error-Correcting Codes: Keeping Data Intact

Error-correcting codes are crucial for ensuring data accuracy, particularly during transmission. Reed-Solomon codes, a robust error-correction technique, encode data as a polynomial and utilize specific points on this polynomial to encode the message. Even if some points are corrupted, the original message can be reconstructed by recovering the polynomial, similar to piecing together a puzzle with some missing pieces.

Vortex: Finalizing the Proof

Vortex is Linea’s in-house polynomial commitment scheme and forms the final part of the proof system. The purpose of a polynomial commitment scheme is to replace the polynomial oracle used earlier in the proof system. Essentially, it allows a prover to commit to a polynomial (like a secure hash) in such a way that the prover cannot alter it afterward. The verifier can then request evaluations of this committed polynomial at specific points to ensure the integrity of the proof.

In Linea, Vortex is built on error-correcting codes and lattice-based hash functions. While Vortex greatly speeds up the verification process compared to traditional methods, it doesn’t yet achieve fully succinct verifier time. Verifying Vortex proofs on-chain, especially on blockchains like Ethereum, remains resource-intensive.

To overcome this challenge, Linea employs a technique called "self-recursion." In this method, the prover generates a new proof that the verifier has successfully verified a previous Vortex proof. Each recursive proof is smaller and faster to verify than the original, and the process is repeated until further compression is no longer possible.

Finally, the prover wraps the compressed Vortex proof in a Plonk proof for an additional layer of optimization. This final compression step is key to ensuring that the proof is both small and quick to verify, making it highly efficient for use on-chain, particularly on Ethereum’s main network.

The Future of Secure Transactions

The Linea Prover demonstrates the power of cryptography in ensuring secure, efficient, and private blockchain transactions. It achieves this by converting computational operations into mathematical equations, simplifying them with Arcane, verifying them with Polynomial-IOPs, securing them with lattices and hash functions, protecting them with error-correcting codes, and optimizing them with Vortex. The Linea Prover provides a strong solution for privacy-preserving verification on blockchain platforms. As blockchain technology progresses, innovations like the Linea Prover pave the way for more secure and private decentralized systems. This ensures that the concept of zero-knowledge proofs continues to revolutionize the digital landscape.

Stay tuned and subscribe to Linea on Mirror for more in-depth coverage.

The nine-day challenge kicks off on September 18. Players will choose to join one of the four guilds and mint a companion to your Game7 avatar. This fox, penguin, or frog will serve as an entry ticket to the game. Players and their guild play the Unfettered Awakening, competing for a prize pool of $100,000 in ETH from Linea, plus $150k in additional prizes provided by LGG’s gaming and meme partners. Individuals will receive daily rewards from this prize pool and the winning guild will receive a pot of $ETH to be spent and shared as a community.

LGG is not an LXP event. Yes, you read that right. We heard you and listened. It's just gaming for fun, you know, like the old days. Meet new friends, play online, and win together!

Here’s everything you need to know about the Linea Guild Games.

Meet Our Partners

The Linea Guild games are made possible through collaboration from top gaming builders on Linea.

The Unfettered

The Unfettered Awakening is a zombie killing game live on HyperPlay and deployed exclusively on Linea. The Unfettered was chosen as the first LGG partner because of its Linea-only gamefi ecosystem and the positive feedback we received from the Linea community around their gameplay. The Unfettered has an exciting roadmap of upcoming games exclusively on Linea, and LGG is just an introduction.

Hyperplay

The web3 native game launcher and marketplace will create our gaming repository for the Linea Guild Games and launch infrastructure. HyperPlay already features over 90 web3 games and features current MetaMask standards. HypePlay’s proven infrastructure and standards, strong user base and trusted name make them an ideal partner of the Games. Hyperplay will be launching its in-browser capabilities, giving gamers the best experience during LGG!

Game7 Summon Platform

Game7 operates a gaming-native, questing platform, and LGG will be featured on its new Lootdrop system. Users will mint an avatar, then mint a companion based on their guild selection. These furry friends will remain with you beyond Linea Guild Games so you can continue to enjoy them after the tournament!

Choose Your Fighter

For the Linea Guild Games, you can choose to join one of four NFT/meme communities on Linea. Choose your Guild wisely! You will be playing alongside each other to win the grand prize together.

• Efrogs: The cute, sunshine-on-my shoulder guild! Croak believes in living life on his own cute terms, unbound by conventions. He always wears a smile and spreads good vibes wherever he goes. Croak embraces the present moment, appreciating the simple pleasures in life, like a perfect wave or a sunset. If you are up for a good time, some surfing before sunrise, and embracing the cute energies of life—Croak is your guild.

• Foxy: The bold, risk taking adventurous guild. Foxy is a rule breaker, innovator and adventurous maverick. He sees the potential in everything and everyone and is always willing to help, in style. Just like Crypto did for the world, Foxy is here to blaze a new path forward for memes. Beat the odds and look good while doing it. Win as a community, a fox is only as strong as its den. If you’re a trailblazer, this guild is for you.

• FrogwifCat: The weird, slightly crazy, counterculture guild. $WEF is meme culture all the way. Your parents won’t understand this and probably shake their heads. This is about wack, out-there fun, weird humor. From spongebob, over Lord of the Rings to the Ninja Turtles, no cliche is too big for this guild. If you love new age meme stuff, have a wack sense of humor and enjoy colorful deranged culture, this guild is for you.

• Linus Guild: The cynical, sharp-witted, tech savvy guild. Linus is a laid-back, slightly cynical, yet sharp-witted penguin. He’s a tech-savvy blockchain, crypto, and gaming enthusiast. He enjoys downtime, possibly indulging in a smoke, and takes life at his own pace. He dislikes the establishment and all conventions. Join the Linus Guild to take things easy and do things your way. Things will fall in place.

Assets and Prizes

Here’s an overview of all the assets and prizes being deployed during the Linea Guild Games:

• $100,000 in ETH from Linea.

• $200,000 $SOULS  tokens throughout the game.

• Up to $50,000 in $FOXY.

• $5,000 in $CROAK

• Up to $1,000 in WEF

• Two in-game utility NFTs; avatar and companion.

• “Awakening” in-game rewards.

• In-game items including treasure chests, buffs, boosts, SVPs, and tickets.

• Game7 credits, earned for completing daily quests and play streaks.

Follow Linea on X for updates and get ready to kill some zombies!

Ethereum Name Services (ENS) is a decentralized protocol, governed by ENS DAO and relying on immutable and transparent smart contracts to translate names to addresses. ENS improves user experience, reduces the likelihood of transaction errors, increases accessibility, and establishes a new forum for decentralized digital identities.

While the Linea ENS repository was created to bring ENS to Linea, its component libraries can be applied in other contexts. The functionality of these associated components enables any L1 application to query L2 data using CCIP Read (ERC-3668), equipping developers for cross-chain retrieval.

As vocalized by Vitalik Buterin, standardization across chain-specific addresses, chain-specific ENS, and CCIP Read light clients is a next frontier for the ecosystem. Combined, these solutions can address difficulties that arrise when moving funds between chains, whether due to inconsistent address formats, limited interoperability, or manual processes.

As one of the drivers of this new paradigm, we take a look at ERC-3668 and potential use cases for dapps and developers on Linea.

CCIP Read (Cross-chain Interoperability Protocol) is a protocol that allows applications to access cross-chain or offchain data via a gateway server.

ENS uses CCIP Read to resolve domains on Ethereum, even if the relevant data and records are stored on an L2 chain, through an off-chain resolver framework. This process is trust-minimal, as the gateway provides a storage proof that can be verified on L1, ensuring protection against intervention or tampering.

Linea adapted the functionality of the relevant ENS contract so that it would function correctly with Linea. The Linea ENS repository, therefore, adds support for CCIP Read to Linea. The repository contains a frontend and associated contracts for ENS to work on Linea, including functionality that enables any L1 application to query L2 data using CCIP Read.

The two main components are the Linea CCIP Gateway, which implements the gateway required for L1 protocols to query data on Linea, and the Linea State Verifier, which verifies the state proofs generated by the gateway. Learn more about how CCIP Read works on Linea Docs.

CCIP Read Use Cases

Linea ENS domains are just one use case stemming from the Linea ENS repository. CCIP Read is beneficial in any scenario where it's advantageous to store data on L2. This opens up applications and use cases aligned with parallel innovations across the Ethereum ecosystem.

These proposals across Ethereum are gearing the ecosystem up for new standards for data retrieval. ERC-7683, proposed by Uniswap Labs and Across Protocol, aims to create a unified framework for cross-chain intents, improving interoperability between networks. ERC-3770, meanwhile, introduces a standardized address format with a chain identifier, clarifying the specific blockchain network an address belongs to and minimizing the risk of sending funds to the incorrect chain.

Combined with CCIP Read (ERC-3668), these protocols would effectively automatically support light clients for compliant L2 blockchains, without wallets having to make any additional configurations.

As one (important) step toward this convergence of protocols, CCIP Read already brings a range of potential use cases and integrations for dapps on Linea. Users on L1 can read data from Linea and "outsource" costly operations to Linea, retrieving only the results, with Linea functioning effectively like a coprocessor, but fully onchain:

• Determine eligibility for NFT mints or governance voting: The library enables L1 applications to create allowlists using cross-chain Verax attestations to determine eligibility for NFT mints, governance voting, or other permissioned actions like accessing a regulated DEX pool based on Proof of KYC or receiving special offers for specific user groups.

• Execute L1 transactions based on DAO votes stored on Linea: This mechanism allows L1 transactions to be executed depending on the outcomes of DAO votes stored on Linea.

• Enable ENS subname transfers with NFT sales: This would allow for the attachment of an ENS identifier to an NFT and the association of an onchain subname with your PFP. When the NFT is sold, the associated ENS subname would also be transferred.

• Enable self-service subname creation on Linea: This would allow anyone to launch their own subnames on Linea, with forthcoming documentation to standardize the process, eliminating the need for bespoke handling.

Head to Linea Docs to learn more about CCIP Read and the Linea ENS repository.

But like web3 at large, this model has evolved. EigenLayer, introduced on Ethereum in June 2023, has addressed some of these limitations by introducing restaking across different networks and protocols. Liquid Restaking Tokens (LRTs) are integral to this staking ecosystem, setting themselves apart from Liquid Staking Tokens (LSTs) by introducing the selection of Active Validator Sets (AVSs).

“LRTs connect AVSs, operators, and restakers. They play a critical role not only in risk management but also in ensuring that AVSs are successful, which is crucial for a thriving restaking environment,” explains Fahim Aziz, Co-Founder at Affine, a liquid restaking dapp.

This liquid restaking means that staked assets gain increased flexibility within the DeFi ecosystem and can be used across different dapps. They can serve as collateral for lending, enhance security in different layer 2 (L2) setups, or engage in various consensus mechanisms.

“LRTs are crucial because they offer a unique blend of flexibility and efficiency within. By enabling staked assets to remain liquid, LRTs allow users to leverage these assets across various dapps without having to unstake them,” says Maggie Wang, COO of Zypher Network, an assets protocol for ZK verifiable games, incorporating LRTs into its ecosystem. “In any financial system, liquidity is king.”

Decentralized applications are continuing to adopt and innovate when it comes to liquid restaking tokens (LRTs). Here, Linea spoke to two dapps, Affine and Zypher, who are reimagining liquid restaking.

Zypher: Incorporating LRTs in Web3 Gaming

Zypher Network is an assets protocol for ZK verifiable games, secured by a decentralized proof-mining network that creates a new paradigm of trustless games for both developers and gamers. They’re the team behind popular onchain games like Crypto Rumble.

“It all started with a fully onchain poker game,” shares Maggie Wang, Zypher Network’s COO, on Zypher’s inceptions. “The trend towards ZK becoming more prevalent was clear—with better cost efficiency, democratized accessibility, and improved usability. Neo Sun (now Zypher CEO) and I naturally thought of experimenting with a few games.”

While Zypher’s initial Hold’em game was a success as a demo, the game was impractical for production due to high gas costs and the EVM's limitations for complex verification operations. In response, the team focused on infrastructure improvements, and later deployed a fully onchain Bingo game when Linea launched its Mainnet. Now, a year later, Zypher is introducing a Layer 3 on Linea, called Zytron, providing a gasless environment optimized for running zk-based game SDKs.

Serving 3 billion players around the world, Zypher envisions itself to be the infrastructure for truly decentralized games, where assets are fully composable & interoperable, enabling permissionless modding and open economy.

As Wang explains, this vision means Zypher’s core principles and infrastructure rely on verifiable and transparent asset policies, making it akin to DeFi. “In order to build a scalable and interoperable gaming ecosystem, LRTs play a key role in boot strapping this ecosystem,” says Wang.

The Zypher proof mining network utilizes a mix of Proof of Stake and Proof of Work mechanisms with LRT as a staking token, enhancing the reliability and security of the network. Additionally, the Zytron Layer 3 Network is moving towards decentralizing its sequencers, which will accept LRT tokens as staking collateral. Lastly, Zytron will accept LRT tokens in exchange for gaming tokens, functioning similarly to a decentralized gaming guild that operates automatically, injecting liquidity and value into the gaming economy.

“By incorporating liquid restaking, we enable users to maximize their asset usage across different parts of the ecosystem while maintaining the integrity and transparency that are critical in web3 gaming,” explains Wang.

Zypher is beginning to roll out Zytron, a highly customizable L3 rollup stack, and is in the integration process with 20 games and 10 dapps live at launch. “Zytron provides smart-contract-level optimizations like zero gas, wallet abstraction, and chain abstraction,” adds Wang. To participate, gamers can stake LRT tokens in exchange for a gasless SBT for gas redemption eligibility.

Affine: Prioritizing Risk Assessment for DeFi

Affine has set out to build a robust DeFi future, introducing the Affine Risk Engine and two LRTs–one on EigenLayer and one symbiotic–built on top of it.

“My co-founder, Tarik and I were excited about the potential of restaking but also saw the inherent risks in using the same capital to secure networks with varying levels of risk. A cascading slashing event could be catastrophic for the entire industry, much like the 2008 housing crash,” recalls Fahim Aziz, Affine’s co-founder, on the initial building stages.

This market awareness led Affine to develop a risk engine first, built on a Bayesian model that receives inputs from various operators and AVS factors to generate a credit score and a slashing risk audit report.

The risk engine sits at the core of Affine’s restaking. “We believe it’s crucial to manage the risk of rehypothecation so that the industry can grow and progress in a risk-adjusted manner,” says Aziz. Affine also prioritizes smart contract and dapp security through a range of measures, including audits and innovative AVS solutions like Drosera, which involves setting traps to enhance security.

Affine’s LRT, ultraETH, was launched in July 2024 and has recently landed on Linea. UltraETH offers transparent risk management that reduces the chance of cascading slashing as AVSs go live.  It also provides clear rewards through ultraETH, Symbiotic/Eigenlayer points, undiluted AVS points, and various incentives from chains and protocols.

“Restaking has incredible potential, and we need to work hard to make it robust. We are collaborating with top operators, AVSs, and chains, and many exciting partnerships will be announced soon,” adds Aziz.

-

Follow Zypher and Affine to keep up to date on new launches.