sdk-triggerx 0.1.16 → 0.1.18

package/dist/contracts/safe/SafeWallet.js

@@ -0,0 +1,109 @@
+"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)",
+    // module management
+    "function enableModule(address module)",
+    // 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)",
+    // Add getTransactionHash for onchain hash calculation
+    "function getTransactionHash(address to,uint256 value,bytes data,uint8 operation,uint256 safeTxGas,uint256 baseGas,uint256 gasPrice,address gasToken,address refundReceiver,uint256 nonce) view returns (bytes32)"
+];
+// 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) {
+        console.log('Module is already enabled');
+        return;
+    }
+    // First, let's try the direct approach for single-owner Safes
+    try {
+        console.log('Attempting direct enableModule call...');
+        const safeWithSigner = new ethers_1.ethers.Contract(safeAddress, exports.SAFE_ABI, signer);
+        const tx = await safeWithSigner.enableModule(moduleAddress);
+        await tx.wait();
+        console.log('Module enabled via direct call');
+        return;
+    }
+    catch (error) {
+        console.log('Direct call failed, trying execTransaction approach...');
+    }
+    // If direct call fails, use execTransaction with proper signature
+    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 = 0;
+    const operation = 0; // CALL
+    const safeTxGas = 0;
+    const baseGas = 0;
+    const gasPrice = 0;
+    const gasToken = ethers_1.ethers.ZeroAddress;
+    const refundReceiver = ethers_1.ethers.ZeroAddress;
+    // Use contract to compute tx hash to avoid mismatch
+    const safeTxHash = await safeProxy.getTransactionHash(to, value, data, operation, safeTxGas, baseGas, gasPrice, gasToken, refundReceiver, safeNonce);
+    // Sign the transaction hash using the connected wallet (personal_sign)
+    // For Gnosis Safe, personal_sign signatures must have v adjusted by +4 to mark EthSign
+    const rawSignature = await signer.signMessage(ethers_1.ethers.getBytes(safeTxHash));
+    const sigObj = ethers_1.ethers.Signature.from(rawSignature);
+    const adjustedV = sigObj.v + 4;
+    const signature = ethers_1.ethers.concat([
+        sigObj.r,
+        sigObj.s,
+        ethers_1.ethers.toBeHex(adjustedV, 1),
+    ]);
+    // Execute the transaction through Safe's execTransaction
+    const safeProxyWithSigner = new ethers_1.ethers.Contract(safeAddress, exports.SAFE_ABI, signer);
+    const tx = await safeProxyWithSigner.execTransaction(to, value, data, operation, safeTxGas, baseGas, gasPrice, gasToken, refundReceiver, signature);
+    await tx.wait();
+    // Verify module is enabled
+    const isNowEnabled = await safeProxy.isModuleEnabled(moduleAddress);
+    if (!isNowEnabled) {
+        throw new Error("Module verification failed");
+    }
+    console.log('Module enabled successfully via execTransaction');
+}

package/dist/types.d.ts

@@ -8,6 +8,21 @@ export interface ApiResponse<T> {
     data: T;
     error?: string;
 }
+export type HttpStatusCode = 400 | 401 | 402 | 403 | 404 | 405 | 406 | 407 | 408 | 409 | 410 | 411 | 412 | 413 | 414 | 415 | 416 | 417 | 418 | 421 | 422 | 423 | 424 | 425 | 426 | 428 | 429 | 431 | 451 | 500 | 501 | 502 | 503 | 504 | 505 | 506 | 507 | 508 | 510 | 511;
+export type ApiErrorCode = 'BAD_REQUEST' | 'UNAUTHORIZED' | 'PAYMENT_REQUIRED' | 'FORBIDDEN' | 'NOT_FOUND' | 'METHOD_NOT_ALLOWED' | 'NOT_ACCEPTABLE' | 'PROXY_AUTHENTICATION_REQUIRED' | 'REQUEST_TIMEOUT' | 'CONFLICT' | 'GONE' | 'LENGTH_REQUIRED' | 'PRECONDITION_FAILED' | 'PAYLOAD_TOO_LARGE' | 'URI_TOO_LONG' | 'UNSUPPORTED_MEDIA_TYPE' | 'RANGE_NOT_SATISFIABLE' | 'EXPECTATION_FAILED' | 'IM_A_TEAPOT' | 'MISDIRECTED_REQUEST' | 'UNPROCESSABLE_ENTITY' | 'LOCKED' | 'FAILED_DEPENDENCY' | 'TOO_EARLY' | 'UPGRADE_REQUIRED' | 'PRECONDITION_REQUIRED' | 'TOO_MANY_REQUESTS' | 'REQUEST_HEADER_FIELDS_TOO_LARGE' | 'UNAVAILABLE_FOR_LEGAL_REASONS' | 'INTERNAL_SERVER_ERROR' | 'NOT_IMPLEMENTED' | 'BAD_GATEWAY' | 'SERVICE_UNAVAILABLE' | 'GATEWAY_TIMEOUT' | 'HTTP_VERSION_NOT_SUPPORTED' | 'VARIANT_ALSO_NEGOTIATES' | 'INSUFFICIENT_STORAGE' | 'LOOP_DETECTED' | 'NOT_EXTENDED' | 'NETWORK_AUTHENTICATION_REQUIRED' | 'VALIDATION_ERROR' | 'NETWORK_ERROR' | 'AUTHENTICATION_ERROR' | 'CONTRACT_ERROR' | 'BALANCE_ERROR' | 'CONFIGURATION_ERROR' | 'RATE_LIMIT_EXCEEDED' | 'INSUFFICIENT_FUNDS' | 'INVALID_SIGNATURE' | 'TRANSACTION_FAILED' | 'CONTRACT_REVERT' | 'GAS_ESTIMATION_FAILED' | 'NONCE_TOO_LOW' | 'NONCE_TOO_HIGH' | 'REPLACEMENT_UNDERPRICED' | 'UNKNOWN_ERROR';
+export interface ErrorResponse {
+    success: false;
+    error: string;
+    errorCode: ApiErrorCode;
+    httpStatusCode?: HttpStatusCode;
+    errorType: 'VALIDATION_ERROR' | 'NETWORK_ERROR' | 'AUTHENTICATION_ERROR' | 'CONTRACT_ERROR' | 'API_ERROR' | 'BALANCE_ERROR' | 'CONFIGURATION_ERROR' | 'UNKNOWN_ERROR';
+    details?: any;
+}
+export interface SuccessResponse<T> {
+    success: true;
+    data: T;
+}
+export type ApiResult<T> = SuccessResponse<T> | ErrorResponse;
 export declare enum JobType {
     Time = "time",
     Event = "event",
@@ -17,6 +32,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;
@@ -36,13 +52,19 @@ export interface TimeBasedJobInput {
     specificSchedule?: string;
     timezone: string;
     chainId: string;
-    targetContractAddress: string;
-    targetFunction: string;
-    abi: string;
+    targetContractAddress?: string;
+    targetFunction?: string;
+    abi?: string;
     isImua?: boolean;
     arguments?: string[];
     dynamicArgumentsScriptUrl?: string;
     autotopupTG?: boolean;
+    walletMode?: WalletMode;
+    /**
+     * The Safe address to use when walletMode is 'safe'.
+     * Required if walletMode is 'safe'.
+     */
+    safeAddress: string;
 }
 export interface EventBasedJobInput {
     jobTitle: string;
@@ -53,13 +75,19 @@ export interface EventBasedJobInput {
     timezone: string;
     recurring?: boolean;
     chainId: string;
-    targetContractAddress: string;
-    targetFunction: string;
-    abi: string;
+    targetContractAddress?: string;
+    targetFunction?: string;
+    abi?: string;
     isImua?: boolean;
     arguments?: string[];
     dynamicArgumentsScriptUrl?: string;
     autotopupTG?: boolean;
+    walletMode?: WalletMode;
+    /**
+     * The Safe address to use when walletMode is 'safe'.
+     * Required if walletMode is 'safe'.
+     */
+    safeAddress: string;
 }
 export interface ConditionBasedJobInput {
     jobTitle: string;
@@ -72,13 +100,19 @@ export interface ConditionBasedJobInput {
     timezone: string;
     recurring?: boolean;
     chainId: string;
-    targetContractAddress: string;
-    targetFunction: string;
-    abi: string;
+    targetContractAddress?: string;
+    targetFunction?: string;
+    abi?: string;
     isImua?: boolean;
     arguments?: string[];
     dynamicArgumentsScriptUrl?: string;
     autotopupTG?: boolean;
+    walletMode?: WalletMode;
+    /**
+     * The Safe address to use when walletMode is 'safe'.
+     * Required if walletMode is 'safe'.
+     */
+    safeAddress: string;
 }
 export interface CreateJobData {
     job_id: string;
@@ -118,6 +152,10 @@ export interface JobResponse {
     success: boolean;
     data?: any;
     error?: string;
+    errorCode?: ApiErrorCode;
+    httpStatusCode?: HttpStatusCode;
+    errorType?: 'VALIDATION_ERROR' | 'NETWORK_ERROR' | 'AUTHENTICATION_ERROR' | 'CONTRACT_ERROR' | 'API_ERROR' | 'BALANCE_ERROR' | 'CONFIGURATION_ERROR' | 'UNKNOWN_ERROR';
+    details?: any;
 }
 export interface JobDataAPI {
     job_id: string;
@@ -209,6 +247,10 @@ export interface ConditionJobData {
 export interface JobResponseUser {
     success: boolean;
     error?: string;
+    errorCode?: ApiErrorCode;
+    httpStatusCode?: HttpStatusCode;
+    errorType?: 'VALIDATION_ERROR' | 'NETWORK_ERROR' | 'AUTHENTICATION_ERROR' | 'CONTRACT_ERROR' | 'API_ERROR' | 'BALANCE_ERROR' | 'CONFIGURATION_ERROR' | 'UNKNOWN_ERROR';
+    details?: any;
     jobs?: JobResponseAPI;
 }
 export interface JobResponseAPI {

package/dist/utils/errors.d.ts

@@ -1,4 +1,43 @@
+import { ApiErrorCode, HttpStatusCode } from '../types';
 export declare class TriggerXError extends Error {
-    constructor(message: string);
+    readonly errorCode: ApiErrorCode;
+    readonly httpStatusCode?: HttpStatusCode;
+    readonly errorType: 'VALIDATION_ERROR' | 'NETWORK_ERROR' | 'AUTHENTICATION_ERROR' | 'CONTRACT_ERROR' | 'API_ERROR' | 'BALANCE_ERROR' | 'CONFIGURATION_ERROR' | 'UNKNOWN_ERROR';
+    readonly details?: any;
+    constructor(message: string, errorCode: ApiErrorCode, errorType: 'VALIDATION_ERROR' | 'NETWORK_ERROR' | 'AUTHENTICATION_ERROR' | 'CONTRACT_ERROR' | 'API_ERROR' | 'BALANCE_ERROR' | 'CONFIGURATION_ERROR' | 'UNKNOWN_ERROR', details?: any, httpStatusCode?: HttpStatusCode);
 }
+export declare const HTTP_STATUS_TO_ERROR_CODE: Record<HttpStatusCode, ApiErrorCode>;
+export declare const ERROR_PATTERN_TO_CODE: Record<string, ApiErrorCode>;
 export declare function wrapError(error: unknown): TriggerXError;
+export declare function extractHttpStatusCode(error: any): HttpStatusCode | undefined;
+export declare function determineErrorCode(error: any, httpStatusCode?: HttpStatusCode): ApiErrorCode;
+export declare class ValidationError extends TriggerXError {
+    readonly field: string;
+    constructor(field: string, message: string, details?: any, httpStatusCode?: HttpStatusCode);
+}
+export declare class NetworkError extends TriggerXError {
+    constructor(message: string, details?: any, httpStatusCode?: HttpStatusCode);
+}
+export declare class AuthenticationError extends TriggerXError {
+    constructor(message: string, details?: any, httpStatusCode?: HttpStatusCode);
+}
+export declare class ContractError extends TriggerXError {
+    constructor(message: string, details?: any, httpStatusCode?: HttpStatusCode);
+}
+export declare class ApiError extends TriggerXError {
+    constructor(message: string, details?: any, httpStatusCode?: HttpStatusCode);
+}
+export declare class BalanceError extends TriggerXError {
+    constructor(message: string, details?: any, httpStatusCode?: HttpStatusCode);
+}
+export declare class ConfigurationError extends TriggerXError {
+    constructor(message: string, details?: any, httpStatusCode?: HttpStatusCode);
+}
+export declare function createErrorResponse(error: TriggerXError | Error | unknown, fallbackMessage?: string): {
+    success: false;
+    error: string;
+    errorCode: ApiErrorCode;
+    httpStatusCode?: HttpStatusCode;
+    errorType: 'VALIDATION_ERROR' | 'NETWORK_ERROR' | 'AUTHENTICATION_ERROR' | 'CONTRACT_ERROR' | 'API_ERROR' | 'BALANCE_ERROR' | 'CONFIGURATION_ERROR' | 'UNKNOWN_ERROR';
+    details?: any;
+};

package/dist/utils/errors.js

@@ -1,17 +1,240 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.TriggerXError = void 0;
+exports.ConfigurationError = exports.BalanceError = exports.ApiError = exports.ContractError = exports.AuthenticationError = exports.NetworkError = exports.ValidationError = exports.ERROR_PATTERN_TO_CODE = exports.HTTP_STATUS_TO_ERROR_CODE = exports.TriggerXError = void 0;
 exports.wrapError = wrapError;
+exports.extractHttpStatusCode = extractHttpStatusCode;
+exports.determineErrorCode = determineErrorCode;
+exports.createErrorResponse = createErrorResponse;
 class TriggerXError extends Error {
-    constructor(message) {
+    constructor(message, errorCode, errorType, details, httpStatusCode) {
         super(message);
         this.name = 'TriggerXError';
+        this.errorCode = errorCode;
+        this.errorType = errorType;
+        this.details = details;
+        this.httpStatusCode = httpStatusCode;
     }
 }
 exports.TriggerXError = TriggerXError;
+// HTTP Status Code to Error Code Mapping
+exports.HTTP_STATUS_TO_ERROR_CODE = {
+    // 4xx Client Errors
+    400: 'BAD_REQUEST',
+    401: 'UNAUTHORIZED',
+    402: 'PAYMENT_REQUIRED',
+    403: 'FORBIDDEN',
+    404: 'NOT_FOUND',
+    405: 'METHOD_NOT_ALLOWED',
+    406: 'NOT_ACCEPTABLE',
+    407: 'PROXY_AUTHENTICATION_REQUIRED',
+    408: 'REQUEST_TIMEOUT',
+    409: 'CONFLICT',
+    410: 'GONE',
+    411: 'LENGTH_REQUIRED',
+    412: 'PRECONDITION_FAILED',
+    413: 'PAYLOAD_TOO_LARGE',
+    414: 'URI_TOO_LONG',
+    415: 'UNSUPPORTED_MEDIA_TYPE',
+    416: 'RANGE_NOT_SATISFIABLE',
+    417: 'EXPECTATION_FAILED',
+    418: 'IM_A_TEAPOT',
+    421: 'MISDIRECTED_REQUEST',
+    422: 'UNPROCESSABLE_ENTITY',
+    423: 'LOCKED',
+    424: 'FAILED_DEPENDENCY',
+    425: 'TOO_EARLY',
+    426: 'UPGRADE_REQUIRED',
+    428: 'PRECONDITION_REQUIRED',
+    429: 'TOO_MANY_REQUESTS',
+    431: 'REQUEST_HEADER_FIELDS_TOO_LARGE',
+    451: 'UNAVAILABLE_FOR_LEGAL_REASONS',
+    // 5xx Server Errors
+    500: 'INTERNAL_SERVER_ERROR',
+    501: 'NOT_IMPLEMENTED',
+    502: 'BAD_GATEWAY',
+    503: 'SERVICE_UNAVAILABLE',
+    504: 'GATEWAY_TIMEOUT',
+    505: 'HTTP_VERSION_NOT_SUPPORTED',
+    506: 'VARIANT_ALSO_NEGOTIATES',
+    507: 'INSUFFICIENT_STORAGE',
+    508: 'LOOP_DETECTED',
+    510: 'NOT_EXTENDED',
+    511: 'NETWORK_AUTHENTICATION_REQUIRED'
+};
+// Error message patterns to error code mapping
+exports.ERROR_PATTERN_TO_CODE = {
+    'network': 'NETWORK_ERROR',
+    'timeout': 'REQUEST_TIMEOUT',
+    'connection': 'NETWORK_ERROR',
+    'unauthorized': 'UNAUTHORIZED',
+    'forbidden': 'FORBIDDEN',
+    'not found': 'NOT_FOUND',
+    'bad request': 'BAD_REQUEST',
+    'validation': 'VALIDATION_ERROR',
+    'invalid': 'VALIDATION_ERROR',
+    'missing': 'VALIDATION_ERROR',
+    'required': 'VALIDATION_ERROR',
+    'insufficient': 'INSUFFICIENT_FUNDS',
+    'balance': 'BALANCE_ERROR',
+    'contract': 'CONTRACT_ERROR',
+    'transaction': 'TRANSACTION_FAILED',
+    'gas': 'GAS_ESTIMATION_FAILED',
+    'nonce': 'NONCE_TOO_LOW',
+    'revert': 'CONTRACT_REVERT',
+    'rate limit': 'RATE_LIMIT_EXCEEDED',
+    'too many': 'TOO_MANY_REQUESTS',
+    'server error': 'INTERNAL_SERVER_ERROR',
+    'service unavailable': 'SERVICE_UNAVAILABLE',
+    'bad gateway': 'BAD_GATEWAY',
+    'gateway timeout': 'GATEWAY_TIMEOUT'
+};
 function wrapError(error) {
+    if (error instanceof TriggerXError) {
+        return error;
+    }
     if (error instanceof Error) {
-        return new TriggerXError(error.message);
+        return new TriggerXError(error.message, 'UNKNOWN_ERROR', 'UNKNOWN_ERROR');
+    }
+    return new TriggerXError('Unknown error', 'UNKNOWN_ERROR', 'UNKNOWN_ERROR');
+}
+// Helper function to extract HTTP status code from error
+function extractHttpStatusCode(error) {
+    if (error?.response?.status) {
+        return error.response.status;
+    }
+    if (error?.status) {
+        return error.status;
+    }
+    if (error?.code && typeof error.code === 'number') {
+        return error.code;
+    }
+    return undefined;
+}
+// Helper function to determine error code from error message and status
+function determineErrorCode(error, httpStatusCode) {
+    // First check if we have an HTTP status code
+    if (httpStatusCode && exports.HTTP_STATUS_TO_ERROR_CODE[httpStatusCode]) {
+        return exports.HTTP_STATUS_TO_ERROR_CODE[httpStatusCode];
+    }
+    // Extract status code from error if not provided
+    const statusCode = httpStatusCode || extractHttpStatusCode(error);
+    if (statusCode && exports.HTTP_STATUS_TO_ERROR_CODE[statusCode]) {
+        return exports.HTTP_STATUS_TO_ERROR_CODE[statusCode];
+    }
+    // Check error message patterns
+    const message = error?.message?.toLowerCase() || '';
+    for (const [pattern, code] of Object.entries(exports.ERROR_PATTERN_TO_CODE)) {
+        if (message.includes(pattern)) {
+            return code;
+        }
+    }
+    return 'UNKNOWN_ERROR';
+}
+class ValidationError extends TriggerXError {
+    constructor(field, message, details, httpStatusCode) {
+        super(message, 'VALIDATION_ERROR', 'VALIDATION_ERROR', details, httpStatusCode);
+        this.name = 'ValidationError';
+        this.field = field;
+    }
+}
+exports.ValidationError = ValidationError;
+class NetworkError extends TriggerXError {
+    constructor(message, details, httpStatusCode) {
+        super(message, 'NETWORK_ERROR', 'NETWORK_ERROR', details, httpStatusCode);
+        this.name = 'NetworkError';
+    }
+}
+exports.NetworkError = NetworkError;
+class AuthenticationError extends TriggerXError {
+    constructor(message, details, httpStatusCode) {
+        super(message, 'AUTHENTICATION_ERROR', 'AUTHENTICATION_ERROR', details, httpStatusCode);
+        this.name = 'AuthenticationError';
+    }
+}
+exports.AuthenticationError = AuthenticationError;
+class ContractError extends TriggerXError {
+    constructor(message, details, httpStatusCode) {
+        super(message, 'CONTRACT_ERROR', 'CONTRACT_ERROR', details, httpStatusCode);
+        this.name = 'ContractError';
+    }
+}
+exports.ContractError = ContractError;
+class ApiError extends TriggerXError {
+    constructor(message, details, httpStatusCode) {
+        super(message, 'INTERNAL_SERVER_ERROR', 'API_ERROR', details, httpStatusCode);
+        this.name = 'ApiError';
+    }
+}
+exports.ApiError = ApiError;
+class BalanceError extends TriggerXError {
+    constructor(message, details, httpStatusCode) {
+        super(message, 'BALANCE_ERROR', 'BALANCE_ERROR', details, httpStatusCode);
+        this.name = 'BalanceError';
+    }
+}
+exports.BalanceError = BalanceError;
+class ConfigurationError extends TriggerXError {
+    constructor(message, details, httpStatusCode) {
+        super(message, 'CONFIGURATION_ERROR', 'CONFIGURATION_ERROR', details, httpStatusCode);
+        this.name = 'ConfigurationError';
+    }
+}
+exports.ConfigurationError = ConfigurationError;
+// Helper function to create error response
+function createErrorResponse(error, fallbackMessage = 'An unexpected error occurred') {
+    if (error instanceof TriggerXError) {
+        return {
+            success: false,
+            error: error.message,
+            errorCode: error.errorCode,
+            httpStatusCode: error.httpStatusCode,
+            errorType: error.errorType,
+            details: error.details
+        };
+    }
+    if (error instanceof Error) {
+        const httpStatusCode = extractHttpStatusCode(error);
+        const errorCode = determineErrorCode(error, httpStatusCode);
+        const errorType = getErrorTypeFromCode(errorCode);
+        return {
+            success: false,
+            error: error.message,
+            errorCode,
+            httpStatusCode,
+            errorType,
+            details: { originalError: error.name }
+        };
+    }
+    return {
+        success: false,
+        error: fallbackMessage,
+        errorCode: 'UNKNOWN_ERROR',
+        errorType: 'UNKNOWN_ERROR',
+        details: { originalError: String(error) }
+    };
+}
+// Helper function to determine error type from error code
+function getErrorTypeFromCode(errorCode) {
+    if (errorCode === 'VALIDATION_ERROR' || errorCode === 'BAD_REQUEST' || errorCode === 'UNPROCESSABLE_ENTITY') {
+        return 'VALIDATION_ERROR';
+    }
+    if (errorCode === 'NETWORK_ERROR' || errorCode === 'REQUEST_TIMEOUT' || errorCode === 'SERVICE_UNAVAILABLE' || errorCode === 'BAD_GATEWAY' || errorCode === 'GATEWAY_TIMEOUT') {
+        return 'NETWORK_ERROR';
+    }
+    if (errorCode === 'AUTHENTICATION_ERROR' || errorCode === 'UNAUTHORIZED' || errorCode === 'FORBIDDEN' || errorCode === 'PROXY_AUTHENTICATION_REQUIRED') {
+        return 'AUTHENTICATION_ERROR';
+    }
+    if (errorCode === 'CONTRACT_ERROR' || errorCode === 'TRANSACTION_FAILED' || errorCode === 'CONTRACT_REVERT' || errorCode === 'GAS_ESTIMATION_FAILED' || errorCode === 'NONCE_TOO_LOW' || errorCode === 'NONCE_TOO_HIGH' || errorCode === 'REPLACEMENT_UNDERPRICED') {
+        return 'CONTRACT_ERROR';
+    }
+    if (errorCode === 'BALANCE_ERROR' || errorCode === 'INSUFFICIENT_FUNDS') {
+        return 'BALANCE_ERROR';
+    }
+    if (errorCode === 'CONFIGURATION_ERROR') {
+        return 'CONFIGURATION_ERROR';
+    }
+    if (errorCode.includes('API') || errorCode === 'INTERNAL_SERVER_ERROR' || errorCode === 'NOT_IMPLEMENTED' || errorCode === 'NOT_FOUND' || errorCode === 'METHOD_NOT_ALLOWED' || errorCode === 'CONFLICT' || errorCode === 'TOO_MANY_REQUESTS' || errorCode === 'RATE_LIMIT_EXCEEDED') {
+        return 'API_ERROR';
     }
-    return new TriggerXError('Unknown error');
+    return 'UNKNOWN_ERROR';
 }

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;