sdk-triggerx 0.1.17 → 0.1.18

package/dist/api/jobs.js

@@ -16,7 +16,6 @@ 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) {
@@ -38,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,
@@ -65,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,
@@ -94,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,
@@ -124,46 +123,104 @@ function encodeJobType4or6Data(recurringJob, ipfsHash) {
  */
 async function createJob(client, params) {
     let { jobInput, signer, encodedData } = params;
-    // 0. Validate user input thoroughly before proceeding
+    // Use the API key from the client instance
+    const apiKey = client.getApiKey();
+    if (!apiKey) {
+        return (0, errors_1.createErrorResponse)(new errors_1.AuthenticationError('API key is required but not provided'), 'Authentication failed');
+    }
+    let userAddress;
     try {
-        const argValue = jobInput.argType;
-        (0, validation_1.validateJobInput)(jobInput, argValue);
-        console.log('Job input validated successfully');
+        userAddress = await signer.getAddress();
     }
     catch (err) {
-        if (err instanceof errors_1.ValidationError) {
-            return { success: false, error: `${err.field}: ${err.message}` };
-        }
-        return { success: false, error: err.message };
+        return (0, errors_1.createErrorResponse)(new errors_1.AuthenticationError('Failed to get signer address', { originalError: err }), 'Authentication failed');
     }
-    // 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();
+    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, 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;
     }
-    let jobTitle, timeFrame, targetContractAddress, jobType;
+    // 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 = '';
+    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
@@ -232,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;
@@ -246,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;
     }
@@ -259,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
@@ -278,56 +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;
-    // --- 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;
+    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');
     }
-    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,
-    });
     // 2. Convert input to CreateJobData
     let jobData;
     const balances = { etherBalance, tokenBalanceWei };
@@ -356,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/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');
 }