Comment on page

Set Actions

Set Lit Action Code.
The setActions method let's you add custom, contract and fetch actions that are executed by the nodes on the Lit Network. These actions are only invoked if the conditions set in setConditions are met.
When invoking this method, you provide an array of actions that you want to set. The setActions returns the Lit Action code as a string that will be executed on the Lit Nodes and an unsignedTransactionDataObject that is only populated when instantiating ContractActions.
This is an asynchronous method, make sure to use await.
If undefined is passed to either of the gasLimit, maxPriorityFeePerGas or maxFeePerGas fields they will be calculated internally as the transaction is simulated. If you'd like more control over these fields please pass in correctly calculated values.
If you're transaction requires approval or funding of the PKP Wallet before it's broadcast, these values must be passed in manually. This is necessary due to the transaction simulation process, to obtain the expected gas price, which occurs prior to the minting of the PKP.
Before Lit.Action.executeJS is called with each run of the Circuit the nonce value for ContractActions will be recalculated by invoking getTransactionCount() on the provider.
If you are sending any value along with the Contract Action, make sure that it is specified correctly in wei.
import { FetchAction, ContractAction } from "lit-listener-sdk"
const fetchAction: FetchAction = {
type: "fetch", // type
priority: 1, // execution priority
baseUrl: "", // baseUrl
endpoint: "/data", // endPoint
responsePath: "data.value", // responsePath
apiKey: "your_api_key", // apiKey
toSign: [72, 101, 108, 108, 111, 32, 87, 111, 114, 108, 100], // toSign
signCondition: [
type: "&&",
operator: "==",
value: "expected_value",
], // signCondition
const contractAction: ContractAction = {
type: "contract", // type
priority: 2, // execution priority
contractAddress: "0x6968105460f67c3bf751be7c15f92f5286fd0ce5", // contract address
abi: [
constant: true,
inputs: [{ name: "numberValue", type: "uint256" }],
name: "your_function_name",
outputs: [{ name: "", type: "uint256" }],
payable: false,
stateMutability: "external",
type: "function",
], // abi
functionName: "your_function_name", // function name
chainId: "polygon", // chainId
providerURL: "" // provider URL
nonce: 1, // nonce
gasLimit: 100000, // gas Limit
value: 0, // value
maxPriorityFeePerGas: 1000, // max priority gas fee
maxFeePerGas: 10000, // max fee per gas
args: [20], // function arguments
const {unsignedTransactionDataObject, litActionCode} = await newCircuit.setActions(
To easily generate the unsigned transaction data that is passed to executeJS (signed by your PKP) for Contract Actions, you can invoke the asynchronous LitListenerSDK helper function generateUnsignedTransactionData.
import { generateUnsignedTransactionData, CustomAction, CHAIN_NAME, LitUnsignedTransaction } from "lit-listener-sdk";
const unsignedTransactionArgs = await newCircuit.generateUnsignedTransactionData({
chainId: CHAIN_NAME.polygon,
abi: [
constant: false,
inputs: [
name: "_value",
type: "uint256",
name: "setValue",
outputs: [],
payable: true,
stateMutability: "nonpayable",
type: "function",
contractAddress: "0x6968105460f67c3bf751be7c15f92f5286fd0ce5",
nonce: 2, // optional param
gasLimit: "21000", // optional param
maxFeePerGas: "10000000000", // optional param
maxPriorityFeePerGas: "1", // optional param
from: "{{publicKey}}",
functionName: "setValue",
args: [5],
value: "1000000000000000000", // optional param
}, "")
const customFunction = `async () => {
try {
const hashTransaction = (tx) => {
return ethers.utils.arrayify(
await LitActions.signEcdsa({
toSign: hashTransaction(unsignedTransactionArgs),
publicKey: publicKey,
sigName: sigName,
Lit.Actions.SetResponse({response: "Transaction Signed Successfully."});
} catch (err) {
console.log('Error thrown on signing transaction.', err)
const customAction: CustomAction = {
type: "custom",
priority: 0,
code: customFunction
args: {
const { litActionCode } = newCircuit.setActions([customAction]);
Contract Action Parameters:
If the from address passed to a ContractAction is left blank it will be populated with the minted PKP Address during execution of the Lit Action.
import { CHAIN_NAME, } from "lit-listener-sdk";
import { InterfaceAbi } from "ethers";
/* The type of the action, always "contract" for this interface.*/
type: "contract";
/* A numerical value representing the priority of the action. The lower the
value, the higher the priority.*/
priority: number;
/* The Ethereum address of the smart contract with which to interact.*/
contractAddress: `0x${string}`;
/* The ABI (Application Binary Interface) of the smart contract, which
describes its functions and events.*/
abi: InterfaceAbi;
/* The name of the smart contract function to call.*/
functionName: string;
/* The compatible blockchain network chainId. Import
CHAIN_NAME from lit-listener-sdk*/
chainId: CHAIN_NAME;
/* The provider URL for the indicated network.*/
providerURL: string;
/* The transaction nonce.*/
nonce?: number;
/* The transaction gas limit.*/
gasLimit?: BigNumberish;
/* Any value to be passed with the transaction.*/
value?: BigNumberish;
/* The address from which the transaction as called. This will usually be the PKP address.*/
from?: `0x${string}` | {{publicKey}};
/* The max priority fee per gas for the transaction.*/
maxPriorityFeePerGas?: BigNumberish;
/* The max fee per gas for the transaction.*/
maxFeePerGas?: BigNumberish;
/* An array of arguments to pass to the function call.*/
args?: any[];
Fetch Action Parameters:
/* The type of the action, always "fetch" for this interface.*/
type: "fetch";
/* A numerical value representing the priority of the action. The lower the value, the higher the priority. */
priority: number;
/* The base URL of the API endpoint. */
baseUrl: string;
/* The specific endpoint to fetch. */
endpoint: string;
/* The path to access the expected value in the response body.*/
responsePath: string;
/* Optional API key for authorization.*/
apiKey?: string;
/* The data to sign. If left blank the response returned from the API will be signed. */
toSign?: Uint8Array;
/* The condition under which to sign the data.*/
signCondition?: {
type: "&&" | "||";
operator: "<" | ">" | "==" | "===" | "!==" | "!=" | ">=" | "<=";
| number
| string
| bigint
| string[]
| number[]
| bigint[]
| undefined
| (string | number | bigint)[];
Custom Action Parameters:
When creating a CustomAction and invoking a Lit Action to sign unsigned transaction data you will need to pass in the unsigned transaction data as an argument, however you do not need need to include the PKP PublicKey, PKP Address or Auth Signature as arguments as these parameters are passed to Circuit.start()
/* The type of the action, always "custom" for this interface.*/
type: "custom";
/* A numerical value representing the priority of the action. The
lower the value, the higher the priority.*/
priority: number;
/* A function string representing the custom action to be performed. This
function is defined by the user.*/
code: string;
/* The type of the action, always "custom" for this interface.*/
args?: Object;