sdk-triggerx 0.1.0

package/.eslintrc.json

@@ -0,0 +1,16 @@
+{
+  "parser": "@typescript-eslint/parser",
+  "extends": [
+    "plugin:@typescript-eslint/recommended"
+  ],
+  "env": {
+    "node": true,
+    "es2020": true,
+    "jest": true
+  },
+  "parserOptions": {
+    "ecmaVersion": 2020,
+    "sourceType": "module"
+  },
+  "rules": {}
+} 

package/README.md

@@ -0,0 +1,249 @@
+# 🚀 TriggerX SDK
+
+**SDK for interacting with the TriggerX backend and smart contracts.**  
+Supports job automation on EVM-compatible chains using time, event, or condition-based triggers.
+
+---
+
+## ✨ Features
+
+- 🔧 Easy API integration for job and user management
+- 🔗 Smart contract interaction for job creation and deletion
+- 📅 Supports time-based, event-based, and condition-based jobs
+- 🔐 TypeScript support with clean types
+- 🧠 Dynamic argument fetching via external scripts (e.g., IPFS)
+
+---
+
+## 📦 Installation
+
+```bash
+npm install sdk-triggerx
+```
+
+---
+
+## 🛠️ Usage Guide
+
+### 1. Initialize the Client
+
+```ts
+import { TriggerXClient } from 'sdk-triggerx';
+
+const client = new TriggerXClient('YOUR_API_KEY');
+```
+
+---
+
+### 2. Create a Job
+
+#### Supported Job Types
+
+- `JobType.Time`: Interval or Cron-based triggers
+- `JobType.Event`: Smart contract event-based triggers
+- `JobType.Condition`: API or contract-based conditional triggers
+
+#### Supported Argument Types
+
+- `ArgType.Static`: Hardcoded values
+- `ArgType.Dynamic`: Runtime values fetched from a script
+
+---
+
+#### 🕒 Example: Time-based Static Job
+
+```ts
+import { createJob, JobType, ArgType } from 'sdk-triggerx';
+
+const jobInput = {
+  jobType: JobType.Time,
+  argType: ArgType.Static,
+  userAddress: '0x...',
+  etherBalance: 10000000000000000,
+  tokenBalance: 10000000000000000000,
+  jobTitle: 'My Time Job',
+  timeFrame: 36,
+  scheduleType: 'interval',
+  timeInterval: 33,
+  cronExpression: '0 0 * * *',
+  specificSchedule: '2025-01-01 00:00:00',
+  timezone: 'Asia/Calcutta',
+  recurring: false,
+  jobCostPrediction: 0.1,
+  createdChainId: '11155420',
+  targetChainId: '11155420',
+  targetContractAddress: '0x...',
+  targetFunction: 'incrementBy',
+  abi: '[...]',
+  isImua: true,
+  arguments: ['3'],
+  dynamicArgumentsScriptUrl: '',
+};
+
+const signer = /* ethers.Signer instance */;
+const result = await createJob(client, { jobInput, signer });
+console.log(result);
+```
+
+---
+
+#### 📟 Example: Event-based Dynamic Job
+
+```ts
+const jobInput = {
+  jobType: JobType.Event,
+  argType: ArgType.Dynamic,
+  userAddress: '0x...',
+  etherBalance: 10000000000000000,
+  tokenBalance: 10000000000000000000,
+  jobTitle: 'My Event Job',
+  timeFrame: 36,
+  recurring: true,
+  jobCostPrediction: 0.2,
+  timezone: 'Asia/Calcutta',
+  createdChainId: '11155420',
+  triggerChainId: '11155420',
+  triggerContractAddress: '0x...',
+  triggerEvent: 'CounterIncremented',
+  targetChainId: '11155420',
+  targetContractAddress: '0x...',
+  targetFunction: 'incrementBy',
+  abi: '[...]',
+  arguments: [],
+  dynamicArgumentsScriptUrl: 'https://your-ipfs-url',
+  isImua: true,
+};
+
+const result = await createJob(client, { jobInput, signer });
+console.log(result);
+```
+
+---
+
+#### 📈 Example: Condition-based Static Job
+
+```ts
+const jobInput = {
+  jobType: JobType.Condition,
+  argType: ArgType.Static,
+  userAddress: '0x...',
+  etherBalance: 10000000000000000,
+  tokenBalance: 10000000000000000000,
+  jobTitle: 'My Condition Job',
+  timeFrame: 36,
+  recurring: false,
+  jobCostPrediction: 0.3,
+  timezone: 'Asia/Calcutta',
+  createdChainId: '11155420',
+  conditionType: 'greaterThan',
+  upperLimit: 100,
+  lowerLimit: 10,
+  valueSourceType: 'api',
+  valueSourceUrl: 'https://api.example.com/value',
+  targetChainId: '11155420',
+  targetContractAddress: '0x...',
+  targetFunction: 'incrementBy',
+  abi: '[...]',
+  arguments: ['5'],
+  dynamicArgumentsScriptUrl: '',
+  isImua: true,
+};
+
+const result = await createJob(client, { jobInput, signer });
+console.log(result);
+```
+
+---
+
+### 3. Fetch Job Data
+
+#### 🔍 Get All Jobs
+
+```ts
+import { getJobData } from 'sdk-triggerx';
+
+const jobs = await getJobData(client);
+console.log(jobs);
+```
+
+#### 🔎 Get Job by ID
+
+```ts
+import { getJobDataById } from 'sdk-triggerx';
+
+const jobId = 'YOUR_JOB_ID';
+const jobData = await getJobDataById(client, jobId);
+console.log(jobData);
+```
+
+---
+
+### 4. Delete a Job
+
+```ts
+import { deleteJob } from 'sdk-triggerx';
+
+const jobId = 'YOUR_JOB_ID';
+await deleteJob(client, jobId);
+console.log('Job deleted');
+```
+
+---
+
+### 5. Get User Data
+
+```ts
+import { getUserData } from 'sdk-triggerx';
+
+const userAddress = '0x...';
+const userData = await getUserData(client, userAddress);
+console.log(userData);
+```
+
+---
+
+## 📘 API Reference
+
+All input and output types are defined in:
+
+```
+src/types.ts
+```
+
+Includes:
+
+- `JobInput`, `JobType`, `ArgType`
+- `ConditionType`, `ScheduleType`
+- `UserData`, `JobData`, etc.
+
+---
+
+## 🗂️ Project Structure
+
+```
+sdk-triggerx/
+├── index.ts              # Entry point
+├── client.ts             # Axios client wrapper
+├── config.ts             # Config and environment loader
+├── types.ts              # Shared interfaces and enums
+├── api/                  # Backend API modules
+├── contracts/            # Contract logic and ABIs
+├── utils/                # Error and helper utilities
+├── test/                 # Unit/integration tests
+└── scripts/              # Example/test scripts
+```
+
+---
+
+## ✅ Requirements
+
+- Node.js ≥ 16
+- ethers.js for signer interactions
+- IPFS-hosted script for dynamic arguments (optional)
+
+---
+
+## 📝 License
+
+**MIT License**
+

package/dist/api/jobs.d.ts

@@ -0,0 +1,15 @@
+import { TriggerXClient } from '../client';
+import { TimeBasedJobInput, EventBasedJobInput, ConditionBasedJobInput, CreateJobData, JobResponse } from '../types';
+export declare function toCreateJobDataFromTime(input: TimeBasedJobInput): CreateJobData;
+export declare function toCreateJobDataFromEvent(input: EventBasedJobInput): CreateJobData;
+export declare function toCreateJobDataFromCondition(input: ConditionBasedJobInput): CreateJobData;
+export interface CreateJobParams {
+    jobInput: TimeBasedJobInput | EventBasedJobInput | ConditionBasedJobInput;
+    privateKey: string;
+    providerUrl: string;
+    contractAddress: string;
+    abi: any;
+    encodedData: string;
+    jobType: number;
+}
+export declare function createJob(client: TriggerXClient, params: CreateJobParams): Promise<JobResponse>;

package/dist/api/jobs.js

@@ -0,0 +1,138 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.toCreateJobDataFromTime = toCreateJobDataFromTime;
+exports.toCreateJobDataFromEvent = toCreateJobDataFromEvent;
+exports.toCreateJobDataFromCondition = toCreateJobDataFromCondition;
+exports.createJob = createJob;
+const JobRegistry_1 = require("../contracts/JobRegistry");
+const JOB_ID = '300949528249665590178224313442040528409305273634097553067152835846309150732';
+const DYNAMIC_ARGS_URL = 'https://teal-random-koala-993.mypinata.cloud/ipfs/bafkreif426p7t7takzhw3g6we2h6wsvf27p5jxj3gaiynqf22p3jvhx4la';
+function toCreateJobDataFromTime(input) {
+    return {
+        job_id: JOB_ID,
+        user_address: input.userAddress,
+        ether_balance: input.etherBalance,
+        token_balance: input.tokenBalance,
+        job_title: input.jobTitle,
+        task_definition_id: input.dynamicArgumentsScriptUrl ? 2 : 1,
+        custom: true,
+        time_frame: input.timeFrame,
+        recurring: input.recurring ?? false,
+        job_cost_prediction: input.jobCostPrediction,
+        timezone: input.timezone,
+        created_chain_id: input.createdChainId,
+        schedule_type: input.scheduleType,
+        time_interval: input.timeInterval,
+        cron_expression: input.cronExpression,
+        specific_schedule: input.specificSchedule,
+        target_chain_id: input.targetChainId,
+        target_contract_address: input.targetContractAddress,
+        target_function: input.targetFunction,
+        abi: input.abi,
+        arg_type: input.dynamicArgumentsScriptUrl ? 2 : 1,
+        arguments: input.arguments,
+        dynamic_arguments_script_url: input.dynamicArgumentsScriptUrl,
+        is_imua: input.isImua ?? true,
+    };
+}
+function toCreateJobDataFromEvent(input) {
+    return {
+        job_id: JOB_ID,
+        user_address: input.userAddress,
+        ether_balance: input.etherBalance,
+        token_balance: input.tokenBalance,
+        job_title: input.jobTitle,
+        task_definition_id: input.dynamicArgumentsScriptUrl ? 4 : 3,
+        custom: true,
+        time_frame: input.timeFrame,
+        recurring: input.recurring ?? false,
+        job_cost_prediction: input.jobCostPrediction,
+        timezone: input.timezone,
+        created_chain_id: input.createdChainId,
+        trigger_chain_id: input.triggerChainId,
+        trigger_contract_address: input.triggerContractAddress,
+        trigger_event: input.triggerEvent,
+        target_chain_id: input.targetChainId,
+        target_contract_address: input.targetContractAddress,
+        target_function: input.targetFunction,
+        abi: input.abi,
+        arg_type: input.dynamicArgumentsScriptUrl ? 2 : 1,
+        arguments: input.arguments,
+        dynamic_arguments_script_url: input.dynamicArgumentsScriptUrl,
+        is_imua: input.isImua ?? true,
+    };
+}
+function toCreateJobDataFromCondition(input) {
+    return {
+        job_id: JOB_ID,
+        user_address: input.userAddress,
+        ether_balance: input.etherBalance,
+        token_balance: input.tokenBalance,
+        job_title: input.jobTitle,
+        task_definition_id: input.dynamicArgumentsScriptUrl ? 6 : 5,
+        custom: true,
+        time_frame: input.timeFrame,
+        recurring: input.recurring ?? false,
+        job_cost_prediction: input.jobCostPrediction,
+        timezone: input.timezone,
+        created_chain_id: input.createdChainId,
+        condition_type: input.conditionType,
+        upper_limit: input.upperLimit,
+        lower_limit: input.lowerLimit,
+        value_source_type: input.valueSourceType,
+        value_source_url: input.valueSourceUrl,
+        target_chain_id: input.targetChainId,
+        target_contract_address: input.targetContractAddress,
+        target_function: input.targetFunction,
+        abi: input.abi,
+        arg_type: input.dynamicArgumentsScriptUrl ? 2 : 1,
+        arguments: input.arguments,
+        dynamic_arguments_script_url: input.dynamicArgumentsScriptUrl,
+        is_imua: input.isImua ?? true,
+    };
+}
+async function createJob(client, params) {
+    // 1. Call contract to create job and get jobId
+    const { jobInput, privateKey, providerUrl, contractAddress, abi, encodedData, jobType } = params;
+    let jobTitle, timeFrame, targetContractAddress;
+    if ('jobTitle' in jobInput)
+        jobTitle = jobInput.jobTitle;
+    if ('timeFrame' in jobInput)
+        timeFrame = jobInput.timeFrame;
+    if ('targetContractAddress' in jobInput)
+        targetContractAddress = jobInput.targetContractAddress;
+    const jobId = await (0, JobRegistry_1.createJobOnChain)({
+        jobTitle: jobTitle,
+        jobType,
+        timeFrame: timeFrame,
+        targetContractAddress: targetContractAddress,
+        encodedData,
+        contractAddress,
+        abi,
+        privateKey,
+        providerUrl,
+    });
+    // 2. Convert input to CreateJobData
+    let jobData;
+    if ('scheduleType' in jobInput) {
+        jobData = toCreateJobDataFromTime(jobInput);
+    }
+    else if ('triggerChainId' in jobInput) {
+        jobData = toCreateJobDataFromEvent(jobInput);
+    }
+    else {
+        jobData = toCreateJobDataFromCondition(jobInput);
+    }
+    // 3. Set the job_id from contract
+    jobData.job_id = jobId;
+    // 4. Call the API
+    try {
+        const res = await client.post('/api/jobs', [jobData], {
+            headers: { 'Content-Type': 'application/json', 'X-API-KEY': 'ADMIN' },
+        });
+        return { success: true, data: res };
+    }
+    catch (error) {
+        return { success: false, error: error.message };
+    }
+}

package/dist/api/tasks.d.ts

@@ -0,0 +1,4 @@
+import { TriggerXClient } from '../client';
+import { Task, ApiResponse } from '../types';
+export declare function getTasks(client: TriggerXClient): Promise<ApiResponse<Task[]>>;
+export declare function createTask(client: TriggerXClient, task: Partial<Task>): Promise<ApiResponse<Task>>;

package/dist/api/tasks.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTasks = getTasks;
+exports.createTask = createTask;
+async function getTasks(client) {
+    // Placeholder implementation
+    return client.get('/tasks');
+}
+async function createTask(client, task) {
+    // Placeholder implementation
+    // return client.post<ApiResponse<Task>>('/tasks', task);
+    return { data: { id: '1', name: task.name || '', status: 'pending', createdAt: new Date().toISOString() } };
+}

package/dist/client.d.ts

@@ -0,0 +1,7 @@
+import { AxiosRequestConfig } from 'axios';
+export declare class TriggerXClient {
+    private client;
+    constructor(config?: AxiosRequestConfig);
+    get<T>(url: string, config?: AxiosRequestConfig): Promise<T>;
+    post<T>(url: string, data?: any, config?: AxiosRequestConfig): Promise<T>;
+}

package/dist/client.js

@@ -0,0 +1,27 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TriggerXClient = void 0;
+const axios_1 = __importDefault(require("axios"));
+const config_1 = require("./config");
+class TriggerXClient {
+    constructor(config) {
+        const baseConfig = (0, config_1.getConfig)();
+        this.client = axios_1.default.create({
+            baseURL: config?.baseURL || baseConfig.apiUrl || 'http://localhost:9002',
+            headers: { 'Authorization': `Bearer ${baseConfig.apiKey}` },
+            ...config,
+        });
+    }
+    async get(url, config) {
+        const response = await this.client.get(url, config);
+        return response.data;
+    }
+    async post(url, data, config) {
+        const response = await this.client.post(url, data, config);
+        return response.data;
+    }
+}
+exports.TriggerXClient = TriggerXClient;

package/dist/config.d.ts

@@ -0,0 +1,6 @@
+export interface SDKConfig {
+    apiKey: string;
+    apiUrl: string;
+    contractAddress: string;
+}
+export declare function getConfig(): SDKConfig;

package/dist/config.js

@@ -0,0 +1,15 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getConfig = getConfig;
+const dotenv_1 = __importDefault(require("dotenv"));
+dotenv_1.default.config();
+function getConfig() {
+    return {
+        apiKey: process.env.API_KEY || '',
+        apiUrl: process.env.API_URL || '',
+        contractAddress: process.env.CONTRACT_ADDRESS || '',
+    };
+}

package/dist/contracts/JobRegistry.d.ts

@@ -0,0 +1,12 @@
+export interface CreateJobOnChainParams {
+    jobTitle: string;
+    jobType: number;
+    timeFrame: number;
+    targetContractAddress: string;
+    encodedData: string;
+    contractAddress: string;
+    abi: any;
+    privateKey: string;
+    providerUrl: string;
+}
+export declare function createJobOnChain({ jobTitle, jobType, timeFrame, targetContractAddress, encodedData, contractAddress, abi, privateKey, providerUrl, }: CreateJobOnChainParams): Promise<string>;

package/dist/contracts/JobRegistry.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createJobOnChain = createJobOnChain;
+const ethers_1 = require("ethers");
+async function createJobOnChain({ jobTitle, jobType, timeFrame, targetContractAddress, encodedData, contractAddress, abi, privateKey, providerUrl, }) {
+    const provider = new ethers_1.ethers.JsonRpcProvider(providerUrl);
+    const wallet = new ethers_1.ethers.Wallet(privateKey, provider);
+    const contract = new ethers_1.ethers.Contract(contractAddress, abi, wallet);
+    const tx = await contract.createJob(jobTitle, jobType, timeFrame, targetContractAddress, encodedData);
+    const receipt = await tx.wait();
+    // Try to extract jobId from event logs (assume event is JobCreated(jobId,...))
+    const event = receipt.logs
+        .map((log) => {
+        try {
+            return contract.interface.parseLog(log);
+        }
+        catch {
+            return null;
+        }
+    })
+        .find((e) => e && e.name === 'JobCreated');
+    if (event && event.args && event.args[0]) {
+        return event.args[0].toString();
+    }
+    throw new Error('Job ID not found in contract events');
+}

package/dist/contracts/TriggerXContract.d.ts

@@ -0,0 +1,6 @@
+import { Provider } from 'ethers';
+export declare class TriggerXContract {
+    private contract;
+    constructor(address: string, abi: any, provider: Provider);
+    getTaskCount(): Promise<number>;
+}

package/dist/contracts/TriggerXContract.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TriggerXContract = void 0;
+const ethers_1 = require("ethers");
+class TriggerXContract {
+    constructor(address, abi, provider) {
+        this.contract = new ethers_1.Contract(address, abi, provider);
+    }
+    async getTaskCount() {
+        // Placeholder for contract call
+        return this.contract.taskCount();
+    }
+}
+exports.TriggerXContract = TriggerXContract;