sdk-triggerx 0.1.5 → 0.1.7

package/dist/api/jobs.d.ts

@@ -1,15 +1,27 @@
 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;
+import { Signer } from 'ethers';
+export declare function toCreateJobDataFromTime(input: TimeBasedJobInput, balances: {
+    etherBalance: bigint;
+    tokenBalanceWei: bigint;
+}, userAddress: string, jobCostPrediction: number): CreateJobData;
+export declare function toCreateJobDataFromEvent(input: EventBasedJobInput, balances: {
+    etherBalance: bigint;
+    tokenBalanceWei: bigint;
+}, userAddress: string, jobCostPrediction: number): CreateJobData;
+export declare function toCreateJobDataFromCondition(input: ConditionBasedJobInput, balances: {
+    etherBalance: bigint;
+    tokenBalanceWei: bigint;
+}, userAddress: string, jobCostPrediction: number): CreateJobData;
 export interface CreateJobParams {
     jobInput: TimeBasedJobInput | EventBasedJobInput | ConditionBasedJobInput;
-    privateKey: string;
-    providerUrl: string;
-    contractAddress: string;
-    abi: any;
-    encodedData: string;
-    jobType: number;
+    signer: Signer;
+    encodedData?: string;
 }
+/**
+ * Create a job on the blockchain.
+ * @param client TriggerXClient instance
+ * @param params Parameters for creating the job
+ * @returns JobResponse containing the result of the job creation
+ */
 export declare function createJob(client: TriggerXClient, params: CreateJobParams): Promise<JobResponse>;

package/dist/api/jobs.js

@@ -1,31 +1,39 @@
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 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 ethers_1 = require("ethers");
+const JobRegistry_json_1 = __importDefault(require("../contracts/abi/JobRegistry.json"));
+const topupTg_1 = require("./topupTg");
+const checkTgBalance_1 = require("./checkTgBalance");
 const JOB_ID = '300949528249665590178224313442040528409305273634097553067152835846309150732';
 const DYNAMIC_ARGS_URL = 'https://teal-random-koala-993.mypinata.cloud/ipfs/bafkreif426p7t7takzhw3g6we2h6wsvf27p5jxj3gaiynqf22p3jvhx4la';
-function toCreateJobDataFromTime(input) {
+const JOB_REGISTRY_ADDRESS = '0xdB66c11221234C6B19cCBd29868310c31494C21C'; // Set your fixed contract address here
+function toCreateJobDataFromTime(input, balances, userAddress, jobCostPrediction) {
     return {
         job_id: JOB_ID,
-        user_address: input.userAddress,
-        ether_balance: input.etherBalance,
-        token_balance: input.tokenBalance,
+        user_address: userAddress,
+        ether_balance: balances.etherBalance,
+        token_balance: balances.tokenBalanceWei,
         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,
+        recurring: false,
+        job_cost_prediction: jobCostPrediction,
         timezone: input.timezone,
-        created_chain_id: input.createdChainId,
+        created_chain_id: input.chainId,
         schedule_type: input.scheduleType,
-        time_interval: input.timeInterval,
-        cron_expression: input.cronExpression,
-        specific_schedule: input.specificSchedule,
-        target_chain_id: input.targetChainId,
+        time_interval: input.scheduleType === 'interval' ? input.timeInterval : undefined,
+        cron_expression: input.scheduleType === 'cron' ? input.cronExpression : undefined,
+        specific_schedule: input.scheduleType === 'specific' ? input.specificSchedule : undefined,
+        target_chain_id: input.chainId,
         target_contract_address: input.targetContractAddress,
         target_function: input.targetFunction,
         abi: input.abi,
@@ -35,24 +43,24 @@ function toCreateJobDataFromTime(input) {
         is_imua: input.isImua ?? true,
     };
 }
-function toCreateJobDataFromEvent(input) {
+function toCreateJobDataFromEvent(input, balances, userAddress, jobCostPrediction) {
     return {
         job_id: JOB_ID,
-        user_address: input.userAddress,
-        ether_balance: input.etherBalance,
-        token_balance: input.tokenBalance,
+        user_address: userAddress,
+        ether_balance: balances.etherBalance,
+        token_balance: balances.tokenBalanceWei,
         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,
+        job_cost_prediction: jobCostPrediction,
         timezone: input.timezone,
-        created_chain_id: input.createdChainId,
-        trigger_chain_id: input.triggerChainId,
+        created_chain_id: input.chainId,
+        trigger_chain_id: input.triggerChainId ?? input.chainId,
         trigger_contract_address: input.triggerContractAddress,
         trigger_event: input.triggerEvent,
-        target_chain_id: input.targetChainId,
+        target_chain_id: input.chainId,
         target_contract_address: input.targetContractAddress,
         target_function: input.targetFunction,
         abi: input.abi,
@@ -62,26 +70,26 @@ function toCreateJobDataFromEvent(input) {
         is_imua: input.isImua ?? true,
     };
 }
-function toCreateJobDataFromCondition(input) {
+function toCreateJobDataFromCondition(input, balances, userAddress, jobCostPrediction) {
     return {
         job_id: JOB_ID,
-        user_address: input.userAddress,
-        ether_balance: input.etherBalance,
-        token_balance: input.tokenBalance,
+        user_address: userAddress,
+        ether_balance: balances.etherBalance,
+        token_balance: balances.tokenBalanceWei,
         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,
+        job_cost_prediction: jobCostPrediction,
         timezone: input.timezone,
-        created_chain_id: input.createdChainId,
+        created_chain_id: input.chainId,
         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_chain_id: input.chainId,
         target_contract_address: input.targetContractAddress,
         target_function: input.targetFunction,
         abi: input.abi,
@@ -91,44 +99,192 @@ function toCreateJobDataFromCondition(input) {
         is_imua: input.isImua ?? true,
     };
 }
+// --- Encoding helpers for different job types ---
+function encodeJobType1Data(timeInterval) {
+    return ethers_1.ethers.AbiCoder.defaultAbiCoder().encode(['uint256'], [timeInterval]);
+}
+function encodeJobType2Data(timeInterval, ipfsHash) {
+    return ethers_1.ethers.AbiCoder.defaultAbiCoder().encode(['uint256', 'bytes32'], [timeInterval, ipfsHash]);
+}
+function encodeJobType3or5Data(recurringJob) {
+    return ethers_1.ethers.AbiCoder.defaultAbiCoder().encode(['bool'], [recurringJob]);
+}
+function encodeJobType4or6Data(recurringJob, ipfsHash) {
+    return ethers_1.ethers.AbiCoder.defaultAbiCoder().encode(['bool', 'bytes32'], [recurringJob, ipfsHash]);
+}
+/**
+ * Create a job on the blockchain.
+ * @param client TriggerXClient instance
+ * @param params Parameters for creating the job
+ * @returns JobResponse containing the result of the job creation
+ */
 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;
+    let { jobInput, signer, encodedData } = params;
+    // Use the API key from the client instance
+    const apiKey = client.getApiKey();
+    const userAddress = await signer.getAddress();
+    let jobTitle, timeFrame, targetContractAddress, jobType;
     if ('jobTitle' in jobInput)
         jobTitle = jobInput.jobTitle;
     if ('timeFrame' in jobInput)
         timeFrame = jobInput.timeFrame;
     if ('targetContractAddress' in jobInput)
         targetContractAddress = jobInput.targetContractAddress;
+    // Validate schedule-specific fields for time-based jobs
+    if ('scheduleType' in jobInput) {
+        if (jobInput.scheduleType === 'interval' && (jobInput.timeInterval === undefined || jobInput.timeInterval === null)) {
+            throw new Error('timeInterval is required when scheduleType is interval');
+        }
+        if (jobInput.scheduleType === 'cron' && !jobInput.cronExpression) {
+            throw new Error('cronExpression is required when scheduleType is cron');
+        }
+        if (jobInput.scheduleType === 'specific' && !jobInput.specificSchedule) {
+            throw new Error('specificSchedule is required when scheduleType is specific');
+        }
+    }
+    // Infer jobType from jobInput
+    if ('scheduleType' in jobInput) {
+        jobType = jobInput.dynamicArgumentsScriptUrl ? 2 : 1; // Time-based job
+    }
+    else if ('triggerChainId' in jobInput) {
+        jobType = jobInput.dynamicArgumentsScriptUrl ? 4 : 3; // Event-based job
+    }
+    else {
+        jobType = jobInput.dynamicArgumentsScriptUrl ? 6 : 5; // Condition-based job
+    }
+    // --- Generate encodedData if not provided ---
+    if (!encodedData) {
+        // Time-based jobs
+        if ('scheduleType' in jobInput) {
+            if (jobType === 1) {
+                encodedData = encodeJobType1Data(jobInput.timeInterval ?? 0);
+            }
+            else if (jobType === 2) {
+                encodedData = encodeJobType2Data(jobInput.timeInterval ?? 0, jobInput.dynamicArgumentsScriptUrl || '');
+            }
+        }
+        // Event-based jobs
+        else if ('triggerChainId' in jobInput) {
+            if (jobType === 3 || jobType === 5) {
+                encodedData = encodeJobType3or5Data(jobInput.recurring ?? false);
+            }
+            else if (jobType === 4 || jobType === 6) {
+                encodedData = encodeJobType4or6Data(jobInput.recurring ?? false, jobInput.dynamicArgumentsScriptUrl || '');
+            }
+        }
+        // Condition-based jobs
+        else {
+            if (jobType === 3 || jobType === 5) {
+                encodedData = encodeJobType3or5Data(jobInput.recurring ?? false);
+            }
+            else if (jobType === 4 || jobType === 6) {
+                encodedData = encodeJobType4or6Data(jobInput.recurring ?? false, jobInput.dynamicArgumentsScriptUrl || '');
+            }
+        }
+    }
+    // Handle job_cost_prediction logic based on argType (static/dynamic)
+    // If static, set to 0.1. If dynamic, call backend API to get fee and ask user to proceed.
+    // Determine argType directly from user input
+    let argType = 1; // default to static
+    if ('argType' in jobInput) {
+        if (jobInput.argType === 'dynamic' || jobInput.argType === 2) {
+            argType = 2;
+        }
+        else {
+            argType = 1;
+        }
+    }
+    //if jobis time based then check the no of executions of the job from time frame and time interval by deviding time frame by time interval
+    let noOfExecutions = 1;
+    if ('scheduleType' in jobInput) {
+        noOfExecutions = jobInput.timeFrame / (jobInput.timeInterval ?? 0);
+    }
+    // Set job_cost_prediction
+    let job_cost_prediction = 0.1 * noOfExecutions; // default for static
+    if (argType === 2) {
+        // Dynamic: call backend API to get fee
+        const ipfs_url = jobInput.dynamicArgumentsScriptUrl;
+        if (!ipfs_url) {
+            throw new Error('dynamicArgumentsScriptUrl is required for dynamic argType');
+        }
+        // Call backend API to get fee
+        let fee = 0;
+        try {
+            const feeRes = await client.get('/api/fees', { params: { ipfs_url } });
+            // The API now returns { total_fee: number }
+            if (feeRes && typeof feeRes.total_fee === 'number') {
+                fee = feeRes.total_fee;
+            }
+            else if (feeRes && feeRes.data && typeof feeRes.data.total_fee === 'number') {
+                fee = feeRes.data.total_fee;
+            }
+            else {
+                throw new Error('Invalid response from /api/fees: missing total_fee');
+            }
+        }
+        catch (err) {
+            throw new Error('Failed to fetch job cost prediction: ' + err.message);
+        }
+        job_cost_prediction = fee * noOfExecutions;
+    }
+    // Ask user if they want to proceed
+    // Since this is a library, we can't prompt in Node.js directly.
+    // We'll throw an error with the fee and let the caller handle the prompt/confirmation.
+    // If you want to automate, you can add a `proceed` flag to params in the future.
+    // Check if the user has enough TG to cover the job cost prediction
+    const { tgBalanceWei, tgBalance } = await (0, checkTgBalance_1.checkTgBalance)(signer);
+    if (Number(tgBalance) < job_cost_prediction) {
+        // Check if user has enabled auto topup
+        // For each job type, autotopupTG should be present in jobInput
+        const autoTopupTG = jobInput.autotopupTG === true;
+        if (!autoTopupTG) {
+            throw new Error(`Insufficient TG balance. Job cost prediction is ${job_cost_prediction}. Current TG balance: ${tgBalance}. Please set autotopupTG: true in jobInput.`);
+        }
+        else {
+            // autotopupTG is true, automatically top up
+            const requiredTG = Math.ceil(job_cost_prediction * 1000); // 1 TG = 0.001 ETH
+            await (0, topupTg_1.topupTg)(requiredTG, signer);
+        }
+    }
+    // Compute balances to store with the job
+    const tokenBalanceWei = tgBalanceWei;
+    const etherBalance = tokenBalanceWei / 1000n;
+    // Patch jobInput with job_cost_prediction for downstream usage
+    jobInput.jobCostPrediction = job_cost_prediction;
     const jobId = await (0, JobRegistry_1.createJobOnChain)({
         jobTitle: jobTitle,
         jobType,
         timeFrame: timeFrame,
         targetContractAddress: targetContractAddress,
-        encodedData,
-        contractAddress,
-        abi,
-        privateKey,
-        providerUrl,
+        encodedData: encodedData || '',
+        contractAddress: JOB_REGISTRY_ADDRESS,
+        abi: JobRegistry_json_1.default.abi,
+        signer,
     });
     // 2. Convert input to CreateJobData
     let jobData;
+    const balances = { etherBalance, tokenBalanceWei };
     if ('scheduleType' in jobInput) {
-        jobData = toCreateJobDataFromTime(jobInput);
+        jobData = toCreateJobDataFromTime(jobInput, balances, userAddress, job_cost_prediction);
     }
     else if ('triggerChainId' in jobInput) {
-        jobData = toCreateJobDataFromEvent(jobInput);
+        jobData = toCreateJobDataFromEvent(jobInput, balances, userAddress, job_cost_prediction);
     }
     else {
-        jobData = toCreateJobDataFromCondition(jobInput);
+        jobData = toCreateJobDataFromCondition(jobInput, balances, userAddress, job_cost_prediction);
     }
     // 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' },
+        // Ensure JSON-serializable payload (use numbers for balances)
+        const jobDataForApi = {
+            ...jobData,
+            ether_balance: typeof jobData.ether_balance === 'bigint' ? Number(jobData.ether_balance) : Number(jobData.ether_balance),
+            token_balance: typeof jobData.token_balance === 'bigint' ? Number(jobData.token_balance) : Number(jobData.token_balance),
+        };
+        const res = await client.post('/api/jobs', [jobDataForApi], {
+            headers: { 'Content-Type': 'application/json', 'X-API-KEY': apiKey },
         });
         return { success: true, data: res };
     }

package/dist/client.d.ts

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

package/dist/client.js

@@ -7,14 +7,19 @@ exports.TriggerXClient = void 0;
 const axios_1 = __importDefault(require("axios"));
 const config_1 = require("./config");
 class TriggerXClient {
-    constructor(config) {
+    constructor(apiKey, config) {
+        this.apiKey = apiKey; // Initialize the apiKey
         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}` },
+            baseURL: config?.baseURL || baseConfig.apiUrl || 'https://data.triggerx.network', //http://localhost:9002 , https://data.triggerx.network
+            headers: { 'Authorization': `Bearer ${this.apiKey}` }, // Set the API key here
             ...config,
         });
     }
+    // Method to get the API key
+    getApiKey() {
+        return this.apiKey;
+    }
     async get(url, config) {
         const response = await this.client.get(url, config);
         return response.data;
@@ -23,5 +28,10 @@ class TriggerXClient {
         const response = await this.client.post(url, data, config);
         return response.data;
     }
+    // New PUT method
+    async put(url, data, config) {
+        const response = await this.client.put(url, data, config);
+        return response.data;
+    }
 }
 exports.TriggerXClient = TriggerXClient;

package/dist/contracts/JobRegistry.d.ts

@@ -1,3 +1,4 @@
+import { Signer } from 'ethers';
 export interface CreateJobOnChainParams {
     jobTitle: string;
     jobType: number;
@@ -6,7 +7,6 @@ export interface CreateJobOnChainParams {
     encodedData: string;
     contractAddress: string;
     abi: any;
-    privateKey: string;
-    providerUrl: string;
+    signer: Signer;
 }
-export declare function createJobOnChain({ jobTitle, jobType, timeFrame, targetContractAddress, encodedData, contractAddress, abi, privateKey, providerUrl, }: CreateJobOnChainParams): Promise<string>;
+export declare function createJobOnChain({ jobTitle, jobType, timeFrame, targetContractAddress, encodedData, contractAddress, abi, signer, }: CreateJobOnChainParams): Promise<string>;

package/dist/contracts/JobRegistry.js

@@ -2,10 +2,8 @@
 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);
+async function createJobOnChain({ jobTitle, jobType, timeFrame, targetContractAddress, encodedData, contractAddress, abi, signer, }) {
+    const contract = new ethers_1.ethers.Contract(contractAddress, abi, signer);
     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,...))

package/dist/index.d.ts

@@ -1,7 +1,6 @@
 export * from './client';
 export * from './config';
 export * from './types';
-export * from './api/tasks';
 export * from './api/jobs';
 export { createJobOnChain } from './contracts/JobRegistry';
 export * from './contracts';

package/dist/index.js

@@ -18,7 +18,6 @@ exports.createJobOnChain = void 0;
 __exportStar(require("./client"), exports);
 __exportStar(require("./config"), exports);
 __exportStar(require("./types"), exports);
-__exportStar(require("./api/tasks"), exports);
 __exportStar(require("./api/jobs"), exports);
 var JobRegistry_1 = require("./contracts/JobRegistry");
 Object.defineProperty(exports, "createJobOnChain", { enumerable: true, get: function () { return JobRegistry_1.createJobOnChain; } });

package/dist/types.d.ts

@@ -28,9 +28,6 @@ export type CreateJobInput = (TimeBasedJobInput & {
     argType: ArgType.Static | ArgType.Dynamic;
 });
 export interface TimeBasedJobInput {
-    userAddress: string;
-    etherBalance: BigInt | number;
-    tokenBalance: BigInt | number;
     jobTitle: string;
     timeFrame: number;
     scheduleType: 'cron' | 'specific' | 'interval';
@@ -38,21 +35,16 @@ export interface TimeBasedJobInput {
     cronExpression?: string;
     specificSchedule?: string;
     timezone: string;
-    recurring?: boolean;
-    jobCostPrediction: number;
-    createdChainId: string;
-    targetChainId: string;
+    chainId: string;
     targetContractAddress: string;
     targetFunction: string;
     abi: string;
     isImua?: boolean;
     arguments?: string[];
     dynamicArgumentsScriptUrl?: string;
+    autotopupTG?: boolean;
 }
 export interface EventBasedJobInput {
-    userAddress: string;
-    etherBalance: BigInt | number;
-    tokenBalance: BigInt | number;
     jobTitle: string;
     timeFrame: number;
     triggerChainId: string;
@@ -60,38 +52,33 @@ export interface EventBasedJobInput {
     triggerEvent: string;
     timezone: string;
     recurring?: boolean;
-    jobCostPrediction: number;
-    createdChainId: string;
-    targetChainId: string;
+    chainId: string;
     targetContractAddress: string;
     targetFunction: string;
     abi: string;
     isImua?: boolean;
     arguments?: string[];
     dynamicArgumentsScriptUrl?: string;
+    autotopupTG?: boolean;
 }
 export interface ConditionBasedJobInput {
-    userAddress: string;
-    etherBalance: BigInt | number;
-    tokenBalance: BigInt | number;
     jobTitle: string;
     timeFrame: number;
-    conditionType: string;
+    conditionType: 'greater_than' | 'less_than' | 'between' | 'equals' | 'not_equals' | 'greater_equal' | 'less_equal';
     upperLimit: number;
     lowerLimit: number;
     valueSourceType: string;
     valueSourceUrl: string;
     timezone: string;
     recurring?: boolean;
-    jobCostPrediction: number;
-    createdChainId: string;
-    targetChainId: string;
+    chainId: string;
     targetContractAddress: string;
     targetFunction: string;
     abi: string;
     isImua?: boolean;
     arguments?: string[];
     dynamicArgumentsScriptUrl?: string;
+    autotopupTG?: boolean;
 }
 export interface CreateJobData {
     job_id: string;
@@ -132,3 +119,114 @@ export interface JobResponse {
     data?: any;
     error?: string;
 }
+export interface JobDataAPI {
+    job_id: string;
+    job_title: string;
+    task_definition_id: number;
+    user_id: number;
+    link_job_id: string;
+    chain_status: number;
+    custom: boolean;
+    time_frame: number;
+    recurring: boolean;
+    status: string;
+    job_cost_prediction: number;
+    job_cost_actual: number;
+    task_ids: number[];
+    created_at: Date;
+    updated_at: Date;
+    last_executed_at: Date;
+    timezone: string;
+    is_imua: boolean;
+    created_chain_id: string;
+}
+export interface TimeJobData {
+    job_id: string;
+    task_definition_id: number;
+    expiration_time: Date;
+    created_at: Date;
+    updated_at: Date;
+    time_interval: number;
+    schedule_type: string;
+    cron_expression: string;
+    specific_schedule: string;
+    timezone: string;
+    next_execution_timestamp: Date;
+    target_chain_id: string;
+    target_contract_address: string;
+    target_function: string;
+    abi: string;
+    arg_type: number;
+    arguments: string[];
+    dynamic_arguments_script_url: string;
+    is_completed: boolean;
+    is_active: boolean;
+}
+export interface EventJobData {
+    job_id: string;
+    task_definition_id: number;
+    expiration_time: Date;
+    created_at: Date;
+    updated_at: Date;
+    recurring: boolean;
+    trigger_chain_id: string;
+    trigger_contract_address: string;
+    trigger_event: string;
+    timezone: string;
+    target_chain_id: string;
+    target_contract_address: string;
+    target_function: string;
+    abi: string;
+    arg_type: number;
+    arguments: string[];
+    dynamic_arguments_script_url: string;
+    is_completed: boolean;
+    is_active: boolean;
+}
+export interface ConditionJobData {
+    job_id: string;
+    task_definition_id: number;
+    expiration_time: Date;
+    created_at: Date;
+    updated_at: Date;
+    recurring: boolean;
+    condition_type: string;
+    upper_limit: number;
+    lower_limit: number;
+    value_source_type: string;
+    value_source_url: string;
+    timezone: string;
+    target_chain_id: string;
+    target_contract_address: string;
+    target_function: string;
+    abi: string;
+    arg_type: number;
+    arguments: string[];
+    dynamic_arguments_script_url: string;
+    is_completed: boolean;
+    is_active: boolean;
+}
+export interface JobResponseUser {
+    success: boolean;
+    error?: string;
+    jobs?: JobResponseAPI;
+}
+export interface JobResponseAPI {
+    job_data?: JobDataAPI;
+    time_job_data?: TimeJobData;
+    event_job_data?: EventJobData;
+    condition_job_data?: ConditionJobData;
+}
+export interface UserData {
+    user_id: number;
+    user_address: string;
+    job_ids: string[];
+    ether_balance: BigInt | number;
+    token_balance: BigInt | number;
+    user_points: number;
+    total_jobs: number;
+    total_tasks: number;
+    created_at: Date;
+    last_updated_at: Date;
+    email: string;
+}