Forem: Gelato Network

Introducing Gelato Relay: A Fast & Reliable Multichain Transaction API

Gelato Network — Mon, 16 May 2022 18:23:22 +0000

One of the most exciting topics in web3 lately has been P2E Games, Metaverse, and social media applications. Projects such as ZED Run, Decentraland, or Aave’s Lens Protocol have taken the industry by storm and showcased how smart contracts can be used to create novel applications that will drive the next big wave of web3 adoption.

However, unfortunately for most end-users today, despite the recent hype, many applications still lack user-friendly onboarding and interaction experiences. Most new users are not crypto veterans, yet still they get exposed to having to deal with all the quirks that blockchains such as Ethereum demand to understand from its users.

For example, in order to get onboarded onto a P2E gaming application, users are required to complete the following steps before even being able to try out the game:

1. Set up a wallet such as MetaMask
2. Configure the right rpc for each network
3. Purchase or bridge the blockchains native token (e.g. ETH on Ethereum)
Potentially purchase the dApps’ native token
Potentially purchase some in-game avatar / equipment / skin
For every smart contract interaction, configure the right gas price and resubmit transactions in case they get stuck

Once a user is fully onboarded to the dApp, oftentimes they are required to interact with a blockchain for any action they have to perform by submitting transactions. In order to create and execute transactions, they need to pay gas fees. If the user does not have a sufficient balance of the network token or their transaction got stuck because there was a sudden gas price spike, they do not have the option to try out the application altogether which leads to high bounce rates for projects.

There is so much user friction with the conventional dApp architecture that it is difficult for dApps like games or metaverse projects to attract & offer friendly user experiences.

Enter Gelato Relay: A Fast & Reliable Transaction API

Gelato Relay is a new service built on top of the Gelato Network, which helps web3 application and infrastructure developers to use a simple API in order to get arbitrary transactions mined fast, cost-effective and reliable on behalf of their users or protocol. This new feature enables use cases such as gasless transactions which solve common UX problems such as the need to switch between multiple networks or worry about stuck transactions.

How Gelato Relay Works

The goal of the Gelato Relay SDK is to abstract away all the complexities of EVM based blockchain networks which include:

Chain Reorgs
Providers unresponsive
Providers returning errors
Providers out of sync with the chain
Txs underpriced
Txs stuck in mempool
Txs overpriced (max gas price)
Nonce already used
Dealing with multiple transaction types on different networks
Keeping up to date with underlying blockchain changes

This is achieved by enabling dApp developers to access Gelato’s decentralized Executor network to not only accept deferred transactions (i.e. conditional or recurring) through services like Gelato Ops, but also facilitate the relaying of instant transactions which need to be mined right away.

Developers can simply define a) a smart contract address, b) a payload (e.g. a signed message from a user claiming their funds) and c) a payment methodology and then submit this information to Gelato’s endpoint in order for the network to get the transaction mined instantly.

Features

Flexible payment methods: Sponsoring gas fees for users, letting users pay within the transaction themselves with a broad range of tokens, and allowing approve / transferFrom payments

Reliable transaction execution: Transactions get confirmed faster, more securely, and with optimized gas costs
No single point of failure: Transactions are executed by Gelato’s decentralized Executor Network rather than by a centralized node run by the projects development team
Multichain: Gelato Relay supports over 10 different EVM chains, including Ethereum, Polygon, BNB, and many more
Privacy by default: If the dApp is on Ethereum, transactions will be submitted via Flashbots, thus ensuring greater transaction privacy and offering MEV protection
Time and cost savings: Outsourcing all the heavy lifting of creating, running, and maintaining the required infrastructure, developers can minimize infrastructure bills as well as required development time

Gelato Relay empowers developers to focus on what is truly important: building the best possible product and focusing on their users, rather than having to waste time running the required infrastructure needed to get transactions mined reliably on all EVM-based networks.

Example #1: P2E games

For example, let’s imagine a P2E game where users can participate in car races. Rather than having to manually send transactions themselves and pay the underlying gas costs to participate in a certain race, users can instead a) sign a message off-chain and b) send that signed message via Gelato’s Relay SDK to Gelato’s Executor Network which then get the transaction mined fast and reliably on the specified network.

Gelato Executors pay the required gas fees and can get reimbursed in a variety of different payment modes. On top of the gas fee they pay on each transaction, Gelato gets to charge a small fee as an incentive.

Example #2: Bridges & cross-chain messaging protocols

Besides gaming, another segment that greatly benefits from Gelato Relay is infrastructure projects such as bridges. The job of bridges is to reliably move assets between as many chains as possible. This requires a reliable transaction execution service that will enable users to lock their funds on one chain and claim them on the other.

By relaying transactions across multiple chains using a single API, Gelato Relay offers bridges the scalability, liveness, and efficiency they need in order to offer seamless and near-instant interactions to their users.

In fact, one of web3’s most used bridges, Connext, has been using Gelato Relay since 2021 in production and has processed over 1.25 million transactions on over 5 different EVM-based blockchains in a reliable and cost-effective fashion.

Gelato Relay can not only be used to merely transfer assets but to execute arbitrary transactions, meaning cross-chain messaging protocols like LayerZero or Nomad can also adopt the service to further decentralize and improve the robustness of their protocol.

Get started!

Documentation for how to get started can be found here. If you have questions, don’t hesitate to reach out to us on Discord.

--
For more about Gelato: https://gelato.network/

What is a smart contract resolver, when do you need it, and how to write a resolver?

Gelato Network — Sun, 03 Apr 2022 11:45:44 +0000

A resolver is a smart contract in which developers can embed their logic of "when" an execution should occur and what data should executors use for the execution. Gelato will query these resolvers periodically to check if it is time to execute.

You need a resolver if

You want to define the conditions of "when" Gelato should execute your task.
You want to have different arguments for the function you are automating on each execution.

You do not need a resolver if

You simply want to repeatedly call a smart contract function with the same or without arguments (e.g. every 1 hour).
If you just want Gelato to try to execute a particular function in case it does NOT revert

Watch the tutorial:

--
Automate your smart contracts on Gelato Ops: https://app.gelato.network/

How To Automate Your Smart Contracts Using Gelato

Gelato Network — Sat, 05 Mar 2022 11:10:13 +0000

When it comes to smart contracts, most of people assume that they are already built with automation. Actually, smart contracts are not smart enough.

The reason for this lack of automation lies in the Ethereum Virtual Machine (EVM) itself: programs only run for a few milliseconds at a time; persistent loops or “cron” jobs that constantly repeat themselves, typical in traditional operating systems, limit a miner from ever completing the state transition and thus mining a block.

As a result, these programs, called smart contracts, are limited to only storing state and logic. Without an outside impulse, they are functionally inactive. In order to execute their logic and to change their state, they require an external party to send a transaction to them in the first place.

Learn how to automate your smart contract in a 5-min tutorial video:

And you can find the docs here: https://docs.gelato.network/guides/tutorial

Gelato Network is hiring! Technical content lead, Web3 research analyst, back-end and front-end engineer!

Gelato Network — Sat, 15 Jan 2022 09:54:57 +0000

Gelato Network is a protocol that automates smart contract executions on Ethereum. We develop an open-source decentralized network of relay nodes that developers can plug into to create amazing automated dapps for their users.

Join our growing team and work directly with the founders to build the future of Automation on Ethereum. Enjoy a lot of perks, travel with us to cool events, and participate in amazing off-site retreats with the team!

Technical Content Lead (Remote)

What we offer:

A fully remote team with team members in Zug, Paris, New York, Berlin, and many other cool places
Join the "Gelato Legendary Member Club" and work directly with the founders
Participate in building the infrastructure that aims to become the glue between all crypto networks and power the most promising dapps on Ethereum and beyond
Generous Token Package - Get a share of the network's token and be able to participate in the Gelato DAO
Chance to participate in shaping the future of web3 by working together with the biggest projects in this space, such as MakerDAO, Connext, Quickswap, etc.
Worldclass Investors - We are backed by top class VCs and Angels including Dragonfly, Galaxy Digital, ParaFi, Gnosis, Stani Kulechov and many more!

What you will accomplish:

You will define and execute the content strategy to communicate the benefits of our product offering to the existing and prospective developers across multiple channels, including blog, YouTube, Twitter, Newsletter, Discord, and other editorial and social media channels
You will engage directly with developers in our community and other Web3 developer communities to acknowledge their needs and create educational content such as tutorials and guides to help them succeed
You will be the one that amplifies our voices in the Web3 developer communities
You will work with data to measure the impact and effectiveness of all the content

Our ideal candidate has:

Track record of creating engaging content for the developer audience — you define yourself as a technical content creator
Working knowledge of programming languages such as Solidity
Excellent written and presentation-based communication skills (native or fluent English speaker)
Strong curiosity or understanding of the blockchain landscape (Ethereum, DeFi, etc.)
The basic understanding of how SEO works

Bonus points if you can demonstrate:

You have a growing social media channel like YouTube, Podcast, or Tiktok
You are actively involved with the developer communities
Developer marketing experience in the B2B technology space

If this list gets you pumped, we want to hear from you -- email us at jobs@gelato.digital

More job openings: https://recruitcrm.io/jobs/Gelato_Network_careers

Introducing Gelato Ops: Web3’s Multi-Chain Smart Contract Automation Hub

Gelato Network — Wed, 17 Nov 2021 19:45:09 +0000

TL;DR:

Gelato Ops enables web3 developers to automate tasks via an easy-to-use interface
Example use cases that are already live include: harvesting yield vaults every day, paying out rewards daily, topping up contract balances, or petting Aavegotchis every 12 hours
0% fees until the end of 2021

Using Gelato Ops, developers can input the contract address and function they want to automate, when they want to automate it, and how they will pay for it. Having submitted this information as a “task”, it will be picked up by Gelato Executors and executed at the right time. Developers can monitor past transactions, manage their budget, and debug their tasks. Payments can be in the network token (ETH, MATIC, or FTM) and soon with other tokens, including DAI or USDC.

Successful Gelato Ops Beta

Gelato Ops is already in use by some of the most innovative projects in DeFi, NFTs, and gaming:

QiDAO for harvesting rewards and compounding them daily
B.Protocol for executing arbitrage trades
Unicly for creating and distributing daily rewards to stakers
Parcel for automating salary payouts for DAOs
Staking Facilities for topping up different addresses once they go below a certain threshold
ETHA Lend for harvesting their vaults
GotchiCare for petting Aavegotchi NFTs every 12 hours

Plus many more awesome projects…

Instead of manually triggering functions or having to build and monitor their own bot infrastructure, developers can rely on Gelato Ops to automate any arbitrary task on most EVM-based blockchains. Gelato Ops will be live on Ethereum, Polygon, Fantom, and Arbitrum — with more networks to come.

Check out the video on YouTube and read the tutorial on how you can create tasks on the Gelato Ops.

--
Docs: https://docs.gelato.network/

How to Automate Your Smart Contract Executions Using Gelato🍦

Gelato Network — Tue, 10 Aug 2021 13:09:43 +0000

If you have ever written a smart contract, you would know that it is impossible to have a smart contract execute a certain function on its own under a specified condition e.g. make a sell order when the price of Ethereum moons. Well to achieve that, you have to build your own bot which monitors on-chain activities and then have it send transactions. But building a bot that performs these functions for you requires a lot of work and developer resources that can instead be allocated to optimizing your smart contract or going out for a walk from your super shadowy basement 🙊 Apart from that, you have to run your bot on a server, monitor it daily… all that fun stuff.

So here is the solution — Continue to prioritize your focus on building awesome smart contracts without having to run the underlying infrastructure that leaves you susceptible to becoming the central point of failure. Let Gelato do the work for you.

🏃‍♂️ Starting Off

Let’s say you already have a smart contract deployed. And you want Gelato to call the smart contract at a certain time. All you need to do is to deploy a resolver contract which will tell Gelato.

“Hey call this function here at every hour”

Here is an example of the function buy() which we want Gelato to call. This function buys ETH through Uniswap V2.

uint256 public lastBought;

function buy(
    uint256 amountIn,
    uint256 amountOutMin,
    address[] calldata path,
    address to,
    uint256 deadline
  ) external {
    require(block.timestamp >= lastBought + 1 hours);
    IERC20(path[0]).approve(address(router), amountIn);
    router.swapExactTokensForETH(
           amountIn, 
           amountOutMin, 
           path, 
           to,     
           deadline
    );
    lastBought = block.timestamp;
  }

Here is an example of a resolver contract. checker() returns true when it has been at least an hour past lastBought. This will prompt Gelato to call the buy() function mentioned above.

contract Resolver {
  address public immutable owner;
  ISwap public immutable swap;
  address WETH = 0xC02aaA39b223FE8D0A0e5C4F27eAD9083C756Cc2;
  address USDT = 0xdAC17F958D2ee523a2206206994597C13D831ec7;
constructor(address _swap) public {
    owner = msg.sender;
    swap = ISwap(_swap);
  }
function checker()
    external
    view
    returns (bool canExec, bytes memory execPayload)
  {
    address[] memory path = new address[](2);
    path[0] = USDT;
    path[1] = WETH;
    uint256 deadline = block.timestamp + 10 minutes;
    uint256 lastBought = swap.lastBought();
    if (lastBought >= 1 hours) {
       bytes4 selector =                                                        
       bytes4(keccak256(
           "buy(uint256,uint256,address[],address,uint256"));
       execPayload = abi.encodeWithSelector(
         selector,
         1000 ether,
         0,
         path,
         owner,
         deadline
       );
     canExec = true;
     return (canExec, execPayload);
    }
  }
}

Gelato calls this checker() off-chain at every block. If canExec returns true, executors will send a transaction with execPayload.

To get more information on how to write a resolver contract, take a look at the docs

👷‍♂️ Creating A Task

Once you have your resolver contract deployed, you are already halfway done. Now you would need to submit a task. Gelato makes submitting tasks super easy with the PokeMe UI.

1. Visit the PokeMe webpage

Here you can see your current tasks and balance.

2. Click on Submit Task

There are two fields to be filled manually here.

Execution address — Address of the function you want Gelato to call.
Resolver address — Address of your resolver deployed previously.

When you input the execution addresses, a list of functions will appear for you to choose from.

3. Choose the function which you want Gelato to call

Make sure to have your contract verified on Etherscan / Polygonscan or you would have to do it manually.

The same thing applies to the resolver address.

Choose the function which Gelato will call off-chain to check if the bots should execute.
Submit your task!

On your dashboard, you can see all the tasks you have submitted.

Clicking into the task, you will be able to see more details and all the previous executions of the task.

🤑 Deposit Funds

Once you have submitted your task, the final step is to deposit some funds which will be used to pay executors for executing your transactions.

Deposit some ETH or MATIC depending on the network of your smart contracts:

Your balance will then appear on the dashboard.

🎊 All Done

You are all set up! Gelato will now monitor your smart contract and execute when your specified conditions are met!

Gelato PokeMe is available on Ethereum mainnet, Ropsten, and Polygon

Here are the contract addresses!

Introducing Gelato’s Limit Order Library: DEX (Limit) Sells

Gelato Network — Tue, 13 Jul 2021 08:23:47 +0000

Although commonplace on Centralized Exchanges, Limit Orders have yet to reach wide adoption from Decentralized Exchange platforms. The reason DEX UIs have been lagging behind on implementing this feature is deeply rooted in the limitations of the EVM that make it hard to automate users' trades while also upholding DeFi’s core tenet of being non-custodial.

Gelato now sets out to obliterate this barrier for Decentralized Exchange developers with our brand new limit-orders-lib and limit-orders-react npm package releases. These two libraries provide an easy one-stop solution for developers to hook up native Limit Orders to their AMM or other DEX of choice — in as little as 10 minutes! The smart contract components of the limit order system have been audited by Certik. The spectrum of tooling the library provides you with ranges from ready-made React Components for the quickest go-live imaginable, to React Hooks and, on the more customizable end, simple methods for interacting with the underlying Gelato Limit Order infrastructure. The library already works with well-known trading venues on Ethereum, Polygon, and Fantom. Soon BSC and Layer 2s like Arbitrum will also be supported.

If you have any questions or you'd like to build with Gelato, we're here to help!

--
Read more —> Gelato Network Medium

Gelato Network is HIRING

Gelato Network — Wed, 23 Jun 2021 07:32:17 +0000

We're looking for Senior Front End Developer and Back-End / Relay Node Engineer!

What we offer:

Small, fully remote team with an office in Zug Switzerland (in case you don’t want to work remotely)
Be one of the first employees and work directly with the founders
Build the next generation of automated services on Ethereum and Layer 2 networks and become an expert in the most cutting edge UX standards of dapp development
Work together closely with industry leading teams that we team up with to deliver the most innovative products in the DeFi industry
Token Options
Get a share of the networks future tokens and be able to participate in Gelato’s upcoming DAO

Requirements:

As a Senior Front End Developer, you have:

4 years experience with React.js, Vue.js or similar front-end frameworks
3 years experience Graph QL
3 years experience with Typescript
Strong CSS skills
Experience with web3 libraries (ethers.js, web3.js)
Experience with testing your code on Ethereum test networks
You can work with high autonomy
Strong written and verbal communication skills

Bonus:

Strong Design skills
Experience with Solidity

As a Back-End / Relay Node Engineer, you have:

4 years experience with node.js and typescript
Experience in building reliable software infrastructure with Node.js & Typescript
Experience with web3 libraries (ethers.js, web3.js)
Experience with testing your code on ethereum test networks
DevOps experience - ideally experience with deploying code that interacts with Ethereum mainnet
You can work with high autonomy
Strong written and verbal communication skills

Bonus:

Knowledge about the inner workings of the EVM
Experience with Solidity
Experience in building and running bots that interact with smart contracts on Ethereum
Knowledge about Ethereum Client & Mining software

If that's you, please apply HERE and we can't wait to chat with you!

-
Gelato Network is a protocol that automates smart contract executions on Ethereum and beyond. We develop an open-source decentralized network of relay nodes that developers can plug into to create amazing automated dapps for their users.

G-UNI, an automated liquidity provision ERC-20 for Uniswap v3, powered by Gelato

Gelato Network — Thu, 17 Jun 2021 18:03:06 +0000

Automated Market Maker (AMM) protocols such as Uniswap have earned their place as the central primitive of DeFi. In a sense, Uniswap is the “townsquare of tokens”, and provides an easy-go-to arena for users who are looking to exchange them in a completely trustless and decentralized manner.

Through the simple formula of x * y = k, Uniswap v2 allowed anyone to become a market maker and benefit from fees generated from trades and potential yields spouting from yield farming schemes in distant pastures in the DeFi universe. Users provided liquidity across a single curve from 0 to infinity. The benefits of this lies in its simplicity and fungibility, users can just set and forget and receive LP tokens in ERC-20 form making them composable with the money legos of DeFi, for example leading to them being used as collateral in lending protocols such as Aave, MakerDAO.

The benefits of Uniswap v1 and v2 can be summarized by:

Simplicity: Having a simple one size fits all liquidity strategy making market making very accessible for everyone as users don’t have to actively manage their position
Fee Compounding: Reinvesting the earned trading fees back into the pool resulting in an automated compounding effect
Fungibility: One Uniswap LP token is equal to another, meaning they can be used as money legos in other protocols such as Aave or Maker for collateral, making the underlying capital hyper-efficient

Yet, having a pair of tokens populate infinitely along a curve means only a small minority of them are actually being utilized to provide liquidity around the current price at any given moment, with the vast majority sitting idle for most of the time. In order to solve this dilemma and to get the most out of every token that is being provisioned for liquidity, Uniswap took it upon themselves to step up their AMM game by optimizing capital efficiency. The result of this premise was Uniswap v3 which takes liquidity provisioning to a whole new level.

How Uniswap v3 works is that rather than putting all tokens on the same curve, users decide the price range they want to provide liquidity for and deposit them in positions filled with “ticks”. An example of this is for an ETH-DAI pair, you may decide to provide liquidity only between $2,500-$3,000 DAI worth of ETH. The result is much higher fee generation in that range since the liquidity provision is much more concentrated. Yet the trade-offs for this efficiency is more risk for impermanent loss. The price of ETH is likely to escape your LP range, leaving you rekted without any of the benefits of fee accumulation. In addition, because of the way v3 is structured, LP tokens are now NFTs making them much less composable with other DeFi protocols.

Because of the complexity of v3, it leaves many everyday DeFi participants at a disadvantage. Many won’t have the time to keep track of their position or will be unwilling to pay the transaction costs to rebalance their position. So how do we make v3 accessible to all?

Enter G-UNI, an automated liquidity provision ERC-20 for Uniswap v3, powered by Gelato. G-UNI combines the capital efficiency of Uniswap v3 with the simple user experience of Uniswap v2 by enabling users to simply deposit their funds in a G-UNI ERC-20 that manages their liquidity on Uniswap v3 automatically on their behalf.

G-UNI Features:

Makes Uniswap v3’s non-fungible liquidity positions fungible, enabling liquidity to be used as money legos in other DeFi protocols
Automatically reinvests earned fees back into Uniswap to achieve a compounding effect Manages the ranges between which liquidity should be provided to always provide concentrated liquidity around the current market price
Being ERC-20s, G-UNI tokens can be used for liquidity mining schemes to incentivize holders to provide concentrated liquidity around certain price ranges

G-UNI tokens are also very flexible and can be used for passive and active liquidity management. Passive G-UNIs work by just providing very broad liquidity, similar to Uniswap v2 that never has to be changed. It thus can be completely free of anyone’s control as it does not require changes in its price range.

On the other hand, active G-UNI’s will always target providing liquidity as efficiently as possible around e.g. 5%-10% above or below the current trading price, but still in a completely trustless and automated fashion. This is achieved by having Gelato bots monitor the average price and every 30 minutes will decide to rebalance only if the average trading price is outside the current bounds of the position. If that is the case, rebalancing happens, and the position is withdrawn and redeposited with the proper adjustment to the new trading price.

The advantage of this includes that users can sit back and relax as all the difficulties that come with monitoring LP positions are taken care of. In addition, since G-UNI is an ERC-20, it has the capability of being composable with other protocols. This will come in handy when future protocols decide to implement v3 yield farms.

In fact, one of our closest partners, Instadapp, has just launched their liquidity mining scheme utilizing G-UNI. Within the first 8 hours, over $2M were deposited in the passive INST / WETH G-UNI token, making the G-UNI ERC-20 the largest liquidity provider for INST on Uniswap.

UNI v3 has already grown to be the highest decentralized exchange by volume and redefines what it means to be a liquidity provider. Gelato is there to empower users every step of the way.

--
Gelato Network is a protocol that automates smart contract executions on Ethereum and beyond. We are building the underlying infrastructure enabling reliable automation on top of Ethereum and with it a key part of the Web3 middleware stack, enabling trustless, automated flows of value between all smart contracts and upcoming Layer 2 networks.

Introducing Gelato V2, The Most Reliable Way To Automate Your Ethereum Smart Contracts

Gelato Network — Wed, 14 Apr 2021 15:56:28 +0000

TL;DR 👇

Using Gelato v2, web3 developers can build “service” smart contracts that define certain transactions that Executors (bots in the Gelato Network) monitor and automatically execute on behalf of projects and their users.
Gelato v2 enables a wide variety of operations ranging from limit orders to dollar-cost averaging to refinancing one’s debt position to avoid liquidation.
Gelato acts as a single entry point for the execution of these transactions. The whole system coordinates a decentralized network of bots and ensures that those bots only charge fair market rate gas fees based on actual gas consumed and the Chainlink fast gas price.
Bots are coordinated using “slots” and only execute transactions when it is their “turn” in order to avoid racing conditions while guaranteeing maximum efficiency.

What’s New with Gelato Network V2?

1) Each dapp can define its own custom interface
Whereas Gelato v1 imposed a “one size fits all” way of having developers communicate with Executors, v2 is significantly more flexible and opens the possibilities for an infinite number of implementations of how that communication is happening. Developers still do not have to reinvent the wheel and only have to write minimal smart contract code, because we came up with several “Service Standards”, which compose a standard set of functions and modifiers developers can use to automate certain functions on their dapps. More standards, tailored to specific sets of use cases, will be released shortly.

2) No need for proxy contracts
Whether services that are powered by Gelato v2 require a proxy contract or not is completely up to the developers’ to decide. This is no longer a requirement and there are a number of use cases that are already in development that will save users significant gas costs down the line by not requiring a proxy contract per user.

3) Off-chain data generation resulting in significant gas savings
Executors can implement custom logic off-chain that enables them to compute arbitrary data and pass those to smart contracts services, which save a substantial amount of gas that was previously used to fetch certain data on-chain. This capability also opens the door to more interesting use cases like off-chain conditions where data is not available on-chain, but more on that soon!

4) No pre-deposits and pay for transactions with any token you want
Transactions pay for themselves as long as Gelato is paid an amount equal or higher to what it pays out to its network of executors. In practice, a transaction can hence swap e.g. DAI to USDC on Uniswap, and send part of that received USDC to Gelato to pay for the transaction fee and the rest to the user.

5) Ability to submit tasks via Meta transactions
One pain point of Gelato v1 was that tasks had to be submitted on-chain, which meant that before anything got executed, users already had to pay for some gas (even if not that much). V2 supports meta transactions which means that users only have to sign a message off-chain that will be passed to the “Gelato Service Relayer” from which Executors can query the available tasks in order to execute them. This part will be controlled and maintained by the Gelato Core team for now and will be decentralized in the near future.

6) Coordinating bots so they don’t front-run each other
The problem with all “keeper” systems today is that they use gas price auctions in order to decide which bot will end up executing transactions. This results in a significant loss in value that leaks to miners. In the Gelato Network, Executors are coordinated by a soft off-chain coordination mechanism that allocates “slots” to different Executor operators. In those slots, these Executors are the only ones who can execute the tasks of a particular service. If an executor goes offline or fails to serve a specific slot, it will be kicked from the network. In the future, staking and slashing will add even more incentives for executors to abide by the rules and keep a constant uptime for their servers.

We envision Gelato v2 as an ever-changing and improving networked service for developers that will constantly adapt in order to guarantee the automation of transactions in a reliable and efficient manner. Most of the security-related code was externalized into the service contracts and thus services can be assured that even if Gelato is maliciously taken over, their services are safe. For this reason, we choose to implement Gelato v2 using the Diamond Standard, otherwise known as EIP-2535. The upgradable protocol is secured by a multisig controlled by the Gelato Core development team, however, there are already concrete plans to transition this control over to the upcoming GelatoDAO, which will launch in Q2 this year.

Gelato’s v2 was built to complement next-generation protocols like Uniswap v3, which leads to a lot of features open-ended for third parties to build out. For instance, Gelato can automate a variety of functions of Uniswap v3, including reinvesting fees back into the pool, converting LP NFTs into wrapped ERC-20s, and automating LP price ranges.

As demand for smart contracts automation increases in the DeFi ecosystem, there is an even greater need for a cost-efficient and more flexible off-chain solution. That is why we launch Gelato v2 to help and empower the developers to build unstoppable DeFi dapps.

--
If you have any questions or need help to get started, please reach out to us in our Telegram community or email us at hi@gelato.digital.

We are looking forward to building with you!