Getting Started

IMPORTANT: Docs are a work in progress and will continue to improve.

xKeeper is a keeper network aggregator which aims to decentralise the on-chain automation of DeFi. With xKeeper, using multiple keeper networks, such as Keep3r Network, Gelato, or others, will be a walk in the park.

xKeeper is a fully modular framework, designed to be the backbone of future onchain automation.

• App: xkeeper.network

Repositories

• Core Contracts
• Web Application

Deployments Addresses

Ethereum Mainnet

OP Mainnet

Ethereum Sepolia

OP Sepolia

Licensing

The primary license for xKeeper is AGPL-3.0

Contributors

XKeeper was built with ❤️ by Wonderland.

Wonderland is the largest core development group in web3. Our commitment is to a financial future that's open, decentralized, and accessible to all.

DeFi sucks, but Wonderland is here to make it better.

xKeeper

Why xKeeper?

xKeeper offers a powerful solution for on-chain automation. Here's why you should consider using it:

• Simplicity: With the assistance of our relays and vault, you'll be able to easily manage automation for your contracts, and the payment process will be smoother than ever before.

• Versatility: xKeeper is built to be compatible with various keeper services, including Keep3r, Gelato, Autonolas, and others. You have the freedom to choose the keeper that best fits your requirements.

• Public Good: We're committed to contributing to the blockchain community by offering xKeeper as an open and free resource, promoting automation and efficiency across the ecosystem.

Join us in simplifying on-chain automation with xKeeper.

How to use

As a first step into xKeeper usage, we recommend you:

1. Create your first Automation Vault
2. Enable the OpenRelay
3. Enable the GelatoRelay
4. Enable the Keep3rRelay

Here you can also find some additional technical guides:

1. How to create Relay exec data

Create your first Automation Vault

An Automation Vault serves as the home for your on-chain automations.

Within your vault, you can activate various automation networks (for example, Gelato) and select specific tasks they are authorized to perform.

In order to pay for your onchain automation, you can deposit ETH or any ERC20 into your vault.

Let's go ahead and try all this out.

Step 1: Deploy your vault

First, navigate to xkeeper.network in your browser. Once there, connect your wallet and select the testnet of your choosing.

Next, click the "Create Vault" button and follow the shown steps.

Well done! You now have created your first Automation Vault 🥳.

Step 2: Add metadata

Adding a name and description to your vault will make it easier for bots to identify and execute your jobs. Ensure that your description is comprehensive, detailing all the necessary information for task execution.

A compelling metadata entry looks something like this:

Name: My Protocol

Description: Automation of My Protocol reward and distribute jobs. Automation scripts can be found here: https://github.com/my-protocol/automation-scripts.

Now, give it a try and add some metadata to your new vault.

Step 3: Add balance

To prepare your vault for task execution, deposit the necessary funds to cover associated costs.

As an example, let's add some ETH to it. Using your preferred wallet, send ETH to the address of your new Automation Vault.

Step 4: Setup your relays and jobs

Relays act as bridges between your vault and various automation networks. For instance, you can enable the Keep3rRelay for Keep3r's network or the GelatoRelay for Gelato's services within your vault.

The OpenRelay is a unique exception; it doesn't connect to a specific automation network. Instead, it allows any bot to execute your on-chain tasks, compensating them directly with ETH. This approach is particularly attractive to MEV Searchers and contributes significantly to the decentralization of your tasks.

Upon enabling a relay, you also define which tasks it can carry out.

To complete the setup, enable one or more of the following relays in your vault:

• Open Relay
• Gelato Relay
• Keep3r Relay

Enable the GelatoRelay on your Vault

🚧 Prerequisite: Please ensure you have completed the Automation Vault setup before proceeding.

The Gelato Relay enables you to connect Gelato Network to the array of automation networks in xKeeper.

Gelato offers differentiated incentives depending on the chain being used.For comprehensive details, refer to their documentation.

Step 1: Add the relay in your vault

Inside your vault, find and click "Add New Relay," then choose Gelato Relay from the list.

In the Callers section of the window that appears, you will need to approve the dedicated msg.sender from Gelato. You can find your dedicated msg.sender inside Gelato settings.

Next, in the Jobs section, input the details of your job. For this guide, we will use a sample job we've made available on all testnets:

Job Address: 0x129f5C4Adf38a1860e54DE46970653465A605364

Selectors to allow:

• work (0x322e9f04)

Now proceed by confirming in order to submit the transaction.

Step 2: Create the task inside Gelato

Open your web browser and navigate to Gelato. Connect your wallet and click on "Create task".

For the purposes of this guide, we'll apply the following settings:

• Time Interval: 5 minutes
• Start Immediately: true
• Trigger: Solidity function

In the trigger settings:

• Solidity Function
  • Network: Testnet of your choosing.
  • Contract Address: Smart contract with integrated checker. We will use a simple one deployed by us for this guide: 0x6F3f27a48Da92100Bc1b34c1FAA5e268f4bDdFDe.
• Target Smart Contract
  • Contract Address: Address of your job. For this guide, we will use a sample job we've made available on all testnets: 0x129f5C4Adf38a1860e54DE46970653465A605364.

Lastly, in the "Task Properties" section under "Advanced Settings" toggle on "Transaction pays itself" to ensure the transaction costs are covered onchain through your Automation Vault.

You can learn more about each setting by visiting Gelato documentation.

Step 3: Verify execution

After the first work transaction is included onchain, you will be able to find its details under the Activity tab if your vault.

Enable the Keep3rRelay on your Vault

🚧 Prerequisite: Please ensure you have completed the Automation Vault setup before proceeding. For this relay, the selected chain must be Ethereum Sepolia.

The Keep3r Relay allows you to connect the Keep3r Network to an array of automation networks within xKeeper. The Keep3r Network currently provides an incentive of 120% of gas costs to keepers. For in-depth information about the Keep3r Network, please consult their documentation.

Moreover, the Keep3r Relay introduces an opportunity for job owners to leverage Keep3r Liquidity Provider Tokens (kLPs) for their tasks. These tokens, minted to liquidity providers within the network's pools, accrue KP3R credits over time, which can then be utilized for automation payments. The process is detailed further in the Credit Mining Docs.

Step 1: Add the relay in your vault

Inside your vault, find and click "Add New Relay," then choose Keep3r Relay from the list.

In the Callers section of the window that appears, activate the "Allow any caller" option to permit any address to execute your job. Remember that only valid keepers will be able to run your job.

Then, in the Jobs section, provide your job's specifics. For this tutorial, we'll use a sample job available on all testnets:

Job Address: 0x129f5C4Adf38a1860e54DE46970653465A605364

Selectors to allow:

• work (0x322e9f04)

Additionally, for this relay's operation, it's crucial to authorize the isKeeper and worked functions from Keep3r v2 for executing payments:

Job Address: 0xf171B63F97018ADff9Bb15F065c6B6CDA378d320 (Keep3rV2)

Selectors to allow:

• isKeeper (0x6ba42aaa)
• worked (0x5feeb794)

Continue by confirming the transaction.

Step 2: Register your Automation Vault as a Keep3r Job

Open keep3r.network in your web browser, connect your wallet, and click on "Register Job" using your Automation Vault's address.

Step 3: Acquire kLPs

Since kLPs are backed by WETH and KP3R, acquiring these underlying tokens is a prerequisite for minting kLPs.

• To obtain WETH: Utilize the WETH deposit function to convert 0.01 ETH.
• To acquire KP3R: Use the KP3R mint function to mint 100,000 KP3R (100000000000000000000000).

Afterward, navigate to your job on keep3r.network and mint kLPs with the KP3R and WETH you've acquired.

Step 4: Deposit kLPs into your vault

Access your job on keep3r.network and in the "Add liquidity" section, enter the amount of previously minted kLPs. Proceed by selecting "Add liquidity to job" and confirming the transaction.

This will commence the automatic generation of KP3R credits. Please note, it may take up to an hour to accumulate sufficient credits to commence your job.

Step 5: Work your job for the first time

While only validated keepers can execute tasks, testnet testing simplifies the keeper registration process.

Visit keep3r.network, connect your wallet, and select "Bond". Confirm the transaction, without the need of adding KP3R, effectively validating your keeper status.

While this process is typically automated, we'll manually trigger the job via Etherscan for demonstration purposes. Visit the Keep3rRelay in Etherscan and execute the exec function with the specified parameters.

Let's gather the needed information:

_automationVault

Your vault's address.

_execData

This encapsulates the encoded function signature of your job and its parameters. A typical _execData example is as follows:

[{ "job": "<JOB_ADDRESS>", "jobData": "<JOB_DATA>" }]

Continue using the testnet sample job address: `0x129f5C4Adf38a1860e54DE46970653465A605364`.

To generate the job data, we will use [chisel](https://book.getfoundry.sh/chisel/):

```bash
> chisel
> bytes32(abi.encodeWithSignature("work()"))

Type: bytes32
└ Data: 0x322e9f0400000000000000000000000000000000000000000000000000000000

For alternative methods to generate _execData, refer to Relay exec data.

Step 6: Verify execution

After the first work transaction is included onchain, you will be able to find its details under the Activity tab if your vault.

Enable the OpenRelay on your Vault

🚧 Prerequisite: Please ensure you have completed the Automation Vault setup before proceeding.

The OpenRelay is a fundamental yet potent relay system. It precisely calculates the gas used for executing your job within its smart contract, reimbursing the executor in ETH for the gas costs, plus an additional incentive.

Current incentive: 120% of the gas costs, paid out in ETH instantaneously.

Step 1: Enable the relay in your vault

Inside your vault, find and click "Add New Relay," then choose Open Relay from the list.

In the Callers section of the window that appears, activate the "Allow any caller" option to permit any address to execute your job.

Next, in the Jobs section, input the details of your job. For this guide, we will use a sample job we've made available on all testnets:

Job Address: 0x129f5C4Adf38a1860e54DE46970653465A605364

Selectors to allow:

• work (0x322e9f04)

Now proceed by confirming in order to submit the transaction.

Step 2: Generate exec parameters

Execution of jobs through Relays requires specific data for the exec function on the Open Relay.

Jobs should always be executed through Relays. In this case, we need to generate the data needed to call the exec function on the Open Relay.

Let's gather the needed information:

_automationVault

Your vault's address.

_execData

This encapsulates the encoded function signature of your job and its parameters. A typical _execData example is as follows:

[{ "job": "<JOB_ADDRESS>", "jobData": "<JOB_DATA>" }]

Continue using the testnet sample job address: 0x129f5C4Adf38a1860e54DE46970653465A605364.

To generate the job data, we will use chisel:

> chisel
> bytes32(abi.encodeWithSignature("work()"))

Type: bytes32
└ Data: 0x322e9f0400000000000000000000000000000000000000000000000000000000

For alternative methods to generate _execData, refer to Relay exec data.

_feeRecipient

The ETH fee recipient, typically the wallet executing the job.

Step 3: Work your job for the first time

While this process is usually automated, we'll manually execute the job through Etherscan for demonstration purposes.

Visit the Etherscan page for your chosen testnet and locate the OpenRelay address listed on your vault's homepage.

Then, under the Write Contracts tab, input the parameters prepared in Step 2 and confirm the transaction.

Step 4: Verify execution

After your work transaction is included onchain, you will be able to find its details under the Activity tab if your vault.

How to Generate execData

The exec function shared by every Relay requires a specific argument: IAutomationVault.ExecData[] calldata _execData. This guide covers the process of generating this essential data component.

How can you generate that exec data?

Structure of _execData

The _execData is a collection that includes the encoded function signature of your job along with its parameters. Here’s how the _execData looks like:

[{ "job": "<JOB_ADDRESS>", "jobData": "<JOB_DATA>" }]

Generating Job Data with chisel

Prerequisite: Ensure you have Foundry installed.

To generate your job data, execute the following commands in your terminal:

> chisel
> abi.encodeWithSignature("work(uint256)", 420)

Type: dynamic bytes
├ Hex (Memory):
├─ Length ([0x00:0x20]): 0x0000000000000000000000000000000000000000000000000000000000000024
├─ Contents ([0x20:..]): 0x5858d16100000000000000000000000000000000000000000000000000000000000001a400000000000000000000000000000000000000000000000000000000
├ Hex (Tuple Encoded):
├─ Pointer ([0x00:0x20]): 0x0000000000000000000000000000000000000000000000000000000000000020
├─ Length ([0x20:0x40]): 0x0000000000000000000000000000000000000000000000000000000000000024
└─ Contents ([0x40:..]): 0x5858d16100000000000000000000000000000000000000000000000000000000000001a400000000000000000000000000000000000000000000000000000000 <-- YOUR NEEDED DATA

Grab the Contents field of the result, and use that as your <JOB_DATA>.

Generating Job Data with ethers.js

For those who use JavaScript, ethers.js provides a straightforward method to obtain your job data. Below is an example:

abi = ["function work(uint256 _someData)"];
iface = new ethers.utils.Interface(abi);
encodedData = iface.encodeFunctionData("work", [420]);

> "0x5858d16100000000000000000000000000000000000000000000000000000000000001a4"

Try copy pasting the previous lines of code in the Ethers Playground to see the expected output.

Grab the value of encodedData, and use that as your <JOB_DATA>.

Core Contracts

The core contracts of the xKeeper project are the backbone of the framework. They can be used to generate new vaults, manage balances and approve and revoke permissions for callers and relays.

Core Contracts

• The AutomationVault contract manages on-chain job execution with relays, streamlining payment and serving as a core component in user-friendly on-chain automation.

• The AutomationVaultFactory contract is responsible for deploying new instances of automation vaults.

For more detailed information about each contract, please refer to the respective documentation pages.

For more technical details about the interfaces of the core contracts, please refer to the Interfaces section in the technical documentation.

⚠️ Please note that the code has not been audited yet, so use it with caution.

Automation Vault

The AutomationVault contract is designed to facilitate the management of job execution with various relays and the payment of these relays for their services. The contract operates as a core component in the realm of on-chain automation. It provides a robust and user-friendly solution for defining and executing tasks while ensuring that payments are handled in a more straightforward manner.

Key Features

• Relay and Job Management: The AutomationVault contract allows users to manage approved relays and jobs efficiently. It maintains a list of approved relays and jobs, providing control over who can perform specific tasks.

• Simplified Payment Handling: Payment management has been simplified, allowing payments to be made in a more user-friendly manner. It supports both Ether (ETH) and ERC-20 tokens, ensuring that fees for job execution are processed seamlessly.

• Ownership Control: The contract incorporates ownership management to ensure control over its functions. The owner has the authority to approve or revoke relays, callers, and selectors.

• Multichain Support: The xKeeper core allows to configure the automation vaults for several chains. The native token is configurable for any automation vault.

• Flexibility: Users have the freedom to add or remove relays and select specific functions to be executed by jobs, granting them greater control over their automation processes.

Automation Vault Factory

The AutomationVaultFactory contract is specifically designed to handle the deployment and management of automation vaults within the on-chain automation ecosystem. As a factory, it plays a crucial role in streamlining the creation of new automation vaults, each serving as a dedicated entity for job execution, relay management, and payment processing.

Key Features

• Efficient Deployment: The primary function of the factory is to efficiently deploy new instances of automation vaults. This allows users to manage automation tasks, associated relays and handle balances.

• Automation Vaults Listing: Enables users to retrieve a list of deployed automation vaults, allowing for efficient tracking and monitoring.

Relays Contracts

Relay contracts in the xKeeper project play a key role in facilitating automated task executions from different networks. Each of these contracts provides specialized solutions to optimize task execution and manage the associated payments.

Relays Contracts

• The Keep3rRelay: Orchestrates and executes tasks efficiently, ensuring a harmonious automation process within the Keep3r network.

• The Keep3rBondedRelay: Introduces dynamic bonding requirements for automation vaults, enhancing security by validating tasks with bonded keepers.

• The GelatoRelay: Acts as a centralized hub for managing and executing tasks from the Gelato network, streamlining automation processes.

• The OpenRelay: Manages and facilitates the execution of tasks from various bots, ensuring efficient automation processes and fee payments.

For more detailed information about each contract, please refer to the respective documentation pages.

For more technical details about the interfaces of the relays contracts, please refer to the Interfaces section in the technical documentation.

⚠️ Please note that the code has not been audited yet, so use it with caution.

Keep3r Relay

The Keep3rRelay is meticulously crafted to orchestrate and streamline task executions from the Keep3r network, offering a cohesive solution for efficient automation processes and fee payments.

Key Features

• Task Coordination: The contract seamlessly coordinates task executions with an AutomationVault, ensuring a harmonious and streamlined automation process.

• Keeper Authorization: Validation mechanisms guarantee that only authorized keepers within the Keep3r network can initiate and execute tasks, enhancing security and control.

• Optimized Execution Array: The contract intelligently creates an array of executions, encompassing crucial steps such as keeper validation, injected execution data, and issuance of payments upon successful task completion.

• Event Transparency: Upon successful execution, the contract emits the AutomationVaultExecuted event, providing transparent insights into executed tasks and relay activities.

Keep3r Network

The Keep3rRelay combines task coordination, keeper validation, and event transparency to deliver a robust solution for streamlined automation processes within the Keep3r network. This design prioritizes efficiency, security, and user-friendly task execution.

Keep3r Bonded Relay

The Keep3rBondedRelay contract efficiently manages executions originating from the Keep3r network when the job is bonded. This contract introduces bonding requirements for automation vaults, ensuring task executions are performed by legitimate bonded keepers.

Key Features

• Dynamic Bonding Requirements: The contract introduces flexible bonding requirements for automation vaults. Vault owners can set specific bonding parameters, such as the required bond, minimum bond, earned rewards, and age, ensuring customizable security measures.

• Bonding Requirement Configuration: Through the setAutomationVaultRequirements function, automation vault owners can dynamically configure bonding requirements. This feature grants control over the security measures necessary for task execution.

• Task Execution with Bonded Keepers: The contract efficiently executes tasks with bonded keepers, validating their bonding status based on the configured requirements. This ensures that only legitimate bonded keepers can initiate and complete tasks.

• Event Emission: Upon successful execution, the contract emits the AutomationVaultExecuted event. This event provides transparency into executed tasks, including details on the associated automation vault and the executed data.

Keep3r Network

The Keep3rBondedRelay contract introduces a novel approach by incorporating dynamic bonding requirements for automation vaults. This design enhances security and control, allowing vault owners to customize bonding parameters and ensuring task executions are carried out by validated bonded keepers.

Gelato Relay

The GelatoRelay contract, serves as a central hub for managing and executing tasks originating from the Gelato network, contributing to seamless automation processes and fee payments.

Key Features

• Task Execution Coordination: The contract, in collaboration with the Gelato network, coordinates and executes tasks efficiently, ensuring a smooth and reliable automation process.

• Automation Vault Interaction: This interaction centralizes multiple tasks within a single relay, streamlining the management of various tasks and their associated payments in a single function call. This feature enhances efficiency and reduces the complexity of task management, allowing users to handle multiple tasks simultaneously.

• Event Transparency: Upon successful execution, the contract emits the AutomationVaultExecuted event, providing transparent insights into executed tasks and relay activities.

Gelato Network

The GelatoRelay contract seamlessly integrates with the Gelato network, offering a robust solution for the execution of automated tasks while maintaining transparency in fee calculations and execution events.

Open Relay

The OpenRelay is designed to manage and facilitate the execution of tasks coming from various bots, ensuring efficient automation processes and fee payments.

Key Features

• Gas Management: The contract employs gas management to optimize transaction costs. It calculates the gas spent and provides a gas bonus to ensure that the execution is efficient and cost-effective.

• Automated Fee Calculation: The contract automatically calculates and handles fees for task execution. It uses gas metrics to determine the appropriate payment to be made to the automation vault.

• Seamless Task Execution: The contract allows the execution of tasks within an automation vault. It ensures that all tasks are carried out smoothly, and fees are promptly paid to the designated fee recipient.

• Event Transparency: Upon successful execution, the contract emits the AutomationVaultExecuted event, providing transparent insights into executed tasks and relay activities.

Gas Metrics

• GAS_BONUS: 53,000
• GAS_MULTIPLIER: 12,000
• BASE: 10,000

These gas metrics play a vital role in paying the caller for the work performed.

Peripheral Contracts

Peripheral contracts serve as supportive components that extend the capabilities of the core system. Among these, the XKeeperMetadata contract stands out as a crucial peripheral contract, specifically designed for managing and streamlining metadata associated with automation vaults.

Peripheral Contracts

• The XKeeperMetadata: Manages and organizes metadata for automation vaults within the system, ensuring accurate and secure data handling while enhancing the overall efficiency of metadata management processes.

For more detailed information about each contract, please refer to the respective documentation pages.

For more technical details about the interfaces of the relays contracts, please refer to the Interfaces section in the technical documentation.

⚠️ Please note that the code has not been audited yet, so use it with caution.

XKeeperMetadata

The XKeeperMetadata contract is a pivotal component in managing the metadata associated with automation vaults. It offers a structured and efficient way to handle metadata operations, providing essential features and interactions for users. Automation vaults owners can define all information related with their protocols to provide information about how to work their jobs.

Key Features

• Metadata Management: The contract is primarily focused on handling the metadata of automation vaults, providing a structured and consistent approach to managing information.

• Robust Querying: Users can query metadata for an array of automation vaults simultaneously, ensuring efficient data retrieval and management.

• Secure Metadata Modification: The contract ensures that only the owner of an automation vault can modify its metadata, maintaining the integrity and security of the data.

Contents

• core
• external
• periphery
• relays
• utils

Contents

• IAutomationVault
• IAutomationVaultFactory

IAutomationVault

Git Source

Inherits: IOwnable

Functions

NATIVE_TOKEN

Returns the address of the native token

function NATIVE_TOKEN() external view returns (address _nativeToken);

Returns

getRelayData

Returns the approved relay callers and selectors for a specific relay and job

function getRelayData(address _relay)
  external
  returns (address[] memory _callers, IAutomationVault.JobData[] memory _jobsData);

Parameters

Returns

relays

Returns the approved relays

function relays() external view returns (address[] memory _listRelays);

Returns

withdrawFunds

Withdraws funds deposited in the contract

Only the owner can call this function

function withdrawFunds(address _token, uint256 _amount, address _receiver) external;

Parameters

addRelay

Add a new relay to the automation vault with the desired callers, jobs and selectors

If the relay is valid, it can be passed with all the fields or only the necessary ones, passing the empty argument in the unwanted ones

function addRelay(address _relay, address[] calldata _callers, IAutomationVault.JobData[] calldata _jobsData) external;

Parameters

deleteRelay

Revokes the approval of a specific relay

The callers, jobs and selectors will be deleted

function deleteRelay(address _relay) external;

Parameters

modifyRelay

Modify the callers, jobs and selectors of a specific relay

If any of the arguments is empty, the data will be deleted

function modifyRelay(
  address _relay,
  address[] calldata _callers,
  IAutomationVault.JobData[] calldata _jobsData
) external;

Parameters

modifyRelayCallers

Modify the callers of a specific relay

If the array is empty, the data will be deleted

function modifyRelayCallers(address _relay, address[] calldata _callers) external;

Parameters

modifyRelayJobs

Modify the jobs and selectors of a specific relay

If the array is empty, the data will be deleted, also if the function selectors array is empty

function modifyRelayJobs(address _relay, IAutomationVault.JobData[] calldata _jobsData) external;

Parameters

exec

Executes a job and issues a payment to the fee data receivers

The function can be called with only execData, only feeData or both. The strategy of the payment will be different depending on which relay is calling the function

function exec(address _relayCaller, ExecData[] calldata _execData, FeeData[] calldata _feeData) external;

Parameters

Events

WithdrawFunds

Emitted when funds are withdrawn

event WithdrawFunds(address indexed _token, uint256 _amount, address indexed _receiver);

Parameters

ApproveRelay

Emitted when a relay is approved

event ApproveRelay(address indexed _relay);

Parameters

DeleteRelay

Emitted when a relay is deleted

event DeleteRelay(address indexed _relay);

Parameters

ApproveRelayCaller

Emitted when a relay caller is approved

event ApproveRelayCaller(address indexed _relay, address indexed _caller);

Parameters

ApproveJob

Emitted when job is approved

event ApproveJob(address indexed _job);

Parameters

ApproveJobSelector

Emitted when job selector is approved

event ApproveJobSelector(address indexed _job, bytes4 indexed _functionSelector);

Parameters

JobExecuted

Emitted when a job is executed

event JobExecuted(address indexed _relay, address indexed _relayCaller, address indexed _job, bytes _jobData);

Parameters

IssuePayment

Emitted when a payment is issued

event IssuePayment(
  address indexed _relay, address indexed _relayCaller, address indexed _feeRecipient, address _feeToken, uint256 _fee
);

Parameters

NativeTokenReceived

Emitted when native token is received in the automation vault

event NativeTokenReceived(address indexed _sender, uint256 _amount);

Parameters

Errors

AutomationVault_RelayZero

Thrown when the the relay is the zero address

error AutomationVault_RelayZero();

AutomationVault_RelayAlreadyApproved

Thrown when the relay is already approved

error AutomationVault_RelayAlreadyApproved();

AutomationVault_NativeTokenTransferFailed

Thrown when ether transfer fails

error AutomationVault_NativeTokenTransferFailed();

AutomationVault_NotApprovedRelayCaller

Thrown when a not approved relay caller is trying to execute a job

error AutomationVault_NotApprovedRelayCaller();

AutomationVault_NotApprovedJobSelector

Thrown when a not approved job selector is trying to be executed

error AutomationVault_NotApprovedJobSelector();

AutomationVault_ExecFailed

Thrown when a job execution fails

error AutomationVault_ExecFailed();

Structs

ExecData

The data to execute a job

struct ExecData {
  address job;
  bytes jobData;
}

Properties

FeeData

The data to issue a payment

struct FeeData {
  address feeRecipient;
  address feeToken;
  uint256 fee;
}

Properties

JobData

The data of a job

struct JobData {
  address job;
  bytes4[] functionSelectors;
}

Properties

IAutomationVaultFactory

Git Source

Functions

totalAutomationVaults

Get the total amount of automation vaults deployed by the factory

function totalAutomationVaults() external view returns (uint256 _totalAutomationVaults);

Returns

automationVaults

Get a certain amount of automation vaults deployed by the factory

function automationVaults(uint256 _startFrom, uint256 _amount) external view returns (address[] memory _list);

Parameters

Returns

deployAutomationVault

Deploy a new automation vault

function deployAutomationVault(
  address _owner,
  address _nativeToken,
  uint256 _salt
) external returns (IAutomationVault _automationVault);

Parameters

Returns

Events

DeployAutomationVault

Emitted when a new automation vault is deployed

event DeployAutomationVault(address indexed _owner, address indexed _automationVault);

Parameters

Errors

AutomationVaultFactory_Create2Failed

Thrown when the automation vault factory fails to deploy a new automation vault

error AutomationVaultFactory_Create2Failed();

IBasicJobChecker

Git Source

Functions

checker

This function checks whether the job can be executed by the automation vault

function checker(
  IAutomationVault _automationVault,
  IBasicJob _basicJob
) external pure returns (bool _canExec, bytes memory _execPayload);

Parameters

Returns

Contents

• IKeep3rSponsor
• IXKeeperMetadata

IKeep3rSponsor

Git Source

Inherits: IOwnable

Functions

KEEP3R_V2

Returns the keep3rV2 contract

function KEEP3R_V2() external view returns (IKeep3rV2 _keep3rV2);

Returns

KEEP3R_HELPER

Returns the keep3r helper contract

function KEEP3R_HELPER() external view returns (IKeep3rHelper _keep3rHelper);

Returns

BASE

Returns the base

function BASE() external view returns (uint32 _base);

Returns

bonus

Returns the bonus

The bonus is in base 10_000

function bonus() external view returns (uint256 _bonus);

Returns

openRelay

Returns the open relay

function openRelay() external view returns (IOpenRelay _openRelay);

Returns

feeRecipient

Returns the fee recipient address

function feeRecipient() external view returns (address _feeRecipient);

Returns

getSponsoredJobs

Returns the list of the sponsored jobs

function getSponsoredJobs() external returns (address[] memory _sponsoredJobsList);

Returns

setFeeRecipient

Sets the fee recipient who will receive the payment of the open relay

function setFeeRecipient(address _feeRecipient) external;

Parameters

setOpenRelay

Sets the open relay

function setOpenRelay(IOpenRelay _openRelay) external;

Parameters

setBonus

Sets the bonus

function setBonus(uint256 _bonus) external;

Parameters

addSponsoredJobs

Adds a job to the sponsored list

function addSponsoredJobs(address[] calldata _jobs) external;

Parameters

deleteSponsoredJobs

Removes a job from the sponsored list

function deleteSponsoredJobs(address[] calldata _jobs) external;

Parameters

exec

Execute an open relay which will execute the jobs and will manage the payment to the fee data receivers

function exec(IAutomationVault _automationVault, IAutomationVault.ExecData[] calldata _execData) external;

Parameters

Events

JobExecuted

Emitted when a job is executed

event JobExecuted(address _job);

Parameters

FeeRecipientSetted

Emitted when the fee recipient is setted

event FeeRecipientSetted(address indexed _feeRecipient);

Parameters

OpenRelaySetted

Emitted when the open relay is setted

event OpenRelaySetted(IOpenRelay indexed _openRelay);

Parameters

BonusSetted

Emitted when the bonus is setted

event BonusSetted(uint256 indexed _bonus);

Parameters

ApproveSponsoredJob

Emitted when a sponsored job is approved

event ApproveSponsoredJob(address indexed _job);

Parameters

DeleteSponsoredJob

Emitted when a sponsored job is deleted

event DeleteSponsoredJob(address indexed _job);

Parameters

Errors

Keep3rSponsor_JobNotSponsored

Thrown when the job executed is not in the list of sponsored jobs

error Keep3rSponsor_JobNotSponsored();

Keep3rSponsor_NotKeeper

Thrown when the caller is not a keeper

error Keep3rSponsor_NotKeeper();

Keep3rSponsor_NoJobs

Thrown when the exec data is empty

error Keep3rSponsor_NoJobs();

Keep3rSponsor_LowBonus

Thrown when the bonus is lower than the base

error Keep3rSponsor_LowBonus();

IXKeeperMetadata

Git Source

Functions

automationVaultMetadata

Returns the metadata of the automation vault

function automationVaultMetadata(IAutomationVault _automationVault)
  external
  view
  returns (string calldata _name, string calldata _description);

Parameters

Returns

automationVaultsMetadata

Returns the metadata of the automation vault

function automationVaultsMetadata(IAutomationVault[] calldata _automationVault)
  external
  view
  returns (IXKeeperMetadata.AutomationVaultMetadata[] memory _metadata);

Parameters

Returns

setAutomationVaultMetadata

Sets the metadata of the automation vault

function setAutomationVaultMetadata(
  IAutomationVault _automationVault,
  AutomationVaultMetadata calldata _automationVaultMetadata
) external;

Parameters

Events

AutomationVaultMetadataSetted

Emitted when the metadata of an automation vault is set

event AutomationVaultMetadataSetted(IAutomationVault indexed _automationVault, string _name, string _description);

Parameters

Structs

AutomationVaultMetadata

The metadata of the automation vault

struct AutomationVaultMetadata {
  string name;
  string description;
}

Properties

Contents

• IGelatoRelay
• IKeep3rBondedRelay
• IKeep3rBondedRelayL2
• IKeep3rRelay
• IKeep3rRelayL2
• IOpenRelay

IGelatoRelay

Git Source

Functions

AUTOMATE

Returns the automate contract of the gelato network

function AUTOMATE() external view returns (IAutomate _automate);

Returns

FEE_COLLECTOR

Returns the fee collector of the gelato network

function FEE_COLLECTOR() external view returns (address _feeCollector);

Returns

exec

Execute an automation vault which will execute the jobs and will manage the payment to the fee data receivers

function exec(IAutomationVault _automationVault, IAutomationVault.ExecData[] calldata _execData) external;

Parameters

Events

AutomationVaultExecuted

Emitted when an automation vault is executed

event AutomationVaultExecuted(
  IAutomationVault indexed _automationVault,
  address indexed _relayCaller,
  IAutomationVault.ExecData[] _execData,
  IAutomationVault.FeeData[] _feeData
);

Parameters

IKeep3rBondedRelay

Git Source

Inherits: IKeep3rRelay

Functions

automationVaultRequirements

Get the automation vault bonded requirements

function automationVaultRequirements(IAutomationVault _automationVault)
  external
  view
  returns (address _bond, uint256 _minBond, uint256 _earned, uint256 _age);

Parameters

Returns

setAutomationVaultRequirements

Set the automation vault requirements when bonded job is required

Only the owner of the automation vault can set the requirements

function setAutomationVaultRequirements(
  IAutomationVault _automationVault,
  IKeep3rBondedRelay.Requirements memory _requirements
) external;

Parameters

Events

AutomationVaultRequirementsSetted

Emitted when the automation vault requirements are setted

event AutomationVaultRequirementsSetted(
  IAutomationVault indexed _automationVault, address _bond, uint256 _minBond, uint256 _earned, uint256 _age
);

Parameters

Errors

Keep3rBondedRelay_NotAutomationVaultRequirement

Thrown when the automation vault requirements are not setted

error Keep3rBondedRelay_NotAutomationVaultRequirement();

Keep3rBondedRelay_NotBondedKeeper

Thrown when the keeper doesn't meet the requirements set by the automation vault

error Keep3rBondedRelay_NotBondedKeeper();

Structs

Requirements

The requirements needed when bonded job is required

struct Requirements {
  address bond;
  uint256 minBond;
  uint256 earned;
  uint256 age;
}

Properties

IKeep3rBondedRelayL2

Git Source

Inherits: IKeep3rRelayL2, IKeep3rBondedRelay

IKeep3rRelay

Git Source

Functions

KEEP3R_V2

Get the keep3rV2 contract

function KEEP3R_V2() external view returns (IKeep3rV2 _keep3rV2);

Returns

exec

Execute an automation vault which will execute the jobs and will manage the payment to the fee data receivers

The payment will be managed by keep3r network. The first and last exec data are assembled by the relay in order to be able to work with keep3r network

function exec(IAutomationVault _automationVault, IAutomationVault.ExecData[] calldata _execData) external;

Parameters

Events

AutomationVaultExecuted

Emitted when an automation vault is executed

event AutomationVaultExecuted(
  IAutomationVault indexed _automationVault, address indexed _relayCaller, IAutomationVault.ExecData[] _execData
);

Parameters

Errors

Keep3rRelay_NoExecData

Thrown when the exec data is empty

error Keep3rRelay_NoExecData();

Keep3rRelay_NotKeeper

Thrown when the caller is not a keeper

error Keep3rRelay_NotKeeper();

Keep3rRelay_Keep3rNotAllowed

Thrown when the exec data contains Keep3r V2

error Keep3rRelay_Keep3rNotAllowed();

IKeep3rRelayL2

Git Source

Inherits: IKeep3rRelay

Functions

usdPerGasUnitPerVault

Get the USD per gas unit per automation vault

function usdPerGasUnitPerVault(IAutomationVault _automationVault) external view returns (uint256 _usdPerGasUnit);

Parameters

Returns

setUsdPerGasUnit

Set the USD per gas unit

function setUsdPerGasUnit(IAutomationVault _automationVault, uint256 _usdPerGasUnit) external;

Parameters

Events

UsdPerGasUnitSetted

Emitted when the USD per gas unit is setted

event UsdPerGasUnitSetted(IAutomationVault _automationVault, uint256 _usdPerGasUnit);

Parameters

IOpenRelay

Git Source

Functions

GAS_BONUS

Returns the gas bonus

function GAS_BONUS() external view returns (uint256 _gasBonus);

Returns

GAS_MULTIPLIER

Returns the gas multiplier

function GAS_MULTIPLIER() external view returns (uint256 _gasMultiplier);

Returns

BASE

Returns the base used for the payment calculation

function BASE() external view returns (uint32 _base);

Returns

exec

Execute an automation vault which will execute the jobs and will manage the payment to the fee data receivers

The payment will be calculated on the basis of several variables like the gas spent, the base fee, the gas bonus and the gas multiplier

function exec(
  IAutomationVault _automationVault,
  IAutomationVault.ExecData[] calldata _execData,
  address _feeRecipient
) external;

Parameters

Events

AutomationVaultExecuted

Emitted when an automation vault is executed

event AutomationVaultExecuted(
  IAutomationVault indexed _automationVault,
  address indexed _relayCaller,
  IAutomationVault.ExecData[] _execData,
  IAutomationVault.FeeData[] _feeData
);

Parameters

Errors

OpenRelay_NoExecData

Thrown when the exec data is empty

error OpenRelay_NoExecData();

Contents

• IOwnable
• IOwnableAutomationVault

IOwnable

Git Source

This contract is used to manage ownership

Functions

owner

Returns the owner address

function owner() external view returns (address _owner);

Returns

pendingOwner

Returns the pending owner address

function pendingOwner() external view returns (address _pendingOwner);

Returns

changeOwner

Propose a new owner for the contract

The new owner will need to accept the ownership before it is transferred

function changeOwner(address _pendingOwner) external;

Parameters

acceptOwner

Accepts the ownership of the contract

function acceptOwner() external;

Events

ChangeOwner

Emitted when the owner is proposed to change

event ChangeOwner(address indexed _pendingOwner);

Parameters

AcceptOwner

Emitted when the owner is accepted

event AcceptOwner(address indexed _owner);

Parameters

Errors

Ownable_OnlyOwner

Thrown when the caller is not the owner

error Ownable_OnlyOwner();

Ownable_OnlyPendingOwner

Thrown when the caller is not the pending owner

error Ownable_OnlyPendingOwner();

IOwnableAutomationVault

Git Source

Errors

OwnableAutomationVault_OnlyAutomationVaultOwner

Error when the caller is not the automation vault owner

error OwnableAutomationVault_OnlyAutomationVaultOwner();