Gelato Automate SDK

Create automated task executions using our typescript SDK:

NPM Package

npm: @gelatonetwork/automate-sdknpm

How to use

Install automate-sdk:

yarn add @gelatonetwork/automate-sdk

Import AutomateSDK:

import { AutomateSDK } from "@gelatonetwork/automate-sdk";

Instantiate the SDK with your signer:

const automate = new AutomateSDK(chainId, signer);

Use createTask to automate your function calls:

interface CreateTaskOptions {
  name: string;             // your task name

  // Function to execute
  execAddress: string;      // address of your target smart contract
  execSelector: string;     // function selector to execute on your target smart contract
  execAbi?: string;         // ABI of your target smart contract

  // Proxy caller
  dedicatedMsgSender: boolean;  // task will be called via a dedicated msg.sender which you can whitelist (recommended: true)

  // Optional: Pre-defined / static target smart contract inputs
  execData?: string;        // exec call data 
  
  // Optional: Dynamic target smart contract inputs (using a resolver)
  resolverAddress?: string; // resolver contract address
  resolverData?: string;    // resolver call data (encoded data with function selector)
  resolverAbi?: string;     // your resolver contract ABI

  // Optional: Time based task params
  interval?: number;        // execution interval in seconds
  startTime?: number;       // start timestamp in seconds or 0 to start immediately (default: 0)
  
  // Optional: Single execution task
  singleExec?: boolean;     // task cancels itself after 1 execution if true.
  
  // Optional: Payment params
  useTreasury?: boolean;    // use false if your task is self-paying (default: true)
}

const params: CreateTaskOptions = { name, execAddress, execSelector, interval };
const { taskId, tx }: TaskTransaction = await automate.createTask(params);

Examples

Deploy a contract & automate your function call:

// Deploying Counter contract
const counterFactory = await hre.ethers.getContractFactory("Counter");
const counter = await counterFactory.deploy(GELATO_ADDRESSES[chainId].automate);
await counter.deployed();

// Call Counter.increaseCount(42) every 10 minutes
const  { taskId, tx }: TaskTransaction = await automate.createTask({
  execAddress: counter.address,
  execSelector: counter.interface.getSighash("increaseCount(uint256)"),
  execData: counter.interface.encodeFunctionData("increaseCount", [42]),
  execAbi: counter.interface.format("json") as string,
  interval: 10 * 60, // execute every 10 minutes
  name: "Automated counter every 10min",
  dedicatedMsgSender: true
});​

Use a resolver contract to automate your function call:

If you need more configurable execution condition and/or dynamic input data, you can create a task using a resolver function (learn how to write a resolver).

// Prepare Task data to automate
const counter = new Contract(COUNTER_ADDRESSES, counterAbi, signer);
const resolver = new Contract(COUNTER_RESOLVER_ADDRESSES, counterResolverAbi, signer);
const selector = counter.interface.getSighash("increaseCount(uint256)");
const resolverData = resolver.interface.getSighash("checker()");

// Create task
const { taskId, tx }: TaskTransaction = await automate.createTask({
  execAddress: counter.address,
  execSelector: selector,
  resolverAddress: resolver.address,
  resolverData: resolverData,
  name: "Automated counter using resolver",
  dedicatedMsgSender: true
});

Enable dedicated msg.sender:

To have a custom msg.sender that you can whitelist on your contract, you can enable the dedicatedMsgSender flag.

// Prepare Task data to automate
const counter = new Contract(COUNTER_ADDRESSES, counterAbi, signer);
const resolver = new Contract(COUNTER_RESOLVER_ADDRESSES, counterResolverAbi, signer);
const selector = counter.interface.getSighash("increaseCount(uint256)");
const resolverData = resolver.interface.getSighash("checker()");

// Create task
const { taskId, tx }: TaskTransaction = await automate.createTask({
  execAddress: counter.address,
  execSelector: selector,
  resolverAddress: resolver.address,
  resolverData: resolverData,
  dedicatedMsgSender: true,
  name: "Automated counter using resolver",
});

// Get dedicated proxy address to whitelist
const { address, isDeployed } = await automate.getDedicatedMsgSender()

More examples in our Hello World repository:

GitHub - gelatodigital/automate-sdk-hello-world: Create Hello World tasks using Gelato Ops SDKGitHub