DEV Community: Mode

How to Deploy and Verify a Smart Contract on Mode's Blockchain using Foundry

Mode — Fri, 26 Jul 2024 14:49:41 +0000

In this tutorial, you will learn how to deploy and verify a smart contract on Mode using Foundry. This process is essential for those looking to understand and effectively implement smart contracts in blockchain environments. Let's get started!

Prerequisites:

Have a wallet. If you don't have one, you can create one here.
Have some ETH on Mode testnet. You can follow our guide on how to bridge or use this faucet to claim some ETH on Mode.
Have Foundry installed. You can do so here.
Have a code editor of your preference. I'll be using VSCode (install), but feel free to use any other code editor of your choice.

Environment Setup:

Let's configure our project.

First, create a folder where all our project files will reside. To do this, open your terminal (I'm using Ubuntu) and type ‘mkdir ’. Once the folder is created, navigate into it by typing ‘cd ’. After setting up our project folder, open it in your code editor by typing ‘code .’, which will open VSCode if you're using it.

Create a folder for the project

mkdir <Folder Name>

Navigate to the created folder

cd <Folder Name>

Open the folder in Visual Studio Code

code .

Note: The provided commands are for Ubuntu users. If you are using Windows, you might need to use different commands. Make sure to adapt the commands according to your operating system. ChatGPT is great for that ;)

Your terminal should look something like this:

Now open your code editor, I'm using VSCODE.

Once your project folder is open in VSCode, open the VSCode terminal.

Type forge init in the terminal to initialize a Foundry project. After initializing Foundry in your project, your terminal should display:

If everything went well, you should see your folder structure similar to:

A brief explanation of each file:

.github: Typically contains GitHub Actions configurations and workflows.
lib: Contains libraries and dependencies your project needs.
script: Stores scripts automating tasks like deployments or tests.
src: Main folder for your project's source code, including smart contracts.
test: Folder for testing your code to ensure it functions as expected.
.gitignore: Specifies files and folders Git should ignore.
.gitmodules: Used for Git submodules if your project includes them.
foundry.toml: Foundry-specific configuration file defining tool options.
README.md: Contains project information, setup instructions, and usage details.

Writing the Smart Contract:

Configure your smart contract. I'll use a customized ERC20, but you can create your own using the OpenZeppelin Wizard.

Smart Contract Compilation:

Blockchain compilation process

Compilation transforms code written in languages like Solidity into bytecode, binary instructions interpreted by the Ethereum Virtual Machine (EVM). This prepares the contract for execution on the blockchain, where it's stored and can interact with other contracts and users via specific transactions.

After creating and saving your smart contract, open the VSCode terminal and type ‘forge build’ to compile the smart contract.

Deploying the Smart Contract:

Once compiled, we'll proceed with deployment. Before running the command, keep reading to know more about it!

Type:

forge create --rpc-url https://sepolia.mode.network --private-key <YOUR_PRIVATE_KEY> src/ModeDeploy.sol:ModeDeploy --constructor-args <arg1> <arg2> <arg3>

Let's break down the command:

forge create: Foundry command to deploy a smart contract.
--rpc-url https://sepolia.mode.network: Specifies the RPC node URL for contract deployment. Here, it's for Mode's Sepolia network.
--private-key <YOUR_PRIVATE_KEY>: Provides the private key of the account used for deployment. Replace ‘’ with your actual private key. Keep this information secure and do not share it.
src/ModeDeploy.sol:ModeDeploy: This argument specifies the location of the contract file and the contract name within that file. In this case: src/ModeDeploy.sol is the path to the contract file.
ModeDeploy is the name of the contract within that file.
--constructor-args <arg1> <arg2> <arg3>: This flag provides the arguments that will be passed to the constructor of the smart contract during deployment. Replace , , and with the actual values you want to pass to the constructor.

If your smart contract doesn't require constructor arguments, omit --constructor-args <arg1> <arg2> <arg3>.

After deploying the smart contract, you can view it on BlockScout by entering the transaction hash of the deployment.

The transaction hash shows details such as deployed tokens, token name, deployer's address, block number, gas consumed, and more. For further details on transaction hash features, refer here.

Verifying the Smart Contract:

To verify a smart contract, it must first be deployed (as done above). Once deployed, open the VSCode terminal and type

forge verify-contract CONTRACT_ADDRESS src/ModeDeploy.sol:ModeDeploy --verifier blockscout --verifier-url https://sepolia.explorer.mode.network/api\?

Let's break down the command:

forge verify-contract This is the Foundry command used to verify a smart contract on a block explorer.
CONTRACT_ADDRESS Here, replace CONTRACT_ADDRESS with the deployed contract address you wish to verify. For example, if the contract address is 0x1234567890abcdef1234567890abcdef12345678, the command would look like this:

forge verify-contract 0x1234567890abcdef1234567890abcdef12345678 src/MyERC20.sol:MyERC20 --verifier blockscout --verifier-url https://sepolia.explorer.mode.network/api\?

src/ModeDeploy.sol:ModeDeploy This argument indicates the location of the contract file and the contract name within that file. In this case:

src/ModeDeploy.sol is the path to the contract file.

ModeDeploy is the name of the contract within that file.

--verifier blockscout This flag specifies Blockscout as the verification service. Foundry supports different verifiers, and here we're specifying the use of Blockscout.
--verifier-url https://sepolia.explorer.mode.network/api\? This flag provides the URL of the Blockscout verifier API we will use. In this case, it's the Sepolia network explorer URL on Mode.

To confirm successful verification, enter the contract address on BlockScout. Go to the contract tab.

This tutorial was conducted on Mode's testnet. Here's a link with information on doing this on the mainnet.

If you encounter any issues or have questions or suggestions, join the Mode Discord and obtain the developer role. Here's how to get the role. Feel free to ask anything; we're here to help.

I hope you found this tutorial on Deploying and Verifying a Smart Contract on Mode's Blockchain using Foundry helpful. If you did, follow me on Twitter for more interesting content and updates. Thanks for reading!

Introducing Strateg: The Yield Infrastructure Layer

Mode — Fri, 19 Jul 2024 13:12:27 +0000

The DeFi Ecosystem has seen significant growth over the past few years, with a staggering increase in TVL by 75.1% this year, this only shows the importance of decentralized finance protocols in driving innovation in the finance industry.

The interesting thing about this growth is that it cuts across every Defi sub-sector and is not limited to big players in the industry. The five sectors showing significant growth include Yield protocols, stablecoins, money markets, prediction markets, and derivatives.

This growth has also brought about more protocols with increasing complexities for a basic user. These protocols try to solve DeFi problems while paying less attention to user experience and accessibility. While we can try to educate people on using our complex tooling and infrastructure, we should make it more accessible. People don’t care about the underlying technology behind your protocol, they only care that it works and is readily accessible.

Strateg is solving this problem of accessibility by revolutionizing the way yield is generated in the Defi Ecosystem. In this article, we will cover all about it and more.

What is Strateg?

Strateg is an ominichain social yield infrastructure that provides users with the ability to CREATE and Implement complex yield strategies across multiple chains while also providing a profitable way to SHARE these strategies with your audience, communities, users, and clients. Through a solid data set, user-friendly tooling, and secure smart contract infrastructure, Strateg enables the global adoption of complex DeFi strategies by millions of businesses and users.

Strateg provides a suite of tools and infrastructure that lets you harness the opportunities in DeFi by providing a way for users to EARN profits through any protocol on any chain. Whether you’re looking to maximize your yields thereby increasing your risk by investing in multiple protocols or you want to minimize your risks and invest in a few, Strateg has got you covered, Just bring in your assets and you will be provided with a strategy that fits your needs.

What can I do with Strateg?

As I mentioned earlier, you can create complex yield strategies, share these strategies with your audience, and also earn profits from your yields. Let’s explore how it all works in this section.

1. Creating Complex Yield Strategies
Defi has given us the ability to put our assets in multiple protocols at once and expect profit from each one of them. This can be in the form of Restaking or borrowing against a deposit in a liquidity pool and investing in another protocol. All these complex steps require research, a well-versed knowledge of the protocol, and knowing where to find the best yields.

Complex strategies are put together by Defi experts who know where to find the best yields, understand risk management, and have done well-rounded research on protocols to invest in.

2. Leveraging Complex Strategies
For an Inexperienced Defi user or someone who wants to make a quick investment, going through the process of research, understanding risk management, and knowing which protocols are safe and profitable to invest in can be overwhelming. This alone can prevent a user from investing at all and this is the problem of accessibility I spoke about earlier.

With Strateg, users can leverage the strategies provided by experts thereby delegating the heavy lifting while they simply invest in a non-custodial manner while considering their risk appetite.

3. Earn from sharing Strategies
Up until now, Defi experts, Researchers, and crypto degens have always provided their audience with their knowledge for free on social media platforms (Like YouTube and Twitter). But, what if there is a way to monetize every strategy you provide?

Strateg provides a way to earn, depending on the performance of the strategy. The strategy creator receives a performance fee called the “creator fee”. This goes a long way in encouraging the creator to create more reliable strategies, making it a win-win situation for the creator and the user.

4. Integrations and partnerships:
Strateg white-label integrations facilitated by the use of tools such as widgets, SDK, and API enable a fluid and unique experience with leading blockchains and protocols.
Pilot programs will generate valuable customer testimonials and demonstrate real successes, fostering trust and adoption.
Making yield generation accessible to everyone, without the technical hassle is the key. Then forge strategic alliances with key industry players to accelerate growth and adoption.

Conclusion

From a basic user perspective, you can now choose strategies based on the reputation and the track record of the creator. The creator on the other hand puts in sufficient effort to come up with reliable strategies because they earn from the strategies.

Strateg is still in private beta and undergoing security audits, but you can connect with the team and community for announcements and updates with the links provided below

If you’re a Defi protocol interested in what strateg is building and want to be part of it you can check out this form.

Connect with Strateg;

Splice Finance: Your Key to Superior DeFi Yields

Mode — Thu, 27 Jun 2024 12:50:30 +0000

This article was written by Gordian one of Mode's tech cooperators.

Introduction

In decentralized finance (DeFi), finding and utilizing the right platform to maximize your investment yields can be daunting, especially for beginners. Splice Finance aims to simplify this process by offering options between fixed APR and boosted points, allowing users to optimize their investments.

This article explores what Splice Finance is, how it works, and why it's valuable for both novice and experienced DeFi participants.

What is Splice Finance?

Splice Finance is a Decentralized Application (DApp) operating on the Mode Network. Splice provides users with the flexibility to choose between fixed yields (APR) or greater exposure to any capital stream accrued by the underlying accounting token, specifically leverage on native yield, or boosting point exposure. This dual-option system enables users to tailor their investment strategies according to their risk tolerance and financial goals.

How Does Splice Finance Work?

Splice Finance simplifies the DeFi experience through three core features: Markets, Portfolio, and Swap.

Markets

Portfolio

In the Portfolio section, users can monitor and manage their investments effectively. It provides a comprehensive view of assets and facilitates informed decision-making based on financial objectives.

Swap

The Swap feature enables token exchange between yield tokens (YT) and principal tokens (PT). This flexibility allows users to dynamically adjust their investment strategies for fixed yields or boosted points.

Users can explore different yield markets, manage their investments, and swap tokens to optimize their returns. The platform supports various tokens, each with specific yield options and maturity dates.

What can you do in Splice Markets section?

Markets

The Markets section allows users to explore various token options and their respective yields within Splice. Tokens such as wrsETH (Kelp), weETH (EtherFi), ezETH (Renzo), and MODE (Mode) offer unique yield rates and multipliers, which may vary over time. Note, the following examples below offer an explanation of yield opportunities at the time of writing; they may not be available as quoted in the future.

Here’s an example explanation of the Market screenshot below:

wrsETH (Kelp):
- Fixed Yield APY (Annual Percentage Yield): PT tokens of wrsETH offer a fixed yield of 19.82% APY.
- Points Multiplier for YT: YT associated with wrsETH has a points multiplier of 64.00x.
- Maturity: This shows that the Tokens mature on 21st August 2024.
- Liquidity: $164,038 represents the total liquidity available for trading the wrsETH token pair on Splice Finance.
weETH (EtherFi):
- Fixed Yield APY: PT tokens of weETH provide a fixed yield of 14.82% APY.
- Points Multiplier for YT: YT associated with weETH offers a points multiplier of 126.00x.
- Maturity: This shows that the Tokens mature on 21st August 2024.
- Liquidity: $121,839 denotes the total liquidity available for trading the weETH token pair on Splice Finance.
EZETH (Renzo):
- Fixed Yield APY: PT tokens of EZETH have a fixed yield of 24.45% APY.
- Points Multiplier for YT: YT for EZETH features a points multiplier of 104.00x.
- Maturity: This shows that the Tokens mature on 21st August 2024.
- Liquidity: $461,733 indicates the total liquidity available for trading the EZETH token pair on Splice Finance.
MODE (Mode):
- Fixed Yield APY: PT tokens of MODE offer a fixed yield of 76.53% APY.
- Points Multiplier for YT: YT associated with MODE has a points multiplier of 20.00x.
- Maturity: This shows that the Tokens mature on 21st August 2024.
- Liquidity: $335,579 represents the total liquidity available for trading the MODE token pair on Splice Finance.

These would provide you a clear overview of each token's Fixed Yield APR, Points Multiplier for Yield Tokens (YT), and the liquidity available for trading on Splice Finance. It helps users grasp the yield options and market accessibility for each token respectively.

What can you do in the Splice Portfolio section?

Portfolio

Swap

The Swap feature enables users to exchange their tokens for either yield tokens (YT) or principal tokens (PT). This flexibility allows users to adjust their investment strategies dynamically, optimizing for either fixed yields or boosted points and yield volatility.

How to Swap Tokens on Splice Finance

Swapping tokens on Splice Finance is an easy and straightforward process that allows you to either buy Yield Tokens (YT) or Principal Tokens (PT) easily.

To buy Yield Tokens (YT), start by choosing the token you want to swap, such as ezETH. Send your selected token to the swap contract, which will route Splice Yield (SY) from the pool. The contract then mints Principal Tokens (PT) and YTs from the SY, and you receive YTs. The PTs are sold for SY to balance the routed amount.

To buy Principal Tokens (PT), choose the token you want to swap, like ezETH or YT-ezETH, and specify the amount.

Approve the transaction to authorize the swap, then click the swap button to receive PTs.

Benefits of Swapping on Splice Finance

Efficient Yield Maximization:
- Swapping allows you to efficiently acquire YTs or PTs, enabling you to maximize your yield based on your investment strategy.
Flexibility with your Investments:
- Splice provides the flexibility to choose between stable, fixed returns with PTs or higher potential rewards with YTs.
No Liquidation Risks:
- By participating in swaps, you can avoid liquidation risks that are common in other DeFi protocols.
Helps with Optimal Trading:
- The relationship between PT and YT prices allows for optimal trading strategies, including flash swaps, which leverage the inverse price correlation for better returns.
Access to other Integrated tokens and Ecosystem:
- The seamless integration of various tokens and yield options on Splice allows for a comprehensive and user-friendly trading experience.
Boosted Rewards and points both on both Splice, Mode and other ecosystem:
- By becoming a liquidity provider (LP), you can earn additional trading fees and incentives, which helps increase your overall yields too. It also helps you get more Mode airdrop points.

What are the key tokens and concepts of Splice and how can you benefit with them?

What are Splice Tokens :

There are four types of tokens that make up a Splice market:

Principal Tokens (PT): These tokens allow users to purchase at a discount to their fair market value on the day of maturity. This provides a fixed yield that buyers can rely on. Ideal for those seeking stable and predictable returns.
Yield Tokens (YT): Offer leveraged yields during the contract term, diminishing to zero upon redemption but tradable prior to maturity. Perfect for users looking to maximize their returns through points.
Standardized Yield Tokens (SY): These are the tokens received when minting yield tokens, exchangeable for underlying tokens on the Swap page.
Liquidity Provider Tokens (LPT): Minters of these tokens receive both annual percentage yield (APY) and yield points, although both will be lower than PT and YT tokens individually. Additionally LPTs accrue yield through swap fees. Suitable for those looking to hedge against either consolidated strategy and earn global returns.

Splice Concepts:

Fixed Yield APR: The Annual Percent Return for holding PT tokens, providing a clear and stable expected return.
Boosted Points: Holding YT increases multipliers on points in addition enhanced variable yield exposure, potentially leading to higher overall returns.
Maturity Date: The date when PT tokens can be redeemed for the underlying asset, marking the end of the yield accumulation period for YT token holders.

Strategies to Optimize Investment Yields on Splice (NFA):

Free The Yield: All yield is streamed to YT until maturity, providing substantial returns through boosted points. This strategy is ideal for users looking to maximize their variable yield potential.
Zero Price Impact Mode: Minting PT and YT tokens without affecting market prices, ensuring optimal trading conditions.
Long on PT Tokens: This strategy focuses on maximizing fixed yields, providing stable and predictable returns.
Long on YT Tokens: This strategy aims to maximize points and variable yield returns, suitable for users seeking higher but potentially more volatile returns.

What is the Yield Trading Concept?

Yield trading on Splice Finance involves buying and selling yield tokens (YT) and principal tokens (PT) to optimize returns based on market conditions and personal investment strategies. Here's how it works:

Trading YT Tokens: Yield tokens accumulate returns over time and can be purchased for higher points multipliers. This makes them attractive for users who anticipate higher yield growth and are willing to accept higher volatility.
Trading PT Tokens: Principal tokens provide fixed yields and can be traded for their stable returns. These tokens are ideal for users who prefer predictable and steady expected returns.
Market Timing: Users can optimize their returns by strategically trading PT and YT tokens based on their yield forecasts. For instance, buying PT tokens when fixed yield APRs are high and selling them when the rates decrease can maximize returns.
Yield Arbitrage Opportunities: Savvy traders can exploit price differences between PT and YT tokens across different markets, taking advantage of temporary inefficiencies to earn profits.

Why use Splice Finance?

Splice Finance stands out for its flexibility, optimization potential, and integration with multiple protocols which are:

Mode Network: Helps to earn Mode points and leverage Mode’s ecosystem airdrop.
EtherFi (weETH): Provides fixed and variable yield opportunities with EtherFi LRT’s tokens.
Kelp (wrsETH): Enables yield generation through KelpDAO’s token ecosystem.
Renzo (EZETH): Allows users to benefit from Renzo’s yield strategies.

When to Use Splice Finance?

New to Decentralized Finance: If you are new to decentralized finance and want to try things out in yield farming with guided strategies, Splice offers you that freedom.
Optimizing Yields: Suitable for maximizing returns through strategic investments and swaps.
Portfolio Management: Useful for tracking and managing investment performance in a consolidated platform.
Long-Term financial Investment: Suitable for users looking to generate sustainable passive returns through DeFi investments over the long term.
Diversification of financial Investments: Aids in distributing your portfolio across different tokens and integrated protocols.

Getting Started with Splice Finance

Documentation , Tutorials and Guides: Access comprehensive guides at Splice Finance Docs.
Join the Discord Community: Join the Splice community for discussions and receive support on Discord.
Visit the Splice Website: Learn about the available markets and features on the Splice Finance Website.
Contribute to GitHub Repository: View the latest updates and contributions on GitHub.

Conclusion

Splice Finance empowers users to enhance their DeFi investments with strategic flexibility, whether they are new to the space or experienced. By understanding the Splice dashboard features, token concepts (YT, PT, SY, LPT), and optimal investment strategies, users can tailor their investments to maximize their returns accordant to their risk tolerance. Splice Finance also provides the tools, resources, and community support necessary to optimize your investments yields effectively.

Introducing Houdini Swap; A Privacy first cross-chain liquidity aggregator

Mode — Fri, 14 Jun 2024 12:07:08 +0000

TL; DR
Move ETH to Mode in one-click privately and compliantly only on Houdini Swap.

On the road to making cryptocurrency, blockchain tools, and blockchain protocols user-friendly enough for mass adoption, we’ve had innovation and solutions around scalability and security issues. Still, we don’t talk about privacy as much.

Blockchains are designed to be transparent and open to the public by default. While this may be good in some cases it also comes with its fair share of disadvantages. Just by knowing your wallet address anyone can see your transaction history, monitor you, and know exactly the assets that you hold.

This is what Houdini swap solves; In this article, we will understand what Houdini swap is, how it works, and how it solves this privacy issue.

What is Houdini Swap?

Houdini Swap is a leading provider of private cryptocurrency transactions and provides services such as sending, swapping, bridging, and receiving cryptocurrency across major blockchains, all while prioritizing user anonymity and privacy.

Houdini Swap maintains user privacy by concealing the user’s wallet address while they engage in a transaction. At a lower level, it achieves privacy for users by using a dual exchange system and randomized layer 1 chain. Let’s explore this in the next section.

How does it work?

Houdini Swap's protocol achieves user privacy through a multi-faceted approach that obscures the transaction path and breaks any direct link between the sender and receiver. Here’s a breakdown of how each component contributes to this privacy:

1. Dual Exchange System:

Exchange 1 handles the initial reception of funds and swaps them before sending them across a randomized Layer 1 blockchain.

Exchange 2 manages the receipt of these funds on the Layer 1 blockchain, swaps them into the receiver's specified token, and dispatches them to the receiver.

By splitting the transaction process between two independent exchanges, each exchange only has partial knowledge of the entire transaction, ensuring that no single party can trace the full transaction path.

2. Record Segregation:

Exchange 1 records the intake and swaps the funds to be sent across a randomly selected Layer 1.

Exchange 2 records the receipt of funds from the Layer 1 and swaps them into the desired token before dispatching them to the receiver.

This separation ensures that each exchange has only one-half of the transaction information, making it impossible to piece together the complete transaction details from the records of either exchange alone.

3. Single-Use Wallet Addresses:

Both exchanges use newly created, single-use wallet addresses for each transaction.

Exchange 1 sends funds to a single-use wallet address of an unknown owner.
Exchange 2 receives funds from a single-use deposit address of an unknown user.

This method prevents any address reuse, making it harder to track transactions based on wallet addresses. Since neither exchange knows that the other is also an exchange, it further obscures the transaction path.

4. Randomized Layer 1s:

A randomly selected Layer 1 blockchain acts as an intermediary layer, breaking the direct link between the sender’s original tokens and the receiver’s final tokens. Layer 1 blockchains used in this process are chosen from a diverse portfolio, including chains like TRX, LTC, SOL, and DOT, each with high liquidity and transaction volumes.

The randomization of the Layer 1 blockchain adds a layer of obscurity, making it exceedingly difficult to trace which specific transactions across various blockchains are linked.

5. Anonymity in Transaction Flow:

The combination of two exchanges and a randomized Layer 1 ensures there is no identifiable on-chain connection between the sender and receiver. Neither the exchanges nor any external observer can see the full transaction flow. Each exchange only knows about the transactions it directly handles, ensuring that no party has the complete picture.

How to make use of Houdini Swap

With Houdini swap, you can either send, swap, or bridge your assets. Here you have three easy steps on how to do it:

Step 1 - Get Your Order Quote

Select a Crypto pair: Choose which two tokens you want to swap, send, or bridge.

Enter Amount: Enter the crypto amount to be sent. Select Fixed for a specified amount to be received. Choose Variable to get the best market rates.

Price Optimized: Houdini Swap finds the lowest rates.

No Wallet Connect: For security, you don’t need to connect your wallet.

Step 2 - Send Your Funds to Start

Receiving Wallet Address: Input the address of the receiving wallet. Ensure it's on the same blockchain as the receiving currency.

Initiate Order: Send the specified crypto amount to the Houdini Swap address.

Step 3 - Transaction Completion

Transaction Processing: Private transactions take 20-40 minutes on average. Semi-private transactions take about 3 minutes.

Track Progress: Follow your transaction's progress once initiated.

Why Choose Houdini Swap

Below are some reasons why Houdini Swap stands out and why you might consider choosing it.

Compliant, private transactions
No need to connect your wallet if you don’t want to
Non-custodial
24/7 support
Cross-chain
Low-cost
Fast settlement times
Supports 30+ chains
Supports 100+ tokens
Processed over $443M+ in volume
$5 million annual revenue
25% of supply staked
Revenue backed APY

Don’t forget that you can also swap ETH to MODE privately and in one click only on Houdini swap.

To learn more check out the Houdini swap Docs

Optimism Retro Funding Round 4: All you need to know

Mode — Mon, 03 Jun 2024 13:20:15 +0000

Optimism is a Layer 2 scaling solution that transcends being just a simple blockchain protocol. As a Collective, It fosters a collaborative environment, which tackles various technical aspects of a decentralized ecosystem. This Collective is building the foundation for next-generation applications on a network of blockchains called a "Superchain." The OP mainnet, a high-throughput scaling solution for Ethereum, serves as the core of this Superchain.

Developers can leverage the OP Stack, a collaborative knowledge base, to streamline development on the Superchain. A strong community backs this technical framework and OP governance empowers the community to participate in shaping the project's future through a sophisticated voting system. Optimism is a powerful combination of technical infrastructure and a community working together to push the boundaries of the blockchain ecosystem.

Optimism Retro funding

Optimism Retro funding, initially called Retroactive Public Goods Funding (RPGF), aims to financially reward those who contribute to the growth of the Superchain ecosystem. Round 4 is currently open for application and it focuses on onchain builders, rewarding those building products, tools, or infrastructure that place a demand on OP blockspace and provide value to the ecosystem

Key Dates

Sign up: May 23rd - June 6th
Application Review Process: June 6th - June 18th
Voting: June 23rd - July 8th
Results & Grant delivery: July 15th

What are the Eligibility Criteria?

The Eligibility criteria are a set of standards designed to restrict the influx of low-impact projects while maintaining a balance between broad inclusivity and the conditions required to accept projects with significant impact for the funding round.

Eligible projects should have to;

Deploy their onchain contracts on one or multiple of the following OP chains: OP Mainnet, Base, Zora, Mode, Frax, and Metal, and meet the following requirements:

Onchain contracts have interactions from 420 unique addresses from Jan 1st - May 1st, 2024

Onchain contracts had their first transaction before April 1st, 2024

Onchain contract had more than 10 days of activity from Jan 1st - May 1st, 2024

Verify their onchain contracts in the Retro Funding sign-up process.

Make their contract code available in a public GitHub repo, for which ownership has been verified in the Retro Funding sign-up process.
Confirm that they will comply with Optimism Foundation KYC requirements and do not reside in a sanctioned country.
Submit a Retro Funding application before June 6th, 2024, and comply with application rules.

What would you be rewarded for?

The Retro Funding round 4 is focusing on onchain builders who have made a significant impact from October 2023 - June 2024. In no particular order, below are some of the metrics that would be considered.

Demand generated for Optimism blockspace.
Interactions from new Optimism users.
Open source license of contract code.
Repeated Interactions from Optimism users.
Interactions from Optimism users with high trust scores.

How do you apply?

For the application process, there is a possibility of making errors or changes after applying so it would be best to make your submission as early as possible to allow you to make changes and corrections later on.

Go to Optimism Retrofunding and Sign in with Farcaster.

Add a project to your profile.

Note the Following while filling in the details for your project;

Your project’s contract must be deployed on Mode or any other chains in the superchain.
To verify ownership of the contract you have to sign a message from the deployer wallet of the contract.
To prove ownership of your project's Github Repository you’ll have to push a generated JSON to your default branch.
You can add your teammates to the project with their Farcaster profiles.
Add an email

After filling in all your details, do a crosscheck then apply! You should get an email to confirm your application.

Resources

Below are some extensive resources to check out.

Retrofunding 4 Round details by Optimism
Retrofundng 4 Application process by Optimism
A quick guide to Optimism Retro Funding 4 by Koha

This post was written by Revealer, tech cooperator @ Mode.

Introducing Molend: the Pioneering Lending Protocol on Mode Network

Mode — Fri, 24 May 2024 15:00:00 +0000

Molend, the next-generation lending protocol, launches on the Ethereum Layer 2 blockchain Mode. Users can now engage in collateralized lending and borrowing using Molend. Mode is the DeFi L2 designed for growth, incentivizing and directly rewarding developers, users, and protocols to foster the development of the Mode and superchain ecosystem.

Traditional Lending vs Decentralized Lending

Traditional bank lending services are known for their complex and lengthy processes, causing inconvenience for borrowers. Decentralized lending protocols, on the other hand, offer fast loan disbursements and high security, gaining increasing popularity and occupying a significant share in the DeFi space. In simple terms, users can borrow other digital assets by collateralizing their existing digital assets and engage in various profit-generating activities. This includes taking long or short positions on assets through lending, participating in DeFi farming to generate yields, or simply earning interest on deposited assets.

Empowering Users with Molend’s Flash Loans and Loop Feature

Molend provides two primary functions: depositing and borrowing. By placing funds into Molend, depositors can earn interest from the borrowing activities of others. Flash loan, a distinctive feature of Molend, allows borrowing & repaying from the liquidity pool in a single transaction, eliminating the need for collaterals when a borrower can repay the loan atomically. Users incur only a minimal processing fee in addition to the standard gas fee, making it an efficient option for quick financial transactions. Flash Loans are particularly useful for arbitrage, enabling users to profit from price discrepancies across different protocols and liquidation opportunities.

Furthermore, Molend will be introducing the Loop feature in the near future to simplify the process of leveraging and borrowing assets for users. The Loop feature enables users to lend and borrow the same type of asset multiple times with a single click. More details about this feature will be revealed soon.

Note: Molend will use a point system to track users' deposits/borrowings, and allocate airdrop rewards based on the number of points.

As a highly anticipated flagship product, Molend has many advantages. Molend has high composability and can be integrated into other platforms for use. In terms of user experience, Molend provides a user-friendly data dashboard, allowing users to accurately assess profit trends and execute investment strategies. Flash Loans provide efficient investment tools for advanced users, while most of the fees generated are directly subsidized to users who have. The team behind Molend has extensive experience and a strong technical background in the cryptocurrency industry, enabling them to identify and address user pain points accurately.

Earn Rewardsfor Being an Early User on Molend

MODE has a mainnet airdrop campaign for early users and a point system dedicated to it. Molend will be a close partner of the campaign, meaning Molend users will earn more MODE points by using Molend.

Moreover, Molend is also allocating 10% of its governance token, $MLD, to early users through airdrops. As a holder of $MLD, you have governance rights over the protocol AND receive protocol revenue sharing. 50% of the loan interest generated across the protocol will be directed to $MLD holders, enabling $MLD tokens with strong value capture capabilities.

Our point system tracks your deposits and borrowings, allowing us to allocate airdrop rewards based on the points you accumulate. The more you engage with Molend, the more rewards you can earn!

In the future, Molend will explore additional gameplay and features while partnering with more blockchain networks and ecosystems. Stay tuned for updates!

About Molend

Molend is the next-generation lending protocol built on the Ethereum Layer 2 blockchain, Mode Network. Depositors earn passive income by providing liquidity, while borrowers access assets through over-collateralization. Powered by Mode, Molend ensures secure lending with transparent governance. Join Molend to be part of the decentralized lending revolution and unlock a world of possibilities in the Mode and Superchain ecosystem.

Stay Connected

Twitter | Discord | Telegram | Medium

How To Setup a Multi-Signature Wallet with Safe (prev. Gnosis Safe) on Mode

Mode — Thu, 23 May 2024 23:23:00 +0000

Safe formerly known as Gnosis Safe is a decentralized protocol and wallet that stands at the forefront of secure asset management for Ethereum and other EVM-compatible blockchains.

In this guide, I will show you how to set up a Safe wallet on Mode, the modular DeFi layer 2 part of Optimism's Superchain.

What is Gnosis Safe?

Safe is a multi-sig smart contract wallet that allows you to store your assets.

Some of its core innovative functionalities include;

Multi-signature security: Safe allows multiple owners (signers) to control a single wallet, requiring a set number of approvals for any transaction to occur. This adds a significant layer of security compared to single-signature wallets(Regular private key wallets), minimizing the risk of unauthorized access or accidental transactions.
Smart contract-based: Unlike traditional wallets, smart contracts can be modified and programmable, giving more flexibility and control. Additionally, this allows for more sophisticated features like time-locked transactions or custom execution conditions to be added to a wallet.

Why is MultiSigs Important?

Multisigs provide increased security for your assets, especially for businesses and organizations. Let’s take a look at a practical example to understand this better.

Imagine you're running a small business with two partners and need to manage a company bank account. Here's how multisigs can be beneficial:

Scenario 1: Regular Single-Signature Account

Each partner has their login credentials and can access the funds independently.
This poses a security risk: one partner could misuse the funds without the others' knowledge.
Building trust and ensuring transparency can be challenging. Don't trust, verify.

Scenario 2: Multi-Signature Account with Safe

You create a Safe wallet for the business account, requiring both partners' approvals for any transaction.
Each partner holds a private key, and any transaction requires both keys to be used.
This significantly reduces the risk of unauthorized spending, as both partners must agree and sign off on transactions.
Transparency is increased as all transactions require explicit approval from both parties, building trust and reducing potential disputes.

Our example shows that Safe improves transparency, offers shared control, enhances security, and reduces human error.

How to create a Safe wallet on Mode

Step 1: Go to the Superchain Safe website and connect your wallet.

Select Mode as your preferred Network.

Step 2: Select your preferred wallet and authorize the action.

Step 3: You won’t have Mode network set as a default in your wallet, so you would need to switch. Click here to add Mode to your wallet if you haven’t.

Click the wallet area and switch to Mode.

Step 4: Continue with Metamask on Mode.

Step 5: Create the name of your Safe.

Step 6: Add the number of owners you want for the wallet.

You can also set the threshold for the number of owners that must sign a transaction before it goes through.

💡
The amount of owners you set doesn't have to relate 1 to 1 with a person. You could also set up a Safe wallet for yourself and require 2 or more signatures to approve the tx, even if you are the owner of all the private keys.

Step 7: Review your settings, click on next, and start using the superchain safe.

Step 8: Wallet Created successfully!

Congratulations! You just created a Multisig wallet on Mode Network.Me

How Protofire is Bringing Safe to the Superchain

Protofire is a team of blockchain experts that helps companies and ecosystems build tools, scale their TVL(Transaction Volume), and improve their infrastructure.

Having been approved to build Safe for the Optimism superchain ecosystem, Protofire plans to bring Safe to the Superchain through continuous deployment and maintenance service.

Here's a breakdown of their plan:

Deployment and configuration:

They will pre-deploy the safe-singleton factory on new networks to optimize the process.
Safe will be deployed and configured with network branding and UI integration, including two environments (Stage and Production) for both Mainnet and Testnet.
Safe will be deployed on up to 10 networks which include Mode, Zora, and PGN.

Support and maintenance:

Protofire will provide regular updates to Safe, monitor infrastructure, and offer support to governance and the community.
They will also develop new features with a limited scope (10 hours per network per month).

Click here to learn more about how Protofire plans to bring Safe to the Superchain ecosystem.

Note that this is still an ongoing project and can run into potential issues and bugs.

What’s Next?

We’re building a community where developers and users can grow as the network grows, this is why we have several hackathons, workshops, campaign quests, and community calls to cement this goal.

Say hi in our discord if you have any questions or would love to be part of our community, we would love to have you.

How to Verify Smart Contracts on BlockScout with Hardhat

Mode — Thu, 23 May 2024 14:22:13 +0000

Verifying a smart contract on Blockscout makes the contract source code publicly available and verifiable, which creates transparency and trust in the community.

This guide will walk you through verifying a smart contract on Blockscout with Hardhat.

Prerequisites

Before you begin the steps in this guide, please ensure you have the following:

You should have a Hardhat project initialized on your machine.
An Etherscan Account. Don't have one? go to Etherscan and sign up for an account.

Verifying the Smart Contract using Hardhat

Step 1: Install the `Hardhat-Verify` Plugin

The hardhat-verify plugin helps you verify the source code for your Solidity contracts.

In your project directory, install hardhat-verify

npm install --save-dev @nomicfoundation/hardhat-verify

And add the following statement to your hardhat.config.js:

require("@nomicfoundation/hardhat-verify");

Or, if you are using TypeScript, add this to your hardhat.config.ts:

import "@nomicfoundation/hardhat-verify";

Step 2: Configure Hardhat

Add the following configuration to the config object in hardhat.config.js.

 etherscan: {
    // Your API key for Etherscan
    // Obtain one at https://etherscan.io/
    apiKey: {
      mode: '<ETHERSCAN_API_KEY>',
    },
    customChains: [
      {
        network: 'mode',
        chainId: 919,
        urls: {
          apiURL: 'https://sepolia.explorer.mode.network/api\?',
          browserURL: 'https://sepolia.explorer.mode.network',
        },
      },
    ],
  },

Replace <ETHERSCAN_API_KEY> with your API key for Etherscan. Under your Etherscan account settings, find the “API Keys” section. Generate one API key using the Free Plan.

This is what the hardhat.config.js file looks like:

require('@nomicfoundation/hardhat-toolbox');

/** @type import('hardhat/config').HardhatUserConfig */
module.exports = {
  solidity: {
    version: '0.8.19',
    settings: {
      evmVersion: 'london',
    },
  },
  networks: {
    'mode': {
      url: 'https://sepolia.mode.network',
      chainId: 919,
      accounts: ['<MY_PRIVATE_KEY>'],
      gasPrice: 10000,
    },
  },
  etherscan: {
    apiKey: {
      mode: '<ETHERSCAN_API_KEY>',
    },
    customChains: [
      {
        network: 'mode',
        chainId: 919,
        urls: {
          apiURL: 'https://sepolia.explorer.mode.network/api\?',
          browserURL: 'https://sepolia.explorer.mode.network',
        },
      },
    ],
  },
};

Step 3: Deploying and Verifying Contracts

Deploy the Contract

In your terminal, run the following command:

npx hardhat run scripts/deploy.js --network mode

Ensure you have enough funds in your account to pay for Gas. You can grab some test tokens from the Faucet to test your contracts before deploying to the mainnet.

Once your smart contract has been successfully deployed, we can now proceed to verify the contract using the contract address.

Verify the contract

In your terminal, run the verify task, passing the address of the contract, the network where it's deployed, and the constructor arguments that were used to deploy it (if any):

npx hardhat verify --network mode DEPLOYED_CONTRACT_ADDRESS "Constructor argument 1"

Where DEPLOYED_CONTRACT_ADDRESS is the contract of your deployed smart contract. Also, replace "Constructor argument 1" (keep the quotes) with the arguments you passed to your smart contract when deploying.

If you are using complex constructor arguments, reference the following Hardhat Documentation.

Conclusion

Congratulations! In this guide, we’ve covered how to verify smart contracts on Blockscout with Hardhat using the hardhat-verify plugin that simplifies the process. Verifying smart contracts is a crucial step in the deployment process because it allows the community to review the source code before usage, thereby promoting transparency and trust within the community.

What's Next:

Check out these other resources from the Mode C00perators:

How To Register a Smart Contract to the SFS with Foundry

Mode — Fri, 10 May 2024 16:50:00 +0000

Foundry is an Ethereum development platform that provides tools for managing your dependencies, testing, running, and deploying your project. It also allows you to interact with your project from the command line.

In this tutorial, you’ll learn how to register our smart contract to the Mode SFS contract with Foundry.

Prerequisites

Before you continue with this tutorial you should:

Have Foundry Installed
Bridge Sepolia Eth with Mode Network.
Have an Ethereum wallet preferably Metamask Installed.
A basic understanding of Solidity.

The Register Function in the SFS contract

Mode’s SFS contract lets developers get some percentage of the transaction fees from their contracts' activities on the Mode network. For this to work, your smart contract has to be registered to Mode’s SFS contract. Once registered, you get an ERC 721 NFT (Non-Fungible Token) which allows you to claim your share of the transaction fees generated from your contract.

To register, your smart contract must call the SFS contract's register function. Let’s look at the register function to understand how it works.

Note that this is only a portion of the SFS contract, check here to see the complete code.

function register(address _recipient) public onlyUnregistered returns 
(uint256 tokenId) {

   address smartContract = msg.sender;

// Check if the recipient address is valid; revert if it's null
   if (_recipient == address(0)) revert InvalidRecipient();

// Generate a unique tokenId, mint an NFT to the recipient with it, and update    
//the tracker
   tokenId = _tokenIdTracker.current();
   mint(recipient, tokenId);
   _tokenIdTracker.increment();
   emit Register(smartContract, _recipient, tokenId);

// Update the fee recipient mapping for the smart contract, associating it with 
//the tokenId and registration details
   feeRecipient[smartContract] = NftData({
       tokenId: tokenId,
       registered: true,
       balanceUpdatedBlock: block.number
   });

}

This function receives _recipient as an input and then mints an NFT to this recipient once your smart contract is registered.

Then, the msg.sender is picked up as the contract to register in the SFS updating the mapping with relevant information.

Here are a few things to note;

The function is specified public meaning an external smart contract can call it.
The msg.sender is assumed to be a smart contract address, ensuring that a smart contract can register a fee recipient.
The function mints an ownership NFT that allows the owner to claim fees earned by the recipient smart contract.

Now that we’ve understood how the register function works, let’s set up our project.

1. Creating your Project

To Initialize a new project with Forge open up your terminal and run;

$ mkdir mode-project 
$ cd  mode-project 
$ forge init

This creates a project structure, you can configure it according to your taste but for this tutorial, we would be sticking with the default structure and only make minor changes to our file.

2. Writing your Contract

We won’t be making use of Openzepplin in this tutorial, but because you’d be making use of it frequently I’d give you the steps. Apply if you want to add it to your project.

Install the Openzeppelin library inside your project by running;

$ forge install openzeppelin/openzeppelin-contracts

This would add the openzeppelin library to the lib/openzeppelin-contracts directory and you can make use of it with a simple import.

Note: For Forge to find this dependency you have to create a remappings.txt file at the top level of your project.

Add this line to the file

@openzeppelin/=lib/openzeppelin-contracts/

With that said, head to the src folder and replace the contract with this one. Also, don’t forget to delete the test file.

// SPDX-License-Identifier: UNLICENSED
pragma solidity ^0.8.13;
contract Register {
  function register(address _recipient) public returns (uint256 tokenId) {}
}
contract ModeTest {
  uint public value;

  constructor(uint _initialValue) {
      value = _initialValue;
      Register sfsContract = Register  (0xBBd707815a7F7eb6897C7686274AFabd7B579Ff6);
      sfsContract.register(msg.sender);
  }
  function updateValue(uint _newValue) public {
      value = _newValue;
  }
}

3. Compiling your Contract

To compile your contract simply run;

$ forge build

4. Deploying your Contract

To deploy your contract run;

mode-project % forge create --rpc-url https://sepolia.mode.network \ 
--constructor-args 100 \ 
--private-key <Your Private Key> src/Mode.sol:ModeTest

The constructor args was added because we have to provide arguments for our constructor.

Replace the private key completely with your private key, it should return something like this.

[⠑] Compiling…

No files changed, compilation skippedDeployer: 0x08755B4d595AFA790d760CF499778f8ff610607EDeployed to: 0x1a06b0ba12Bb0568c7BDEEf1e4573Dd78C74544fTransaction hash: 0x95b9fbd23bdc9513cb089a64287b87e1642508f2fcc123b3c6a4dbe0c5cd3e1b

Congratulations! You just deployed and registered your contract with Foundry.

Check the Explorer

To view your transaction head to Mode Testnet and paste the contract address. Your contract should be assigned to the NFT tokenId. To verify if you assigned your contract correctly, you can check our “Check the registry” guide.

To import the NFT to your wallet, check our Adding the SFS NFT to your wallet tutorial.

How to Verify Smart Contracts on BlockScout with Hardhat

Mode — Fri, 10 May 2024 11:54:00 +0000

Verifying a smart contract on Blockscout makes the contract source code publicly available and verifiable, which creates transparency and trust in the community.

This guide will walk you through verifying a smart contract on Blockscout with Hardhat.

Prerequisites

Before you begin the steps in this guide, please ensure you have the following:

You should have a Hardhat project initialized on your machine.
An Etherscan Account. Don't have one? go to Etherscan and sign up for an account.

Verifying the Smart Contract using Hardhat

Step 1: Install the `Hardhat-Verify` Plugin

The hardhat-verify plugin helps you verify the source code for your Solidity contracts.

In your project directory, install hardhat-verify

npm install --save-dev @nomicfoundation/hardhat-verify

And add the following statement to your hardhat.config.js:

require("@nomicfoundation/hardhat-verify");

Or, if you are using TypeScript, add this to your hardhat.config.ts:

import "@nomicfoundation/hardhat-verify";

Step 2: Configure Hardhat

Add the following configuration to the config object in hardhat.config.js.

 etherscan: {
    // Your API key for Etherscan
    // Obtain one at https://etherscan.io/
    apiKey: {
      mode: '<ETHERSCAN_API_KEY>',
    },
    customChains: [
      {
        network: 'mode',
        chainId: 919,
        urls: {
          apiURL: 'https://sepolia.explorer.mode.network/api\?',
          browserURL: 'https://sepolia.explorer.mode.network',
        },
      },
    ],
  },

Replace <ETHERSCAN_API_KEY> with your API key for Etherscan. Under your Etherscan account settings, find the “API Keys” section. Generate one API key using the Free Plan.

This is what the hardhat.config.js file looks like:

require('@nomicfoundation/hardhat-toolbox');

/** @type import('hardhat/config').HardhatUserConfig */
module.exports = {
  solidity: {
    version: '0.8.19',
    settings: {
      evmVersion: 'london',
    },
  },
  networks: {
    'mode': {
      url: 'https://sepolia.mode.network',
      chainId: 919,
      accounts: ['<MY_PRIVATE_KEY>'],
      gasPrice: 10000,
    },
  },
  etherscan: {
    apiKey: {
      mode: '<ETHERSCAN_API_KEY>',
    },
    customChains: [
      {
        network: 'mode',
        chainId: 919,
        urls: {
          apiURL: 'https://sepolia.explorer.mode.network/api\?',
          browserURL: 'https://sepolia.explorer.mode.network',
        },
      },
    ],
  },
};

Step 3: Deploying and Verifying Contracts

Deploy the Contract

In your terminal, run the following command:

npx hardhat run scripts/deploy.js --network mode

Ensure you have enough funds in your account to pay for Gas. You can grab some test tokens from the Faucet to test your contracts before deploying to the mainnet.

Once your smart contract has been successfully deployed, we can now proceed to verify the contract using the contract address.

Verify the contract

In your terminal, run the verify task, passing the address of the contract, the network where it's deployed, and the constructor arguments that were used to deploy it (if any):

npx hardhat verify --network mode DEPLOYED_CONTRACT_ADDRESS "Constructor argument 1"

If you are using complex constructor arguments, reference the following Hardhat Documentation.

Conclusion

What's Next:

Check out these other resources from the Mode C00perators:

Exploring the ModeNetwork Universe

Mode — Thu, 09 May 2024 14:46:58 +0000

Since I first delved into the world of Mode Network blockchain, every step I've taken has been an exciting adventure filled with learning and discovery. As I progressed on my journey, I found myself increasingly fascinated by the potential and possibilities that this technology offers.

In Search of "The Mode"

My first steps into Mode Network were exciting and full of curiosity. Initially, the multitude of resources I managed to gather, from articles to instructional videos, to understand the fundamentals of this technology and its benefits, might seem overwhelming. Each new piece of information I absorbed brought me closer to understanding how this decentralized network works and its promise of improvement through cooperation. This undoubtedly reminded me of the ubuntu philosophy "I am what I am because of what we all are."

Diving into Mode Network

Driven by deep curiosity and a passion for learning, I decided it was time to fully immerse myself in the Mode Network ecosystem. I superficially explored the complexities that could arise from smart contracts, asset tokenization, and the inherent security of this technology. Each new concept I learned opened new doors of possibilities and encouraged me to continue on my journey of discovery.

One of the most valuable resources for the path I was taking was the technical documentation, although I know nobody likes it, sometimes there comes a time in life when you have to do it.

By the way, I leave it here 👉 Technical Documentation

In the midst of my exploration, I found my first inspiration in Mode's transformative potential. It was then that the idea of creating an application that would allow the community to support projects in a decentralized way through small donations was born. This vision became my guide as I embarked on the development of my first dapp on the Mode Network blockchain.

Getting to Work

Well, with a clear vision in mind, it was time to get to work. I opened the documentation and so I started the development of my donations application on the Mode Network blockchain.

Every line of code I wrote was a small step towards realizing my super idea. I wrote the smart contract, a donation function here, a withdrawal function there, a small deployment with remix, SFS registration, and voila, the smart contract was complete and ready to be implemented.

Just for this occasion, I won't overwhelm anyone with too much code, however, I will leave the link to the contract I used for that dev who is curious 👉 Contract used

It was very interesting to understand that with just an NFT (plus all the work of the Mode Team) I could have the opportunity to obtain benefits as a developer. That reward system design. Wow, the work they have done from Mode!

And I, for my part, was also giving it my all and there was finally my promised NFT.

After this, I felt much more motivated. I continued with a small front.

After hard work and dedication, the time came for "The Big Launch".

With a heart full of excitement and nervousness, I shared my creation with the Mode Network community.

The first reactions were positive and I received the support and validation I had been looking for. I know it's still not the application that will change the world, but for me, it marked an important milestone on this journey, in search of "The Mode".

Would you like to try it? You can do it by entering here: Generosity in action

What's next?

Looking ahead, as I celebrate my achievements, I can't help but be excited about what the future holds for the world of Mode Network.

My journey is far from over, and I'm eager to continue exploring new opportunities and contributing to the growth of this fascinating ecosystem. Every day is a new opportunity to learn, grow, and create in Mode.

If anything from this journey should stay in your mind, I hope it's the excitement for knowledge and the curiosity to continue exploring and creating passionately in this world.

I leave you my social networks in case you want to collaborate on this or another project, or if you want to contribute with ideas, improvements, or simply want to improve your networking, feel free to contact me.

Github: AKAwolfcito
Twitter: AKAwolfcito
Discord: @@akawolfcito

Click here to see the original article in Spanish.

How to get the Developer Role on the Mode Discord Server

Mode — Tue, 30 Apr 2024 19:26:47 +0000

If you are a developer building on Mode, you have the opportunity to get access to an exclusive role in the Mode Discord server, granting access to a private chat to get support, connect, and build your network.

This guide offers step-by-step instructions to get access to the Developer role.

It only takes 2 minutes!

Claiming the Developer Role

Open Discord and navigate to the Mode Discord Server.

Click on the Mode Network Server options available on the Upper Left Corner of the Screen to reveal a dropdown list.

Select Linked Roles in the options menu.

A Modal with the linked roles will appear. Select Developer from the options. You will be prompted to connect to your GitHub account.

Once you’ve successfully connected your GitHub account, you will be granted the Developer role.

Congratulation! You now have access to the developer-exclusive channel. Feel free to ask questions, share what you are building, and connect with other builders.

DEV Community: Mode

How to Deploy and Verify a Smart Contract on Mode's Blockchain using Foundry

Prerequisites:

Environment Setup:

Writing the Smart Contract:

Smart Contract Compilation:

Introducing Strateg: The Yield Infrastructure Layer

What is Strateg?

What can I do with Strateg?

Conclusion

Splice Finance: Your Key to Superior DeFi Yields

Introduction

What is Splice Finance?

How Does Splice Finance Work?

Markets

Portfolio

Swap

What can you do in Splice Markets section?

Markets

Here’s an example explanation of the Market screenshot below:

What can you do in the Splice Portfolio section?

Portfolio

Swap

How to Swap Tokens on Splice Finance

Benefits of Swapping on Splice Finance

What are the key tokens and concepts of Splice and how can you benefit with them?

What are Splice Tokens :

Splice Concepts:

Strategies to Optimize Investment Yields on Splice (NFA):

What is the Yield Trading Concept?

Why use Splice Finance?

When to Use Splice Finance?

Getting Started with Splice Finance

Conclusion

Introducing Houdini Swap; A Privacy first cross-chain liquidity aggregator

What is Houdini Swap?

How does it work?

How to make use of Houdini Swap

Why Choose Houdini Swap

Optimism Retro Funding Round 4: All you need to know

Optimism Retro funding

Key Dates

What are the Eligibility Criteria?

What would you be rewarded for?

How do you apply?

Resources

Introducing Molend: the Pioneering Lending Protocol on Mode Network

How To Setup a Multi-Signature Wallet with Safe (prev. Gnosis Safe) on Mode

What is Gnosis Safe?

Why is MultiSigs Important?

How to create a Safe wallet on Mode

How Protofire is Bringing Safe to the Superchain

What’s Next?

How to Verify Smart Contracts on BlockScout with Hardhat

Prerequisites

Verifying the Smart Contract using Hardhat

Step 1: Install the Hardhat-Verify Plugin

Step 2: Configure Hardhat

Step 3: Deploying and Verifying Contracts

Conclusion

What's Next:

How To Register a Smart Contract to the SFS with Foundry

Prerequisites

The Register Function in the SFS contract

1. Creating your Project

2. Writing your Contract

3. Compiling your Contract

4. Deploying your Contract

Check the Explorer

How to Verify Smart Contracts on BlockScout with Hardhat

Prerequisites

Verifying the Smart Contract using Hardhat

Step 1: Install the Hardhat-Verify Plugin

Step 2: Configure Hardhat

Step 3: Deploying and Verifying Contracts

Conclusion

What's Next:

Exploring the ModeNetwork Universe

How to get the Developer Role on the Mode Discord Server

Claiming the Developer Role

Step 1: Install the `Hardhat-Verify` Plugin

Step 1: Install the `Hardhat-Verify` Plugin