sdk-triggerx 0.1.16 → 0.1.18

package/dist/api/jobs.js

@@ -13,6 +13,9 @@ 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 JOB_ID = '300949528249665590178224313442040528409305273634097553067152835846309150732';
 const DYNAMIC_ARGS_URL = 'https://teal-random-koala-993.mypinata.cloud/ipfs/bafkreif426p7t7takzhw3g6we2h6wsvf27p5jxj3gaiynqf22p3jvhx4la';
 function toCreateJobDataFromTime(input, balances, userAddress, jobCostPrediction) {
@@ -34,9 +37,9 @@ function toCreateJobDataFromTime(input, balances, userAddress, jobCostPrediction
         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,
+        target_contract_address: input.targetContractAddress || '',
+        target_function: input.targetFunction || '',
+        abi: input.abi || '',
         arg_type: input.dynamicArgumentsScriptUrl ? 2 : 1,
         arguments: input.arguments,
         dynamic_arguments_script_url: input.dynamicArgumentsScriptUrl,
@@ -61,9 +64,9 @@ function toCreateJobDataFromEvent(input, balances, userAddress, jobCostPredictio
         trigger_contract_address: input.triggerContractAddress,
         trigger_event: input.triggerEvent,
         target_chain_id: input.chainId,
-        target_contract_address: input.targetContractAddress,
-        target_function: input.targetFunction,
-        abi: input.abi,
+        target_contract_address: input.targetContractAddress || '',
+        target_function: input.targetFunction || '',
+        abi: input.abi || '',
         arg_type: input.dynamicArgumentsScriptUrl ? 2 : 1,
         arguments: input.arguments,
         dynamic_arguments_script_url: input.dynamicArgumentsScriptUrl,
@@ -90,9 +93,9 @@ function toCreateJobDataFromCondition(input, balances, userAddress, jobCostPredi
         value_source_type: input.valueSourceType,
         value_source_url: input.valueSourceUrl,
         target_chain_id: input.chainId,
-        target_contract_address: input.targetContractAddress,
-        target_function: input.targetFunction,
-        abi: input.abi,
+        target_contract_address: input.targetContractAddress || '',
+        target_function: input.targetFunction || '',
+        abi: input.abi || '',
         arg_type: input.dynamicArgumentsScriptUrl ? 2 : 1,
         arguments: input.arguments,
         dynamic_arguments_script_url: input.dynamicArgumentsScriptUrl,
@@ -122,32 +125,102 @@ async function createJob(client, params) {
     let { jobInput, signer, encodedData } = params;
     // Use the API key from the client instance
     const apiKey = client.getApiKey();
-    const userAddress = await signer.getAddress();
+    if (!apiKey) {
+        return (0, errors_1.createErrorResponse)(new errors_1.AuthenticationError('API key is required but not provided'), 'Authentication failed');
+    }
+    let userAddress;
+    try {
+        userAddress = await signer.getAddress();
+    }
+    catch (err) {
+        return (0, errors_1.createErrorResponse)(new errors_1.AuthenticationError('Failed to get signer address', { originalError: err }), 'Authentication failed');
+    }
     // Resolve chain-specific addresses
-    const network = await signer.provider?.getNetwork();
+    let network;
+    try {
+        network = await signer.provider?.getNetwork();
+    }
+    catch (err) {
+        return (0, errors_1.createErrorResponse)(new errors_1.NetworkError('Failed to get network information', { originalError: err }), 'Network error');
+    }
     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.' };
+        return (0, errors_1.createErrorResponse)(new errors_1.ConfigurationError(`JobRegistry address not configured for chain ID: ${chainIdStr}`), 'Configuration error');
+    }
+    // If Safe mode, override target fields BEFORE validation so user doesn't need to provide them
+    const walletModePre = jobInput.walletMode;
+    if (walletModePre === 'safe') {
+        if (!safeModule) {
+            return (0, errors_1.createErrorResponse)(new errors_1.ConfigurationError('Safe Module address not configured for this chain.'), 'Configuration error');
+        }
+        // If safeAddress is missing, require it (must be created by the user before this call)
+        if (!jobInput.safeAddress || typeof jobInput.safeAddress !== 'string' || !jobInput.safeAddress.trim()) {
+            return (0, errors_1.createErrorResponse)(new errors_1.ValidationError('safeAddress', 'safeAddress is required when walletMode is "safe". Call createSafeWallet first.'), 'Validation error');
+        }
+        const dynUrl = jobInput.dynamicArgumentsScriptUrl;
+        if (!dynUrl) {
+            return (0, errors_1.createErrorResponse)(new errors_1.ValidationError('dynamicArgumentsScriptUrl', 'Safe jobs require dynamicArgumentsScriptUrl (IPFS) for parameters.'), 'Validation error');
+        }
+        // Validate Safe has single owner and owner matches signer
+        try {
+            await (0, SafeWallet_1.ensureSingleOwnerAndMatchSigner)(jobInput.safeAddress, signer.provider, await signer.getAddress());
+            // Ensure module is enabled on Safe
+            await (0, SafeWallet_1.enableSafeModule)(jobInput.safeAddress, signer, safeModule);
+        }
+        catch (err) {
+            return (0, errors_1.createErrorResponse)(new errors_1.ContractError('Failed to configure Safe wallet', { originalError: err, safeAddress: jobInput.safeAddress }), 'Contract error');
+        }
+        // Auto-set module target; user does not need to pass targetContractAddress in safe mode
+        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" }]
+            }
+        ]);
+        // Ensure we don't carry static args in safe mode
+        jobInput.arguments = undefined;
+    }
+    // 0. Validate user input thoroughly before proceeding (after safe overrides)
+    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 (0, errors_1.createErrorResponse)(err);
+        }
+        return (0, errors_1.createErrorResponse)(err, 'Job input validation failed');
     }
-    let jobTitle, timeFrame, targetContractAddress, jobType;
+    let jobTitle = '';
+    let timeFrame = 0;
+    let targetContractAddress = '';
+    let jobType = 0;
     if ('jobTitle' in jobInput)
         jobTitle = jobInput.jobTitle;
     if ('timeFrame' in jobInput)
         timeFrame = jobInput.timeFrame;
     if ('targetContractAddress' in jobInput)
-        targetContractAddress = jobInput.targetContractAddress;
+        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');
+            return (0, errors_1.createErrorResponse)(new errors_1.ValidationError('timeInterval', 'timeInterval is required when scheduleType is interval'), 'Validation error');
         }
         if (jobInput.scheduleType === 'cron' && !jobInput.cronExpression) {
-            throw new Error('cronExpression is required when scheduleType is cron');
+            return (0, errors_1.createErrorResponse)(new errors_1.ValidationError('cronExpression', 'cronExpression is required when scheduleType is cron'), 'Validation error');
         }
         if (jobInput.scheduleType === 'specific' && !jobInput.specificSchedule) {
-            throw new Error('specificSchedule is required when scheduleType is specific');
+            return (0, errors_1.createErrorResponse)(new errors_1.ValidationError('specificSchedule', 'specificSchedule is required when scheduleType is specific'), 'Validation error');
         }
     }
     // Infer jobType from jobInput
@@ -216,7 +289,7 @@ async function createJob(client, params) {
         // Dynamic: call backend API to get fee
         const ipfs_url = jobInput.dynamicArgumentsScriptUrl;
         if (!ipfs_url) {
-            throw new Error('dynamicArgumentsScriptUrl is required for dynamic argType');
+            return (0, errors_1.createErrorResponse)(new errors_1.ValidationError('dynamicArgumentsScriptUrl', 'dynamicArgumentsScriptUrl is required for dynamic argType'), 'Validation error');
         }
         // Call backend API to get fee
         let fee = 0;
@@ -230,11 +303,13 @@ async function createJob(client, params) {
                 fee = feeRes.data.total_fee;
             }
             else {
-                throw new Error('Invalid response from /api/fees: missing total_fee');
+                return (0, errors_1.createErrorResponse)(new errors_1.ApiError('Invalid response from /api/fees: missing total_fee', { response: feeRes }), 'API error');
             }
         }
         catch (err) {
-            throw new Error('Failed to fetch job cost prediction: ' + err.message);
+            const httpStatusCode = (0, errors_1.extractHttpStatusCode)(err);
+            const errorCode = (0, errors_1.determineErrorCode)(err, httpStatusCode);
+            return (0, errors_1.createErrorResponse)(new errors_1.ApiError('Failed to fetch job cost prediction', { originalError: err, ipfs_url }, httpStatusCode), 'API error');
         }
         job_cost_prediction = fee * noOfExecutions;
     }
@@ -243,18 +318,41 @@ async function createJob(client, params) {
     // 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);
+    let tgBalanceWei, tgBalance;
+    try {
+        const balanceResult = await (0, checkTgBalance_1.checkTgBalance)(signer);
+        if (!balanceResult.success || !balanceResult.data) {
+            return (0, errors_1.createErrorResponse)(new errors_1.BalanceError('Failed to check TG balance', balanceResult.details), 'Balance check error');
+        }
+        tgBalanceWei = balanceResult.data.tgBalanceWei;
+        tgBalance = balanceResult.data.tgBalance;
+    }
+    catch (err) {
+        return (0, errors_1.createErrorResponse)(new errors_1.BalanceError('Failed to check TG balance', { originalError: err }), 'Balance check error');
+    }
     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.`);
+            return (0, errors_1.createErrorResponse)(new errors_1.BalanceError(`Insufficient TG balance. Job cost prediction is ${job_cost_prediction}. Current TG balance: ${tgBalance}. Please set autotopupTG: true in jobInput.`, {
+                required: job_cost_prediction,
+                current: tgBalance,
+                autoTopupEnabled: false
+            }), 'Insufficient balance');
         }
         else {
             // autotopupTG is true, automatically top up
             const requiredTG = Math.ceil(job_cost_prediction); // 1 TG = 0.001 ETH
-            await (0, topupTg_1.topupTg)(requiredTG, signer);
+            try {
+                const topupResult = await (0, topupTg_1.topupTg)(requiredTG, signer);
+                if (!topupResult.success) {
+                    return (0, errors_1.createErrorResponse)(new errors_1.BalanceError('Failed to top up TG balance', topupResult.details), 'Top-up error');
+                }
+            }
+            catch (err) {
+                return (0, errors_1.createErrorResponse)(new errors_1.BalanceError('Failed to top up TG balance', { originalError: err, requiredTG }), 'Top-up error');
+            }
         }
     }
     // Compute balances to store with the job
@@ -262,16 +360,22 @@ async function createJob(client, params) {
     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: encodedData || '',
-        contractAddress: JOB_REGISTRY_ADDRESS,
-        abi: JobRegistry_json_1.default.abi,
-        signer,
-    });
+    let jobId;
+    try {
+        jobId = await (0, JobRegistry_1.createJobOnChain)({
+            jobTitle: jobTitle,
+            jobType,
+            timeFrame: timeFrame,
+            targetContractAddress: targetContractAddress,
+            encodedData: encodedData || '',
+            contractAddress: JOB_REGISTRY_ADDRESS,
+            abi: JobRegistry_json_1.default.abi,
+            signer,
+        });
+    }
+    catch (err) {
+        return (0, errors_1.createErrorResponse)(new errors_1.ContractError('Failed to create job on chain', { originalError: err, jobTitle, jobType, timeFrame }), 'Contract error');
+    }
     // 2. Convert input to CreateJobData
     let jobData;
     const balances = { etherBalance, tokenBalanceWei };
@@ -300,6 +404,8 @@ async function createJob(client, params) {
         return { success: true, data: res };
     }
     catch (error) {
-        return { success: false, error: error.message };
+        const httpStatusCode = (0, errors_1.extractHttpStatusCode)(error);
+        const errorCode = (0, errors_1.determineErrorCode)(error, httpStatusCode);
+        return (0, errors_1.createErrorResponse)(new errors_1.ApiError('Failed to create job via API', { originalError: error, jobId }, httpStatusCode), 'API error');
     }
 }

package/dist/api/safeWallet.d.ts

@@ -0,0 +1,8 @@
+import { Signer } from 'ethers';
+/**
+ * Creates a new Safe wallet for the user on the signer's network.
+ * @param signer ethers.Signer (must be connected to the correct network)
+ * @returns Promise<string> - the new Safe wallet address
+ * @throws If cannot resolve SafeFactory address from config, or provider/chain/network errors.
+ */
+export declare function createSafeWallet(signer: Signer): Promise<string>;

package/dist/api/safeWallet.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createSafeWallet = createSafeWallet;
+const config_1 = require("../config");
+const SafeFactory_1 = require("../contracts/safe/SafeFactory");
+const SafeWallet_1 = require("../contracts/safe/SafeWallet");
+/**
+ * Creates a new Safe wallet for the user on the signer's network.
+ * @param signer ethers.Signer (must be connected to the correct network)
+ * @returns Promise<string> - the new Safe wallet address
+ * @throws If cannot resolve SafeFactory address from config, or provider/chain/network errors.
+ */
+async function createSafeWallet(signer) {
+    if (!signer.provider)
+        throw new Error('Signer must have a provider');
+    const network = await signer.provider.getNetwork();
+    if (!network?.chainId)
+        throw new Error('Could not get chainId from signer provider');
+    const chainId = network.chainId.toString();
+    const { safeFactory } = (0, config_1.getChainAddresses)(chainId);
+    if (!safeFactory)
+        throw new Error(`SafeFactory not configured for chain ${chainId}`);
+    const userAddr = await signer.getAddress();
+    const safeAddress = await (0, SafeFactory_1.createSafeWalletForUser)(safeFactory, signer, userAddr);
+    const { safeModule } = (0, config_1.getChainAddresses)(chainId);
+    if (!safeModule) {
+        throw new Error(`SafeModule not configured for chain ${chainId}`);
+    }
+    await (0, SafeWallet_1.enableSafeModule)(safeAddress, signer, safeModule);
+    return safeAddress;
+}

package/dist/api/topupTg.d.ts

@@ -1,2 +1,9 @@
 import { ethers } from 'ethers';
-export declare const topupTg: (tgAmount: number, signer: ethers.Signer) => Promise<any>;
+export declare const topupTg: (tgAmount: number, signer: ethers.Signer) => Promise<{
+    success: boolean;
+    data?: any;
+    error?: string;
+    errorCode?: string;
+    errorType?: string;
+    details?: any;
+}>;

package/dist/api/topupTg.js

@@ -7,17 +7,45 @@ exports.topupTg = void 0;
 const ethers_1 = require("ethers");
 const GasRegistry_json_1 = __importDefault(require("../contracts/abi/GasRegistry.json"));
 const config_1 = require("../config");
+const errors_1 = require("../utils/errors");
 const topupTg = async (tgAmount, signer) => {
-    const network = await signer.provider?.getNetwork();
-    const chainId = network?.chainId ? network.chainId.toString() : undefined;
-    const { gasRegistry } = (0, config_1.getChainAddresses)(chainId);
-    const gasRegistryContractAddress = gasRegistry;
-    const contract = new ethers_1.ethers.Contract(gasRegistryContractAddress, GasRegistry_json_1.default, signer);
-    // Each TG costs 0.001 ETH, so calculate the ETH required for the given TG amount
-    const amountInEthWei = tgAmount;
-    // const amountInEthWei = ethers.parseEther(amountInEth.toString());
-    const tx = await contract.purchaseTG(amountInEthWei, { value: amountInEthWei });
-    await tx.wait();
-    return tx;
+    // Validate inputs
+    if (!tgAmount || tgAmount <= 0) {
+        return (0, errors_1.createErrorResponse)(new errors_1.ValidationError('tgAmount', 'TG amount must be a positive number'), 'Validation error');
+    }
+    if (!signer) {
+        return (0, errors_1.createErrorResponse)(new errors_1.ValidationError('signer', 'Signer is required'), 'Validation error');
+    }
+    try {
+        const network = await signer.provider?.getNetwork();
+        const chainId = network?.chainId ? network.chainId.toString() : undefined;
+        const { gasRegistry } = (0, config_1.getChainAddresses)(chainId);
+        const gasRegistryContractAddress = gasRegistry;
+        if (!gasRegistryContractAddress) {
+            return (0, errors_1.createErrorResponse)(new errors_1.ConfigurationError(`GasRegistry address not configured for chain ID: ${chainId}`), 'Configuration error');
+        }
+        const contract = new ethers_1.ethers.Contract(gasRegistryContractAddress, GasRegistry_json_1.default, signer);
+        // Each TG costs 0.001 ETH, so calculate the ETH required for the given TG amount
+        const amountInEthWei = tgAmount;
+        // const amountInEthWei = ethers.parseEther(amountInEth.toString());
+        const tx = await contract.purchaseTG(amountInEthWei, { value: amountInEthWei });
+        await tx.wait();
+        return { success: true, data: tx };
+    }
+    catch (error) {
+        console.error('Error topping up TG:', error);
+        if (error instanceof Error) {
+            if (error.message.includes('network') || error.message.includes('timeout')) {
+                return (0, errors_1.createErrorResponse)(new errors_1.NetworkError('Network error during TG top-up', { originalError: error, tgAmount }), 'Network error');
+            }
+            else if (error.message.includes('contract') || error.message.includes('transaction')) {
+                return (0, errors_1.createErrorResponse)(new errors_1.ContractError('Contract error during TG top-up', { originalError: error, tgAmount }), 'Contract error');
+            }
+            else if (error.message.includes('insufficient funds') || error.message.includes('balance')) {
+                return (0, errors_1.createErrorResponse)(new errors_1.ValidationError('balance', 'Insufficient funds for TG top-up', { originalError: error, tgAmount }), 'Validation error');
+            }
+        }
+        return (0, errors_1.createErrorResponse)(error, 'Failed to top up TG');
+    }
 };
 exports.topupTg = topupTg;

package/dist/api/withdrawTg.d.ts

@@ -3,6 +3,13 @@ import { ethers } from 'ethers';
  * Withdraw ETH in exchange for TG tokens.
  * @param signer ethers.Signer instance
  * @param amountTG The amount of TG tokens to withdraw (as a string or BigNumberish)
- * @returns The transaction object
+ * @returns The transaction object or error response
  */
-export declare const withdrawTg: (signer: ethers.Signer, amountTG: string | ethers.BigNumberish) => Promise<any>;
+export declare const withdrawTg: (signer: ethers.Signer, amountTG: string | ethers.BigNumberish) => Promise<{
+    success: boolean;
+    data?: any;
+    error?: string;
+    errorCode?: string;
+    errorType?: string;
+    details?: any;
+}>;

package/dist/api/withdrawTg.js

@@ -7,25 +7,50 @@ exports.withdrawTg = void 0;
 const ethers_1 = require("ethers");
 const GasRegistry_json_1 = __importDefault(require("../contracts/abi/GasRegistry.json"));
 const config_1 = require("../config");
+const errors_1 = require("../utils/errors");
 /**
  * Withdraw ETH in exchange for TG tokens.
  * @param signer ethers.Signer instance
  * @param amountTG The amount of TG tokens to withdraw (as a string or BigNumberish)
- * @returns The transaction object
+ * @returns The transaction object or error response
  */
 const withdrawTg = async (signer, amountTG) => {
-    const network = await signer.provider?.getNetwork();
-    const chainId = network?.chainId ? network.chainId.toString() : undefined;
-    const { gasRegistry } = (0, config_1.getChainAddresses)(chainId);
-    const gasRegistryContractAddress = gasRegistry;
-    if (!gasRegistryContractAddress) {
-        throw new Error('GasRegistry address not configured for this chain. Update config mapping.');
+    // Validate inputs
+    if (!signer) {
+        return (0, errors_1.createErrorResponse)(new errors_1.ValidationError('signer', 'Signer is required'), 'Validation error');
+    }
+    if (!amountTG || (typeof amountTG === 'string' && amountTG.trim() === '') || Number(amountTG) <= 0) {
+        return (0, errors_1.createErrorResponse)(new errors_1.ValidationError('amountTG', 'Amount must be a positive number'), 'Validation error');
+    }
+    try {
+        const network = await signer.provider?.getNetwork();
+        const chainId = network?.chainId ? network.chainId.toString() : undefined;
+        const { gasRegistry } = (0, config_1.getChainAddresses)(chainId);
+        const gasRegistryContractAddress = gasRegistry;
+        if (!gasRegistryContractAddress) {
+            return (0, errors_1.createErrorResponse)(new errors_1.ConfigurationError(`GasRegistry address not configured for chain ID: ${chainId}`), 'Configuration error');
+        }
+        const contract = new ethers_1.ethers.Contract(gasRegistryContractAddress, GasRegistry_json_1.default, signer);
+        // Assumes the contract has a function: claimEthForTg(uint256 amount)
+        const amountTGWei = ethers_1.ethers.parseEther(amountTG.toString());
+        const tx = await contract.claimETHForTG(amountTGWei);
+        await tx.wait();
+        return { success: true, data: tx };
+    }
+    catch (error) {
+        console.error('Error withdrawing TG:', error);
+        if (error instanceof Error) {
+            if (error.message.includes('network') || error.message.includes('timeout')) {
+                return (0, errors_1.createErrorResponse)(new errors_1.NetworkError('Network error during TG withdrawal', { originalError: error, amountTG }), 'Network error');
+            }
+            else if (error.message.includes('contract') || error.message.includes('transaction')) {
+                return (0, errors_1.createErrorResponse)(new errors_1.ContractError('Contract error during TG withdrawal', { originalError: error, amountTG }), 'Contract error');
+            }
+            else if (error.message.includes('insufficient') || error.message.includes('balance')) {
+                return (0, errors_1.createErrorResponse)(new errors_1.ValidationError('balance', 'Insufficient TG balance for withdrawal', { originalError: error, amountTG }), 'Validation error');
+            }
+        }
+        return (0, errors_1.createErrorResponse)(error, 'Failed to withdraw TG');
     }
-    const contract = new ethers_1.ethers.Contract(gasRegistryContractAddress, GasRegistry_json_1.default, signer);
-    // Assumes the contract has a function: claimEthForTg(uint256 amount)
-    const amountTGWei = ethers_1.ethers.parseEther(amountTG.toString());
-    const tx = await contract.claimETHForTG(amountTGWei);
-    await tx.wait();
-    return tx;
 };
 exports.withdrawTg = withdrawTg;

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

@@ -23,6 +23,9 @@ exports.CONTRACT_ADDRESSES_BY_CHAIN = {
     '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': {
@@ -49,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/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>;