sdk-triggerx 0.1.17 → 0.1.19

package/dist/contracts/safe/SafeWallet.js

@@ -9,6 +9,8 @@ const ethers_1 = require("ethers");
 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
@@ -18,6 +20,8 @@ exports.SAFE_ABI = [
     // 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)");
@@ -52,38 +56,54 @@ async function enableSafeModule(safeAddress, signer, moduleAddress) {
     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)
+    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 = 0n;
+    const value = 0;
     const operation = 0; // CALL
-    const safeTxGas = 0n;
-    const baseGas = 0n;
-    const gasPrice = 0n;
+    const safeTxGas = 0;
+    const baseGas = 0;
+    const gasPrice = 0;
     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);
+    // 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();
-    const check = await safeProxy.isModuleEnabled(moduleAddress);
-    if (!check) {
-        throw new Error('Module verification failed');
+    // 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",
@@ -37,15 +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;
-    safeAddress?: string;
+    /**
+     * The Safe address to use when walletMode is 'safe'.
+     * Required if walletMode is 'safe'.
+     */
+    safeAddress: string;
 }
 export interface EventBasedJobInput {
     jobTitle: string;
@@ -56,15 +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;
-    safeAddress?: string;
+    /**
+     * The Safe address to use when walletMode is 'safe'.
+     * Required if walletMode is 'safe'.
+     */
+    safeAddress: string;
 }
 export interface ConditionBasedJobInput {
     jobTitle: string;
@@ -77,15 +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;
-    safeAddress?: string;
+    /**
+     * The Safe address to use when walletMode is 'safe'.
+     * Required if walletMode is 'safe'.
+     */
+    safeAddress: string;
 }
 export interface CreateJobData {
     job_id: string;
@@ -125,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;
@@ -216,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,8 +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 class ValidationError extends Error {
-    field: string;
-    constructor(field: string, message: string);
+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,25 +1,240 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValidationError = 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');
+    return new TriggerXError('Unknown error', 'UNKNOWN_ERROR', 'UNKNOWN_ERROR');
 }
-class ValidationError extends Error {
-    constructor(field, message) {
-        super(message);
+// 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 'UNKNOWN_ERROR';
+}

package/dist/utils/validation.js

@@ -103,7 +103,9 @@ function validateTimeBasedJobInput(input, argType) {
     else {
         throw new errors_1.ValidationError('scheduleType', 'scheduleType must be one of interval | cron | specific.');
     }
-    validateContractBasics(input.targetContractAddress, input.abi, input.targetFunction, 'contract');
+    if (input.walletMode !== 'safe') {
+        validateContractBasics(input.targetContractAddress, input.abi, input.targetFunction, 'contract');
+    }
     // Arg type checks
     const isDynamic = argType === 'dynamic' || argType === 2;
     if (isDynamic) {
@@ -112,7 +114,9 @@ function validateTimeBasedJobInput(input, argType) {
         }
     }
     else {
-        validateStaticArguments(input.abi, input.targetFunction, input.arguments, 'contract');
+        if (input.walletMode !== 'safe') {
+            validateStaticArguments(input.abi, input.targetFunction, input.arguments, 'contract');
+        }
     }
 }
 function validateEventBasedJobInput(input, argType) {
@@ -132,7 +136,9 @@ function validateEventBasedJobInput(input, argType) {
         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');
+    if (input.walletMode !== 'safe') {
+        validateContractBasics(input.targetContractAddress, input.abi, input.targetFunction, 'contract');
+    }
     const isDynamic = argType === 'dynamic' || argType === 2;
     if (isDynamic) {
         if (!isNonEmptyString(input.dynamicArgumentsScriptUrl) || !isValidUrl(input.dynamicArgumentsScriptUrl)) {
@@ -140,7 +146,9 @@ function validateEventBasedJobInput(input, argType) {
         }
     }
     else {
-        validateStaticArguments(input.abi, input.targetFunction, input.arguments, 'contract');
+        if (input.walletMode !== 'safe') {
+            validateStaticArguments(input.abi, input.targetFunction, input.arguments, 'contract');
+        }
     }
 }
 function validateConditionBasedJobInput(input, argType) {
@@ -176,7 +184,9 @@ function validateConditionBasedJobInput(input, argType) {
             throw new errors_1.ValidationError('contractLimits', 'Value is required.');
         }
     }
-    validateContractBasics(input.targetContractAddress, input.abi, input.targetFunction, 'contract');
+    if (input.walletMode !== 'safe') {
+        validateContractBasics(input.targetContractAddress, input.abi, input.targetFunction, 'contract');
+    }
     const isDynamic = argType === 'dynamic' || argType === 2;
     if (isDynamic) {
         if (!isNonEmptyString(input.dynamicArgumentsScriptUrl) || !isValidUrl(input.dynamicArgumentsScriptUrl)) {
@@ -184,7 +194,9 @@ function validateConditionBasedJobInput(input, argType) {
         }
     }
     else {
-        validateStaticArguments(input.abi, input.targetFunction, input.arguments, 'contract');
+        if (input.walletMode !== 'safe') {
+            validateStaticArguments(input.abi, input.targetFunction, input.arguments, 'contract');
+        }
     }
 }
 function validateJobInput(jobInput, argType) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "sdk-triggerx",
-  "version": "0.1.17",
+  "version": "0.1.19",
   "description": "SDK for interacting with the TriggerX backend and smart contracts.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -38,8 +38,8 @@
     "@typescript-eslint/parser": "^8.38.0",
     "dotenv": "^17.2.1",
     "eslint": "^9.32.0",
-    "jest": "^30.0.5",
-    "ts-jest": "^29.4.0",
+    "jest": "^30.2.0",
+    "ts-jest": "^29.4.5",
     "typescript": "^5.8.3"
   }
 }