sdk-triggerx 0.1.15 → 0.1.17

package/dist/api/deleteJob.d.ts

@@ -1,2 +1,3 @@
 import { TriggerXClient } from '../client';
-export declare const deleteJob: (client: TriggerXClient, jobId: string) => Promise<void>;
+import { Signer } from 'ethers';
+export declare const deleteJob: (client: TriggerXClient, jobId: string, signer: Signer, chainId: string) => Promise<void>;

package/dist/api/deleteJob.js

@@ -1,16 +1,38 @@
 "use strict";
 // sdk-triggerx/src/api/deleteJob.ts
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.deleteJob = void 0;
-const deleteJob = async (client, jobId) => {
+const JobRegistry_json_1 = __importDefault(require("../contracts/abi/JobRegistry.json"));
+const JobRegistry_1 = require("../contracts/JobRegistry");
+const config_1 = require("../config");
+const deleteJob = async (client, jobId, signer, chainId) => {
     const apiKey = client.getApiKey(); // Assuming you have a method to get the API key
+    const { jobRegistry: jobRegistryAddress } = config_1.CONTRACT_ADDRESSES_BY_CHAIN[chainId];
+    if (!jobRegistryAddress) {
+        throw new Error(`No contract address found for chain ID: ${chainId}`);
+    }
     try {
+        console.log(`Deleting job ${jobId} on chain ${chainId}...`);
+        // First delete on-chain
+        await (0, JobRegistry_1.deleteJobOnChain)({
+            jobId,
+            contractAddress: jobRegistryAddress,
+            abi: JobRegistry_json_1.default,
+            signer,
+        });
+        console.log('On-chain deletion successful, updating API...');
+        // Then update the API
         await client.put(`api/jobs/delete/${jobId}`, {}, {
             headers: {
                 'Content-Type': 'application/json',
                 'X-API-KEY': apiKey,
             },
+            timeout: 30000, // 30 second timeout
         });
+        console.log('API update successful');
     }
     catch (error) {
         console.error('Error deleting job:', error);

package/dist/api/jobs.js

@@ -13,6 +13,10 @@ const JobRegistry_json_1 = __importDefault(require("../contracts/abi/JobRegistry
 const topupTg_1 = require("./topupTg");
 const checkTgBalance_1 = require("./checkTgBalance");
 const config_1 = require("../config");
+const validation_1 = require("../utils/validation");
+const errors_1 = require("../utils/errors");
+const SafeWallet_1 = require("../contracts/safe/SafeWallet");
+const SafeFactory_1 = require("../contracts/safe/SafeFactory");
 const JOB_ID = '300949528249665590178224313442040528409305273634097553067152835846309150732';
 const DYNAMIC_ARGS_URL = 'https://teal-random-koala-993.mypinata.cloud/ipfs/bafkreif426p7t7takzhw3g6we2h6wsvf27p5jxj3gaiynqf22p3jvhx4la';
 function toCreateJobDataFromTime(input, balances, userAddress, jobCostPrediction) {
@@ -120,13 +124,25 @@ function encodeJobType4or6Data(recurringJob, ipfsHash) {
  */
 async function createJob(client, params) {
     let { jobInput, signer, encodedData } = params;
+    // 0. Validate user input thoroughly before proceeding
+    try {
+        const argValue = jobInput.argType;
+        (0, validation_1.validateJobInput)(jobInput, argValue);
+        console.log('Job input validated successfully');
+    }
+    catch (err) {
+        if (err instanceof errors_1.ValidationError) {
+            return { success: false, error: `${err.field}: ${err.message}` };
+        }
+        return { success: false, error: err.message };
+    }
     // Use the API key from the client instance
     const apiKey = client.getApiKey();
     const userAddress = await signer.getAddress();
     // Resolve chain-specific addresses
     const network = await signer.provider?.getNetwork();
     const chainIdStr = network?.chainId ? network.chainId.toString() : undefined;
-    const { jobRegistry } = (0, config_1.getChainAddresses)(chainIdStr);
+    const { jobRegistry, safeModule, safeFactory } = (0, config_1.getChainAddresses)(chainIdStr);
     const JOB_REGISTRY_ADDRESS = jobRegistry;
     if (!JOB_REGISTRY_ADDRESS) {
         return { success: false, error: 'JobRegistry address not configured for this chain. Update config mapping.' };
@@ -262,6 +278,46 @@ async function createJob(client, params) {
     const etherBalance = tokenBalanceWei / 1000n;
     // Patch jobInput with job_cost_prediction for downstream usage
     jobInput.jobCostPrediction = job_cost_prediction;
+    // --- Safe wallet integration (override target to module when selected) ---
+    const walletMode = jobInput.walletMode;
+    if (walletMode === 'safe') {
+        if (!safeModule) {
+            return { success: false, error: 'Safe Module address not configured for this chain.' };
+        }
+        // Enforce dynamic parameters coming from IPFS only
+        const dynUrl = jobInput.dynamicArgumentsScriptUrl;
+        if (!dynUrl) {
+            return { success: false, error: 'Safe jobs require dynamicArgumentsScriptUrl (IPFS) for parameters.' };
+        }
+        // Resolve or create Safe wallet
+        const providedSafeAddress = jobInput.safeAddress;
+        let safeAddressToUse = providedSafeAddress;
+        if (!safeAddressToUse) {
+            if (!safeFactory) {
+                return { success: false, error: 'Safe Factory address not configured for this chain.' };
+            }
+            safeAddressToUse = await (0, SafeFactory_1.createSafeWalletForUser)(safeFactory, signer, userAddress);
+        }
+        // Validate Safe has single owner and owner matches signer
+        await (0, SafeWallet_1.ensureSingleOwnerAndMatchSigner)(safeAddressToUse, signer.provider, userAddress);
+        // Ensure module is enabled on Safe
+        await (0, SafeWallet_1.enableSafeModule)(safeAddressToUse, signer, safeModule);
+        // Override target for job to Safe Module and function to execJobFromHub
+        targetContractAddress = safeModule; // ensure target contract is SAFE_MODULE_ADDRESS only
+        jobInput.targetContractAddress = safeModule;
+        jobInput.targetFunction = 'execJobFromHub(address,address,uint256,bytes,uint8)';
+        jobInput.abi = JSON.stringify([
+            { "type": "function", "name": "execJobFromHub", "stateMutability": "nonpayable", "inputs": [
+                    { "name": "safeAddress", "type": "address" },
+                    { "name": "actionTarget", "type": "address" },
+                    { "name": "actionValue", "type": "uint256" },
+                    { "name": "actionData", "type": "bytes" },
+                    { "name": "operation", "type": "uint8" }
+                ], "outputs": [{ "type": "bool", "name": "success" }] }
+        ]);
+        // Note: Parameters will be dynamically provided via IPFS script; do not set static arguments here
+        jobInput.arguments = undefined;
+    }
     const jobId = await (0, JobRegistry_1.createJobOnChain)({
         jobTitle: jobTitle,
         jobType,

package/dist/client.js

@@ -12,6 +12,7 @@ class TriggerXClient {
         this.client = axios_1.default.create({
             baseURL: 'https://data.triggerx.network', //'http://localhost:9002', //'https://data.triggerx.network',
             headers: { 'Authorization': `Bearer ${this.apiKey}` }, // Set the API key here
+            timeout: 30000, // 30 second timeout
             ...config,
         });
     }

package/dist/config.d.ts

@@ -5,9 +5,15 @@ export interface SDKConfig {
 export declare const CONTRACT_ADDRESSES_BY_CHAIN: Record<string, {
     gasRegistry: string;
     jobRegistry: string;
+    safeFactory?: string;
+    safeModule?: string;
+    safeSingleton?: string;
 }>;
 export declare function getConfig(): SDKConfig;
 export declare function getChainAddresses(chainId: string | number | undefined): {
     gasRegistry: string;
     jobRegistry: string;
+    safeFactory: string | undefined;
+    safeModule: string | undefined;
+    safeSingleton: string | undefined;
 };

package/dist/config.js

@@ -8,12 +8,32 @@ exports.getChainAddresses = getChainAddresses;
 // Contract addresses per chain
 // Keyed by chainId as string to avoid bigint conversions throughout the SDK
 exports.CONTRACT_ADDRESSES_BY_CHAIN = {
-    // OP Sepolia? (used in examples) 11155420 - preserves previous defaults
+    // TESTNET CONFIGURATIONS
+    // OP Sepolia (11155420) - Optimism Sepolia Testnet
     '11155420': {
-        gasRegistry: '0x204F9278D6BB7714D7A40842423dFd5A27cC1b88',
+        gasRegistry: '0x664CB20BCEEc9416D290AC820e5446e61a5c75e4',
         jobRegistry: '0x476ACc7949a95e31144cC84b8F6BC7abF0967E4b',
     },
-    // Arbitrum One (42161)
+    // Ethereum Sepolia (11155111) - Ethereum Sepolia Testnet
+    '11155111': {
+        gasRegistry: '0x664CB20BCEEc9416D290AC820e5446e61a5c75e4',
+        jobRegistry: '0x476ACc7949a95e31144cC84b8F6BC7abF0967E4b',
+    },
+    // Arbitrum Sepolia (421614) - Arbitrum Sepolia Testnet
+    '421614': {
+        gasRegistry: '0x664CB20BCEEc9416D290AC820e5446e61a5c75e4',
+        jobRegistry: '0x476ACc7949a95e31144cC84b8F6BC7abF0967E4b',
+        safeFactory: '0x383D4a61D0B069D02cA2Db5A82003b9561d56e19',
+        safeModule: '0xca3a0c43Ac9E4FcB76C774F330fD31D4098EEacD',
+        // safeSingleton can be provided per deployment (Safe or SafeL2)
+    },
+    // Base Sepolia (84532) - Base Sepolia Testnet
+    '84532': {
+        gasRegistry: '0x664CB20BCEEc9416D290AC820e5446e61a5c75e4',
+        jobRegistry: '0x476ACc7949a95e31144cC84b8F6BC7abF0967E4b',
+    },
+    // MAINNET CONFIGURATIONS
+    // Arbitrum One (42161) - Mainnet
     '42161': {
         gasRegistry: '0x93dDB2307F3Af5df85F361E5Cddd898Acd3d132d',
         jobRegistry: '0xAf1189aFd1F1880F09AeC3Cbc32cf415c735C710',
@@ -32,5 +52,8 @@ function getChainAddresses(chainId) {
     return {
         gasRegistry: mapped ? mapped.gasRegistry : '',
         jobRegistry: mapped ? mapped.jobRegistry : '',
+        safeFactory: mapped ? mapped.safeFactory : '',
+        safeModule: mapped ? mapped.safeModule : '',
+        safeSingleton: mapped ? mapped.safeSingleton : '',
     };
 }

package/dist/contracts/JobRegistry.d.ts

@@ -9,4 +9,11 @@ export interface CreateJobOnChainParams {
     abi: any;
     signer: Signer;
 }
+export interface DeleteJobOnChainParams {
+    jobId: string;
+    contractAddress: string;
+    abi: any;
+    signer: Signer;
+}
 export declare function createJobOnChain({ jobTitle, jobType, timeFrame, targetContractAddress, encodedData, contractAddress, abi, signer, }: CreateJobOnChainParams): Promise<string>;
+export declare function deleteJobOnChain({ jobId, contractAddress, abi, signer, }: DeleteJobOnChainParams): Promise<void>;

package/dist/contracts/JobRegistry.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createJobOnChain = createJobOnChain;
+exports.deleteJobOnChain = deleteJobOnChain;
 const ethers_1 = require("ethers");
 async function createJobOnChain({ jobTitle, jobType, timeFrame, targetContractAddress, encodedData, contractAddress, abi, signer, }) {
     const contract = new ethers_1.ethers.Contract(contractAddress, abi, signer);
@@ -22,3 +23,8 @@ async function createJobOnChain({ jobTitle, jobType, timeFrame, targetContractAd
     }
     throw new Error('Job ID not found in contract events');
 }
+async function deleteJobOnChain({ jobId, contractAddress, abi, signer, }) {
+    const contract = new ethers_1.ethers.Contract(contractAddress, abi.abi, signer);
+    const tx = await contract.deleteJob(jobId);
+    await tx.wait();
+}

package/dist/contracts/index.d.ts

@@ -1 +1,4 @@
+export * from './JobRegistry';
+export * from './safe/SafeFactory';
+export * from './safe/SafeWallet';
 export * from './TriggerXContract';

package/dist/contracts/index.js

@@ -14,4 +14,8 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./JobRegistry"), exports);
+// Safe-related helpers
+__exportStar(require("./safe/SafeFactory"), exports);
+__exportStar(require("./safe/SafeWallet"), exports);
 __exportStar(require("./TriggerXContract"), exports);

package/dist/contracts/safe/SafeFactory.d.ts

@@ -0,0 +1,3 @@
+import { Signer } from 'ethers';
+export declare const TRIGGERX_SAFE_FACTORY_ABI: string[];
+export declare function createSafeWalletForUser(factoryAddress: string, signer: Signer, user: string): Promise<string>;

package/dist/contracts/safe/SafeFactory.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TRIGGERX_SAFE_FACTORY_ABI = void 0;
+exports.createSafeWalletForUser = createSafeWalletForUser;
+const ethers_1 = require("ethers");
+// Minimal ABI for TriggerXSafeFactory
+exports.TRIGGERX_SAFE_FACTORY_ABI = [
+    "function createSafeWallet(address user) returns (address)",
+    "function latestSafeWallet(address user) view returns (address)",
+    "function getSafeWallets(address user) view returns (address[])",
+    "function predictSafeAddress(address user) view returns (address)",
+    "event SafeWalletCreated(address indexed user, address indexed safeWallet, uint256 saltNonce)"
+];
+async function createSafeWalletForUser(factoryAddress, signer, user) {
+    const factory = new ethers_1.ethers.Contract(factoryAddress, exports.TRIGGERX_SAFE_FACTORY_ABI, signer);
+    const tx = await factory.createSafeWallet(user);
+    const receipt = await tx.wait();
+    // Try to fetch from event; fallback to latestSafeWallet
+    const evt = receipt.logs
+        .map((l) => {
+        try {
+            return factory.interface.parseLog(l);
+        }
+        catch {
+            return null;
+        }
+    })
+        .find((e) => e && e.name === 'SafeWalletCreated');
+    if (evt && evt.args && evt.args.safeWallet) {
+        return evt.args.safeWallet;
+    }
+    return await factory.latestSafeWallet(user);
+}

package/dist/contracts/safe/SafeWallet.d.ts

@@ -0,0 +1,6 @@
+import { ethers, Signer } from 'ethers';
+export declare const SAFE_ABI: string[];
+export declare const SAFE_TX_TYPEHASH: string;
+export declare function isSafeModuleEnabled(safeAddress: string, provider: ethers.Provider, moduleAddress: string): Promise<boolean>;
+export declare function ensureSingleOwnerAndMatchSigner(safeAddress: string, provider: ethers.Provider, signerAddress: string): Promise<void>;
+export declare function enableSafeModule(safeAddress: string, signer: Signer, moduleAddress: string): Promise<void>;

package/dist/contracts/safe/SafeWallet.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SAFE_TX_TYPEHASH = exports.SAFE_ABI = void 0;
+exports.isSafeModuleEnabled = isSafeModuleEnabled;
+exports.ensureSingleOwnerAndMatchSigner = ensureSingleOwnerAndMatchSigner;
+exports.enableSafeModule = enableSafeModule;
+const ethers_1 = require("ethers");
+// Minimal Safe ABI fragments used in this SDK
+exports.SAFE_ABI = [
+    // module checks
+    "function isModuleEnabled(address module) view returns (bool)",
+    // EIP-712 domain separator for Safe
+    "function domainSeparator() view returns (bytes32)",
+    // Safe nonce
+    "function nonce() view returns (uint256)",
+    // Exec transaction (self-call to enable module)
+    "function execTransaction(address to,uint256 value,bytes data,uint8 operation,uint256 safeTxGas,uint256 baseGas,uint256 gasPrice,address gasToken,address refundReceiver,bytes signatures) returns (bool)",
+    // Owners and threshold, to validate single signer safes
+    "function getOwners() view returns (address[])",
+    "function getThreshold() view returns (uint256)",
+];
+// Safe EIP-712 typehash for transactions
+exports.SAFE_TX_TYPEHASH = ethers_1.ethers.id("SafeTx(address to,uint256 value,bytes data,uint8 operation,uint256 safeTxGas,uint256 baseGas,uint256 gasPrice,address gasToken,address refundReceiver,uint256 _nonce)");
+async function isSafeModuleEnabled(safeAddress, provider, moduleAddress) {
+    const safe = new ethers_1.ethers.Contract(safeAddress, exports.SAFE_ABI, provider);
+    return await safe.isModuleEnabled(moduleAddress);
+}
+async function ensureSingleOwnerAndMatchSigner(safeAddress, provider, signerAddress) {
+    const safe = new ethers_1.ethers.Contract(safeAddress, exports.SAFE_ABI, provider);
+    const [owners, threshold] = await Promise.all([
+        safe.getOwners(),
+        safe.getThreshold(),
+    ]);
+    if (Number(threshold) !== 1) {
+        throw new Error('Safe wallet must have threshold 1');
+    }
+    // Check if signerAddress matches any of the Safe owners
+    const normalizedSigner = signerAddress.toLowerCase();
+    const normalizedOwners = owners.map((owner) => owner.toLowerCase());
+    if (!normalizedOwners.includes(normalizedSigner)) {
+        throw new Error('Signer is not an owner of the Safe wallet');
+    }
+    if (owners[0].toLowerCase() !== signerAddress.toLowerCase()) {
+        throw new Error('Signer must be the sole owner of the Safe wallet');
+    }
+}
+// Enable provided module on the Safe by crafting and signing a Safe execTransaction
+async function enableSafeModule(safeAddress, signer, moduleAddress) {
+    const provider = signer.provider;
+    if (!provider)
+        throw new Error('Signer provider is required');
+    const safeProxy = new ethers_1.ethers.Contract(safeAddress, exports.SAFE_ABI, provider);
+    // If already enabled, exit early
+    const already = await safeProxy.isModuleEnabled(moduleAddress);
+    if (already)
+        return;
+    const safeNonce = await safeProxy.nonce();
+    const iface = new ethers_1.ethers.Interface(exports.SAFE_ABI);
+    const data = iface.encodeFunctionData('enableModule', [moduleAddress]);
+    const to = safeAddress;
+    const value = 0n;
+    const operation = 0; // CALL
+    const safeTxGas = 0n;
+    const baseGas = 0n;
+    const gasPrice = 0n;
+    const gasToken = ethers_1.ethers.ZeroAddress;
+    const refundReceiver = ethers_1.ethers.ZeroAddress;
+    // Calculate Safe transaction hash per EIP-712
+    const safeTxHash = ethers_1.ethers.keccak256(ethers_1.ethers.AbiCoder.defaultAbiCoder().encode([
+        'bytes32', 'address', 'uint256', 'bytes32', 'uint8',
+        'uint256', 'uint256', 'uint256', 'address', 'address', 'uint256'
+    ], [
+        exports.SAFE_TX_TYPEHASH, to, value, ethers_1.ethers.keccak256(data), operation,
+        safeTxGas, baseGas, gasPrice, gasToken, refundReceiver, safeNonce
+    ]));
+    const domainSeparator = await safeProxy.domainSeparator();
+    const txHash = ethers_1.ethers.keccak256(ethers_1.ethers.solidityPacked(['bytes1', 'bytes1', 'bytes32', 'bytes32'], ['0x19', '0x01', domainSeparator, safeTxHash]));
+    const rawSignature = await signer.signMessage(ethers_1.ethers.getBytes(txHash));
+    const sig = ethers_1.ethers.Signature.from(rawSignature);
+    const adjustedV = sig.v + 4; // EthSign type
+    const signature = ethers_1.ethers.concat([sig.r, sig.s, ethers_1.ethers.toBeHex(adjustedV, 1)]);
+    const safeWithSigner = new ethers_1.ethers.Contract(safeAddress, exports.SAFE_ABI, signer);
+    const tx = await safeWithSigner.execTransaction(to, value, data, operation, safeTxGas, baseGas, gasPrice, gasToken, refundReceiver, signature);
+    await tx.wait();
+    const check = await safeProxy.isModuleEnabled(moduleAddress);
+    if (!check) {
+        throw new Error('Module verification failed');
+    }
+}

package/dist/index.d.ts

@@ -2,6 +2,11 @@ export * from './client';
 export * from './config';
 export * from './types';
 export * from './api/jobs';
-export { createJobOnChain } from './contracts/JobRegistry';
+export * from './api/getjob';
+export * from './api/getUserData';
+export * from './api/checkTgBalance';
+export * from './api/topupTg';
+export * from './api/deleteJob';
+export * from './api/getJobDataById';
 export * from './contracts';
 export * from './utils/errors';

package/dist/index.js

@@ -14,12 +14,16 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.createJobOnChain = void 0;
 __exportStar(require("./client"), exports);
 __exportStar(require("./config"), exports);
 __exportStar(require("./types"), exports);
 __exportStar(require("./api/jobs"), exports);
-var JobRegistry_1 = require("./contracts/JobRegistry");
-Object.defineProperty(exports, "createJobOnChain", { enumerable: true, get: function () { return JobRegistry_1.createJobOnChain; } });
+__exportStar(require("./api/getjob"), exports);
+__exportStar(require("./api/getUserData"), exports);
+__exportStar(require("./api/checkTgBalance"), exports);
+__exportStar(require("./api/topupTg"), exports);
+__exportStar(require("./api/deleteJob"), exports);
+__exportStar(require("./api/getJobDataById"), exports);
+// export { createJobOnChain } from './contracts/JobRegistry';
 __exportStar(require("./contracts"), exports);
 __exportStar(require("./utils/errors"), exports);

package/dist/types.d.ts

@@ -17,6 +17,7 @@ export declare enum ArgType {
     Static = "static",
     Dynamic = "dynamic"
 }
+export type WalletMode = 'regular' | 'safe';
 export type CreateJobInput = (TimeBasedJobInput & {
     jobType: JobType.Time;
     argType: ArgType.Static | ArgType.Dynamic;
@@ -43,6 +44,8 @@ export interface TimeBasedJobInput {
     arguments?: string[];
     dynamicArgumentsScriptUrl?: string;
     autotopupTG?: boolean;
+    walletMode?: WalletMode;
+    safeAddress?: string;
 }
 export interface EventBasedJobInput {
     jobTitle: string;
@@ -60,6 +63,8 @@ export interface EventBasedJobInput {
     arguments?: string[];
     dynamicArgumentsScriptUrl?: string;
     autotopupTG?: boolean;
+    walletMode?: WalletMode;
+    safeAddress?: string;
 }
 export interface ConditionBasedJobInput {
     jobTitle: string;
@@ -79,6 +84,8 @@ export interface ConditionBasedJobInput {
     arguments?: string[];
     dynamicArgumentsScriptUrl?: string;
     autotopupTG?: boolean;
+    walletMode?: WalletMode;
+    safeAddress?: string;
 }
 export interface CreateJobData {
     job_id: string;

package/dist/utils/errors.d.ts

@@ -2,3 +2,7 @@ export declare class TriggerXError extends Error {
     constructor(message: string);
 }
 export declare function wrapError(error: unknown): TriggerXError;
+export declare class ValidationError extends Error {
+    field: string;
+    constructor(field: string, message: string);
+}

package/dist/utils/errors.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TriggerXError = void 0;
+exports.ValidationError = exports.TriggerXError = void 0;
 exports.wrapError = wrapError;
 class TriggerXError extends Error {
     constructor(message) {
@@ -15,3 +15,11 @@ function wrapError(error) {
     }
     return new TriggerXError('Unknown error');
 }
+class ValidationError extends Error {
+    constructor(field, message) {
+        super(message);
+        this.name = 'ValidationError';
+        this.field = field;
+    }
+}
+exports.ValidationError = ValidationError;

package/dist/utils/validation.d.ts

@@ -0,0 +1,5 @@
+import { TimeBasedJobInput, EventBasedJobInput, ConditionBasedJobInput } from '../types';
+export declare function validateTimeBasedJobInput(input: TimeBasedJobInput, argType: 'static' | 'dynamic' | 1 | 2 | undefined): void;
+export declare function validateEventBasedJobInput(input: EventBasedJobInput, argType: 'static' | 'dynamic' | 1 | 2 | undefined): void;
+export declare function validateConditionBasedJobInput(input: ConditionBasedJobInput, argType: 'static' | 'dynamic' | 1 | 2 | undefined): void;
+export declare function validateJobInput(jobInput: TimeBasedJobInput | EventBasedJobInput | ConditionBasedJobInput, argType?: 'static' | 'dynamic' | 1 | 2): void;

package/dist/utils/validation.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateTimeBasedJobInput = validateTimeBasedJobInput;
+exports.validateEventBasedJobInput = validateEventBasedJobInput;
+exports.validateConditionBasedJobInput = validateConditionBasedJobInput;
+exports.validateJobInput = validateJobInput;
+const ethers_1 = require("ethers");
+const errors_1 = require("./errors");
+function isNonEmptyString(value) {
+    return typeof value === 'string' && value.trim().length > 0;
+}
+function isValidUrl(value) {
+    try {
+        // eslint-disable-next-line no-new
+        new URL(value);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function buildFunctionSignature(name, inputs) {
+    const types = (inputs || []).map((i) => i.type).join(',');
+    return `${name}(${types})`;
+}
+function parseAbi(abiString) {
+    if (!isNonEmptyString(abiString))
+        return null;
+    try {
+        const parsed = JSON.parse(abiString);
+        return Array.isArray(parsed) ? parsed : null;
+    }
+    catch {
+        return null;
+    }
+}
+function validateContractBasics(address, abi, targetFunction, fieldPrefix = 'contract') {
+    if (!isNonEmptyString(address)) {
+        throw new errors_1.ValidationError(`${fieldPrefix}Address`, 'Contract address is required.');
+    }
+    if (!ethers_1.ethers.isAddress(address)) {
+        throw new errors_1.ValidationError(`${fieldPrefix}Address`, 'Invalid contract address.');
+    }
+    if (!isNonEmptyString(abi)) {
+        throw new errors_1.ValidationError(`${fieldPrefix}ABI`, 'Contract ABI must be provided.');
+    }
+    if (!isNonEmptyString(targetFunction)) {
+        throw new errors_1.ValidationError(`${fieldPrefix}Target`, 'Target function must be selected.');
+    }
+}
+function validateStaticArguments(abiString, targetFunction, args, fieldPrefix = 'contract') {
+    const abi = parseAbi(abiString);
+    if (!abi) {
+        // If ABI is invalid JSON, surface a clear error
+        throw new errors_1.ValidationError(`${fieldPrefix}ABI`, 'Contract ABI must be valid JSON array.');
+    }
+    const fnItem = abi.find((item) => item && item.type === 'function' && buildFunctionSignature(item.name, item.inputs) === targetFunction);
+    if (!fnItem)
+        return; // If we cannot find it, skip strict arg validation
+    const inputs = Array.isArray(fnItem.inputs) ? fnItem.inputs : [];
+    if (inputs.length === 0)
+        return;
+    if (!args || args.length < inputs.length) {
+        throw new errors_1.ValidationError(`${fieldPrefix}Args`, 'All function arguments are required for static argument type.');
+    }
+    const missing = inputs.findIndex((_, idx) => !isNonEmptyString(args[idx]));
+    if (missing !== -1) {
+        throw new errors_1.ValidationError(`${fieldPrefix}Args`, 'All function arguments are required for static argument type.');
+    }
+}
+function validateTimeBasedJobInput(input, argType) {
+    if (!isNonEmptyString(input.jobTitle)) {
+        throw new errors_1.ValidationError('jobTitle', 'Job title is required.');
+    }
+    if (!input.timeFrame || input.timeFrame <= 0) {
+        throw new errors_1.ValidationError('timeframe', 'Timeframe must be a positive number of seconds.');
+    }
+    if (!isNonEmptyString(input.timezone)) {
+        throw new errors_1.ValidationError('timezone', 'Timezone is required.');
+    }
+    if (!isNonEmptyString(input.chainId)) {
+        throw new errors_1.ValidationError('chainId', 'Chain ID is required.');
+    }
+    // Schedule-specific required fields
+    if (input.scheduleType === 'interval') {
+        if (input.timeInterval === undefined || input.timeInterval === null || input.timeInterval <= 0) {
+            throw new errors_1.ValidationError('timeInterval', 'timeInterval is required and must be > 0 when scheduleType is interval.');
+        }
+        if (input.timeInterval > input.timeFrame) {
+            throw new errors_1.ValidationError('timeInterval', 'Time interval cannot exceed the timeframe.');
+        }
+    }
+    else if (input.scheduleType === 'cron') {
+        if (!isNonEmptyString(input.cronExpression)) {
+            throw new errors_1.ValidationError('cronExpression', 'cronExpression is required when scheduleType is cron.');
+        }
+    }
+    else if (input.scheduleType === 'specific') {
+        if (!isNonEmptyString(input.specificSchedule)) {
+            throw new errors_1.ValidationError('specificSchedule', 'specificSchedule is required when scheduleType is specific.');
+        }
+    }
+    else {
+        throw new errors_1.ValidationError('scheduleType', 'scheduleType must be one of interval | cron | specific.');
+    }
+    validateContractBasics(input.targetContractAddress, input.abi, input.targetFunction, 'contract');
+    // Arg type checks
+    const isDynamic = argType === 'dynamic' || argType === 2;
+    if (isDynamic) {
+        if (!isNonEmptyString(input.dynamicArgumentsScriptUrl) || !isValidUrl(input.dynamicArgumentsScriptUrl)) {
+            throw new errors_1.ValidationError('contractIpfs', 'IPFS Code URL is required and must be valid for dynamic argument type.');
+        }
+    }
+    else {
+        validateStaticArguments(input.abi, input.targetFunction, input.arguments, 'contract');
+    }
+}
+function validateEventBasedJobInput(input, argType) {
+    if (!isNonEmptyString(input.jobTitle)) {
+        throw new errors_1.ValidationError('jobTitle', 'Job title is required.');
+    }
+    if (!input.timeFrame || input.timeFrame <= 0) {
+        throw new errors_1.ValidationError('timeframe', 'Timeframe must be a positive number of seconds.');
+    }
+    if (!isNonEmptyString(input.timezone)) {
+        throw new errors_1.ValidationError('timezone', 'Timezone is required.');
+    }
+    if (!isNonEmptyString(input.chainId)) {
+        throw new errors_1.ValidationError('chainId', 'Chain ID is required.');
+    }
+    if (!isNonEmptyString(input.triggerChainId)) {
+        throw new errors_1.ValidationError('triggerChainId', 'Trigger chain ID is required.');
+    }
+    validateContractBasics(input.triggerContractAddress, input.abi, input.triggerEvent, 'eventContract');
+    validateContractBasics(input.targetContractAddress, input.abi, input.targetFunction, 'contract');
+    const isDynamic = argType === 'dynamic' || argType === 2;
+    if (isDynamic) {
+        if (!isNonEmptyString(input.dynamicArgumentsScriptUrl) || !isValidUrl(input.dynamicArgumentsScriptUrl)) {
+            throw new errors_1.ValidationError('contractIpfs', 'IPFS Code URL is required and must be valid for dynamic argument type.');
+        }
+    }
+    else {
+        validateStaticArguments(input.abi, input.targetFunction, input.arguments, 'contract');
+    }
+}
+function validateConditionBasedJobInput(input, argType) {
+    if (!isNonEmptyString(input.jobTitle)) {
+        throw new errors_1.ValidationError('jobTitle', 'Job title is required.');
+    }
+    if (!input.timeFrame || input.timeFrame <= 0) {
+        throw new errors_1.ValidationError('timeframe', 'Timeframe must be a positive number of seconds.');
+    }
+    if (!isNonEmptyString(input.timezone)) {
+        throw new errors_1.ValidationError('timezone', 'Timezone is required.');
+    }
+    if (!isNonEmptyString(input.chainId)) {
+        throw new errors_1.ValidationError('chainId', 'Chain ID is required.');
+    }
+    // Condition fields
+    if (!isNonEmptyString(input.conditionType)) {
+        throw new errors_1.ValidationError('contractConditionType', 'Condition type is required.');
+    }
+    if (!isNonEmptyString(input.valueSourceType)) {
+        throw new errors_1.ValidationError('contractSourceType', 'Value source type is required.');
+    }
+    if (!isNonEmptyString(input.valueSourceUrl) || !isValidUrl(input.valueSourceUrl)) {
+        throw new errors_1.ValidationError('contractSourceUrl', 'Source URL is required and must be valid.');
+    }
+    if (input.conditionType === 'between') {
+        if (input.upperLimit === undefined || input.lowerLimit === undefined || input.upperLimit === null || input.lowerLimit === null) {
+            throw new errors_1.ValidationError('contractLimits', 'Both upper and lower limits are required.');
+        }
+    }
+    else {
+        if (input.upperLimit === undefined || input.upperLimit === null) {
+            throw new errors_1.ValidationError('contractLimits', 'Value is required.');
+        }
+    }
+    validateContractBasics(input.targetContractAddress, input.abi, input.targetFunction, 'contract');
+    const isDynamic = argType === 'dynamic' || argType === 2;
+    if (isDynamic) {
+        if (!isNonEmptyString(input.dynamicArgumentsScriptUrl) || !isValidUrl(input.dynamicArgumentsScriptUrl)) {
+            throw new errors_1.ValidationError('contractIpfs', 'IPFS Code URL is required and must be valid for dynamic argument type.');
+        }
+    }
+    else {
+        validateStaticArguments(input.abi, input.targetFunction, input.arguments, 'contract');
+    }
+}
+function validateJobInput(jobInput, argType) {
+    if ('scheduleType' in jobInput) {
+        validateTimeBasedJobInput(jobInput, argType);
+    }
+    else if ('triggerChainId' in jobInput) {
+        validateEventBasedJobInput(jobInput, argType);
+    }
+    else {
+        validateConditionBasedJobInput(jobInput, argType);
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sdk-triggerx",
-  "version": "0.1.15",
+  "version": "0.1.17",
   "description": "SDK for interacting with the TriggerX backend and smart contracts.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",