sdk-triggerx 0.1.26 → 0.1.28

package/README.md

@@ -12,6 +12,10 @@ Supports job automation on EVM-compatible chains using time, event, or condition
 - 📅 Supports time-based, event-based, and condition-based jobs
 - 🔐 TypeScript support with clean types
 - 🧠 Dynamic argument fetching via external scripts (e.g., IPFS)
+- 🛡️ Safe (Gnosis Safe) wallet integration with support for:
+  - Static single transactions (e.g., ETH transfers)
+  - Static batch transactions (e.g., DeFi operations like token approvals + swaps)
+  - Dynamic runtime arguments via IPFS scripts
 
 ---
 
@@ -57,9 +61,11 @@ const client = new TriggerXClient('YOUR_API_KEY');
   - Requirements:
     - Safe threshold must be 1 (single-signer) in this implementation.
     - The signer must be an owner of the Safe.
-    - Parameters must be dynamic (provided by `dynamicArgumentsScriptUrl`).
-    - The SDK will auto-create a Safe if `safeAddress` is not provided and the chain is configured with a Safe Factory.
+    - Supports both static transactions (`safeTransactions` array) and dynamic arguments (`dynamicArgumentsScriptUrl`).
     - The SDK will auto-enable the TriggerX Safe Module on the Safe if not already enabled.
+  - Static transactions:
+    - Single transaction: Provide one transaction in `safeTransactions` array (operation: CALL).
+    - Batch transactions: Provide multiple transactions in `safeTransactions` array (uses Safe MultiSend with DELEGATECALL).
 
 #### Supported Condition Types (for `conditionType`)
 
@@ -128,11 +134,11 @@ const jobInput = {
 
   // Safe mode (no target required — SDK auto-sets module target/function/ABI)
   walletMode: 'safe',
-  // Optional: provide an existing Safe; otherwise the SDK will create one for you
-  // safeAddress: '0xYourSafeAddress',
+  safeAddress: '0xYourSafeAddress', // Required: provide your Safe address
 
-  // Dynamic params must come from an IPFS/URL script
+  // Dynamic params fetched from IPFS/URL script at execution time
   dynamicArgumentsScriptUrl: 'https://your-ipfs-gateway/ipfs/your-hash',
+  language:'', //Your code language exmampel->  language:'go',
 
   // Optional helper to auto-top up TG if low
   autotopupTG: true,
@@ -144,8 +150,8 @@ console.log(result);
 
 Notes for Safe wallet mode:
 - In Safe mode, you do NOT need to set `targetContractAddress`/`targetFunction`/`abi` — the SDK sets these for the Safe Module and uses `execJobFromHub(address,address,uint256,bytes,uint8)` under the hood.
-- Your action details (action target/value/data/op) must be produced by your IPFS script at execution time.
-- No static arguments are allowed in Safe mode.
+- For dynamic jobs: your action details (action target/value/data/op) must be produced by your IPFS script at execution time.
+- For static jobs: use the `safeTransactions` array to provide hardcoded transaction details (see Safe Wallet Flow section below).
 
 ---
 
@@ -172,6 +178,7 @@ const jobInput = {
 
   arguments: [],                         // Target function args as strings
   dynamicArgumentsScriptUrl: 'https://your-ipfs-url', // Script URL for dynamic args
+  language:'', //Your code language exmampel->  language:'go',
   isImua: false,                          // Optional feature flag
   autotopupTG: true,                     // Auto top-up TG if balance is low
 };
@@ -224,7 +231,7 @@ To create jobs that use Safe wallets (`walletMode: 'safe'`), you must first crea
 #### 1️⃣ Create a Safe wallet for your user
 
 ```ts
-import { createSafeWallet } from 'sdk-triggerx/api/safeWallet'; // <--- new dedicated helper!
+import { createSafeWallet } from 'sdk-triggerx/api/safeWallet';
 const safeAddress = await createSafeWallet(signer /* ethers.Signer */);
 console.log('Your Safe address:', safeAddress);
 ```
@@ -234,29 +241,133 @@ console.log('Your Safe address:', safeAddress);
 - This MUST be done before you attempt to create any job with `walletMode: 'safe'`.
 - All safe wallet creation helpers are now in the dedicated `api/safeWallet` module so your file structure stays clean.
 
-#### 2️⃣ Create a job using the Safe (walletMode: 'safe')
+#### 2️⃣ Create a job using the Safe
+
+Safe wallet jobs support two modes: **static transactions** and **dynamic arguments**.
+
+##### Option A: Static Single Transaction (e.g., ETH transfer)
 
 ```ts
 const jobInput = {
   jobType: JobType.Time,
-  argType: ArgType.Dynamic, // required in safe mode
-  jobTitle: 'Safe Job',
+  argType: ArgType.Static, // Static for hardcoded transactions
+  jobTitle: 'Safe ETH Transfer',
   timeFrame: 3600,
   scheduleType: 'interval',
   timeInterval: 300,
   timezone: 'UTC',
   chainId: '421614',
   walletMode: 'safe',
-  safeAddress, // <---- required and must come from step 1
+  safeAddress: '0xYourSafeAddress', // from step 1
+  safeTransactions: [
+    {
+      to: '0xRecipientAddress',
+      value: '10000000000000', // 0.00001 ETH in wei
+      data: '0x' // empty for simple ETH transfer
+    }
+  ],
+  autotopupTG: true,
+};
+
+await createJob(client, { jobInput, signer });
+```
+
+##### Option B: Static Batch Transactions (e.g., Uniswap Swap)
+
+For complex multi-step operations like token approvals + swaps:
+
+```ts
+import { ethers } from 'ethers';
+
+// Token addresses (Arbitrum Sepolia)
+const USDC = '0x75faf114eafb1BDbe2F0316DF893fd58CE46AA4d';
+const WETH = '0x980B62Da83eFf3D4576C647993b0c1D7faf17c73';
+const UNISWAP_ROUTER = '0x101F443B4d1b059569D643917553c771E1b9663E';
+
+// Encode approve transaction
+const erc20Interface = new ethers.Interface([
+  'function approve(address spender, uint256 amount) returns (bool)'
+]);
+const approveData = erc20Interface.encodeFunctionData('approve', [
+  UNISWAP_ROUTER,
+  '10000' // 0.01 USDC (6 decimals)
+]);
+
+// Encode Uniswap V3 swap transaction
+const swapInterface = new ethers.Interface([
+  'function exactInputSingle((address tokenIn, address tokenOut, uint24 fee, address recipient, uint256 amountIn, uint256 amountOutMinimum, uint160 sqrtPriceLimitX96)) payable returns (uint256 amountOut)'
+]);
+const swapData = swapInterface.encodeFunctionData('exactInputSingle', [{
+  tokenIn: USDC,
+  tokenOut: WETH,
+  fee: 3000, // 0.3%
+  recipient: safeAddress, // Safe receives the output
+  amountIn: '10000',
+  amountOutMinimum: '0',
+  sqrtPriceLimitX96: 0
+}]);
+
+const jobInput = {
+  jobType: JobType.Time,
+  argType: ArgType.Static,
+  jobTitle: 'Safe Uniswap Swap',
+  timeFrame: 3600,
+  scheduleType: 'interval',
+  timeInterval: 600,
+  timezone: 'UTC',
+  chainId: '421614',
+  walletMode: 'safe',
+  safeAddress: '0xYourSafeAddress',
+  safeTransactions: [
+    {
+      to: USDC, // Approve USDC to router
+      value: '0',
+      data: approveData
+    },
+    {
+      to: UNISWAP_ROUTER, // Execute swap
+      value: '0',
+      data: swapData
+    }
+  ],
+  autotopupTG: true,
+};
+
+await createJob(client, { jobInput, signer });
+```
+
+**Note:** When multiple transactions are provided in `safeTransactions`, the SDK automatically:
+- Encodes them using Safe's MultiSend format
+- Wraps them with the `multiSend(bytes)` function call
+- Sets the operation to DELEGATECALL for batch execution
+
+##### Option C: Dynamic Arguments
+
+For runtime-determined parameters:
+
+```ts
+const jobInput = {
+  jobType: JobType.Time,
+  argType: ArgType.Dynamic,
+  jobTitle: 'Dynamic Safe Job',
+  timeFrame: 3600,
+  scheduleType: 'interval',
+  timeInterval: 300,
+  timezone: 'UTC',
+  chainId: '421614',
+  walletMode: 'safe',
+  safeAddress: '0xYourSafeAddress',
   dynamicArgumentsScriptUrl: 'https://your-ipfs-gateway/ipfs/your-hash',
+  language:'go', //Your code language exmampel->  language:'go',
   autotopupTG: true,
 };
-// ...
-await createJob(client, { jobInput, signer }); // as normal
+
+await createJob(client, { jobInput, signer });
 ```
 
-- The `safeAddress` property is now required for jobs using `walletMode: 'safe'`.
-- The SDK will no longer auto-create a Safe wallet for you; you must explicitly create and pass it in your job input.
+- The `safeAddress` property is required for all Safe wallet jobs.
+- For static jobs, provide `safeTransactions` array with transaction details.
+- For dynamic jobs, provide `dynamicArgumentsScriptUrl` that returns the action parameters at execution time.
 
 ---
 
@@ -337,6 +448,14 @@ Includes:
 - `JobInput`, `JobType`, `ArgType`
 - `ConditionType`, `ScheduleType`
 - `UserData`, `JobData`, etc.
+- `SafeTransaction` - Interface for Safe wallet transaction objects:
+  ```ts
+  interface SafeTransaction {
+    to: string;        // Target contract address
+    value: string;     // Value in wei (as string)
+    data: string;      // Encoded function call data (hex with 0x prefix)
+  }
+  ```
 
 ---
 

package/dist/api/checkTgBalance.d.ts

@@ -1,5 +1,13 @@
 import { ethers } from 'ethers';
-export declare const checkTgBalance: (signer: ethers.Signer) => Promise<{
+/**
+ * Check TG balance for a given signer using SDK-provided RPC
+ * This function uses our own RPC provider to ensure reliable connection
+ * even if the user's RPC fails
+ * @param signer - ethers.Signer instance (used to get wallet address)
+ * @param chainId - Optional chain ID. If not provided, will try to get from signer's provider
+ * @returns Balance information or error response
+ */
+export declare const checkTgBalance: (signer: ethers.Signer, chainId?: string | number) => Promise<{
     success: boolean;
     data?: {
         tgBalanceWei: bigint;

package/dist/api/checkTgBalance.js

@@ -8,21 +8,53 @@ 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 checkTgBalance = async (signer) => {
+/**
+ * Check TG balance for a given signer using SDK-provided RPC
+ * This function uses our own RPC provider to ensure reliable connection
+ * even if the user's RPC fails
+ * @param signer - ethers.Signer instance (used to get wallet address)
+ * @param chainId - Optional chain ID. If not provided, will try to get from signer's provider
+ * @returns Balance information or error response
+ */
+const checkTgBalance = async (signer, chainId) => {
     // Validate inputs
     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);
+        // Try to get chainId from signer's provider if not provided
+        // If signer's provider fails, we'll use the provided chainId or return error
+        let resolvedChainId = chainId?.toString();
+        if (!resolvedChainId) {
+            try {
+                const network = await signer.provider?.getNetwork();
+                resolvedChainId = network?.chainId ? network.chainId.toString() : undefined;
+            }
+            catch (providerError) {
+                // If user's RPC fails, we can't get chainId from it
+                // This is expected in cases where user's RPC is down
+                console.warn('Could not get network from signer provider, using provided chainId or will fail:', providerError);
+            }
+        }
+        if (!resolvedChainId) {
+            return (0, errors_1.createErrorResponse)(new errors_1.ConfigurationError('Chain ID is required. Please provide chainId parameter or ensure signer has a working provider.'), 'Configuration error');
+        }
+        const { gasRegistry } = (0, config_1.getChainAddresses)(resolvedChainId);
         const gasRegistryContractAddress = gasRegistry;
         if (!gasRegistryContractAddress) {
-            return (0, errors_1.createErrorResponse)(new errors_1.ConfigurationError(`GasRegistry address not configured for chain ID: ${chainId}`), 'Configuration error');
+            return (0, errors_1.createErrorResponse)(new errors_1.ConfigurationError(`GasRegistry address not configured for chain ID: ${resolvedChainId}`), 'Configuration error');
+        }
+        // Use SDK-provided RPC provider instead of user's provider
+        // This ensures we can read balance even if user's RPC fails
+        const rpcProvider = (0, config_1.getRpcProvider)(resolvedChainId);
+        if (!rpcProvider) {
+            return (0, errors_1.createErrorResponse)(new errors_1.ConfigurationError(`RPC URL not configured for chain ID: ${resolvedChainId}. Cannot check balance without RPC provider.`), 'Configuration error');
         }
-        const contract = new ethers_1.ethers.Contract(gasRegistryContractAddress, GasRegistry_json_1.default, signer);
+        // Create contract instance with our RPC provider (read-only)
+        const contract = new ethers_1.ethers.Contract(gasRegistryContractAddress, GasRegistry_json_1.default, rpcProvider);
+        // Get address from signer (this doesn't require provider)
         const address = await signer.getAddress();
+        // Read balance using our RPC provider
         const balance = await contract.balances(address);
         // balance is likely an array or object with ethSpent and TGbalance, both in wei
         // We'll convert TGbalance from wei to ETH

package/dist/api/jobs.js

@@ -16,11 +16,44 @@ 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';
+// Helper function to encode multisend batch transactions
+function encodeMultisendData(transactions) {
+    // Multisend format: for each transaction, encode as:
+    // operation (1 byte) + to (20 bytes) + value (32 bytes) + dataLength (32 bytes) + data (variable)
+    let encodedTransactions = '';
+    for (const tx of transactions) {
+        const txWithOperation = tx;
+        const to = txWithOperation.to;
+        const value = ethers_1.ethers.toBigInt(txWithOperation.value);
+        const data = txWithOperation.data;
+        // Remove 0x prefix from data if present
+        const dataWithoutPrefix = data.startsWith('0x') ? data.slice(2) : data;
+        const dataLength = ethers_1.ethers.toBigInt(dataWithoutPrefix.length / 2);
+        // Encode each field and concatenate
+        // operation: uint8 (1 byte)
+        const operation = typeof txWithOperation.operation === 'number' ? txWithOperation.operation : 0;
+        if (operation < 0 || operation > 1) {
+            throw new Error(`Invalid Safe transaction operation: ${operation}. Expected 0 (CALL) or 1 (DELEGATECALL).`);
+        }
+        const operationHex = operation.toString(16).padStart(2, '0');
+        // to: address (20 bytes)
+        const toHex = to.toLowerCase().replace(/^0x/, '').padStart(40, '0');
+        // value: uint256 (32 bytes)
+        const valueHex = value.toString(16).padStart(64, '0');
+        // dataLength: uint256 (32 bytes)
+        const dataLengthHex = dataLength.toString(16).padStart(64, '0');
+        // data: bytes (variable length)
+        encodedTransactions += operationHex + toHex + valueHex + dataLengthHex + dataWithoutPrefix;
+    }
+    const packedTransactions = `0x${encodedTransactions}`;
+    const multiSendInterface = new ethers_1.ethers.Interface([
+        'function multiSend(bytes transactions)'
+    ]);
+    return multiSendInterface.encodeFunctionData('multiSend', [packedTransactions]);
+}
 function toCreateJobDataFromTime(input, balances, userAddress, jobCostPrediction) {
     return {
-        job_id: JOB_ID,
+        job_id: "",
         user_address: userAddress,
         ether_balance: balances.etherBalance,
         token_balance: balances.tokenBalanceWei,
@@ -43,16 +76,16 @@ function toCreateJobDataFromTime(input, balances, userAddress, jobCostPrediction
         arg_type: input.dynamicArgumentsScriptUrl ? 2 : 1,
         arguments: input.arguments,
         dynamic_arguments_script_url: input.dynamicArgumentsScriptUrl,
-        is_imua: input.isImua ?? true,
+        is_imua: input.isImua ?? false,
         is_safe: input.walletMode === 'safe',
         safe_name: input.safeName || '',
         safe_address: input.safeAddress || '',
-        language: input.language || '',
+        language: input.language || 'go',
     };
 }
 function toCreateJobDataFromEvent(input, balances, userAddress, jobCostPrediction) {
     return {
-        job_id: JOB_ID,
+        job_id: "",
         user_address: userAddress,
         ether_balance: balances.etherBalance,
         token_balance: balances.tokenBalanceWei,
@@ -74,16 +107,16 @@ function toCreateJobDataFromEvent(input, balances, userAddress, jobCostPredictio
         arg_type: input.dynamicArgumentsScriptUrl ? 2 : 1,
         arguments: input.arguments,
         dynamic_arguments_script_url: input.dynamicArgumentsScriptUrl,
-        is_imua: input.isImua ?? true,
+        is_imua: input.isImua ?? false,
         is_safe: input.walletMode === 'safe',
         safe_name: input.safeName || '',
         safe_address: input.safeAddress || '',
-        language: input.language || '',
+        language: input.language || 'go',
     };
 }
 function toCreateJobDataFromCondition(input, balances, userAddress, jobCostPrediction) {
     return {
-        job_id: JOB_ID,
+        job_id: "",
         user_address: userAddress,
         ether_balance: balances.etherBalance,
         token_balance: balances.tokenBalanceWei,
@@ -107,11 +140,11 @@ function toCreateJobDataFromCondition(input, balances, userAddress, jobCostPredi
         arg_type: input.dynamicArgumentsScriptUrl ? 2 : 1,
         arguments: input.arguments,
         dynamic_arguments_script_url: input.dynamicArgumentsScriptUrl,
-        is_imua: input.isImua ?? true,
+        is_imua: input.isImua ?? false,
         is_safe: input.walletMode === 'safe',
         safe_name: input.safeName || '',
         safe_address: input.safeAddress || '',
-        language: input.language || '',
+        language: input.language || 'go',
     };
 }
 // --- Encoding helpers for different job types ---
@@ -156,7 +189,7 @@ async function createJob(client, params) {
         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 { jobRegistry, safeModule, safeFactory, multisendCallOnly } = (0, config_1.getChainAddresses)(chainIdStr);
     const JOB_REGISTRY_ADDRESS = jobRegistry;
     if (!JOB_REGISTRY_ADDRESS) {
         return (0, errors_1.createErrorResponse)(new errors_1.ConfigurationError(`JobRegistry address not configured for chain ID: ${chainIdStr}`), 'Configuration error');
@@ -171,10 +204,6 @@ async function createJob(client, params) {
         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());
@@ -186,20 +215,67 @@ async function createJob(client, params) {
         }
         // 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)';
+        // Function signature must match exactly as in ABI
+        jobInput.targetFunction = 'execJobFromHub';
+        // ABI verified per provided interface and matches execJobFromHub
         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" }]
+                "inputs": [
+                    { "internalType": "address", "name": "safeAddress", "type": "address" },
+                    { "internalType": "address", "name": "actionTarget", "type": "address" },
+                    { "internalType": "uint256", "name": "actionValue", "type": "uint256" },
+                    { "internalType": "bytes", "name": "actionData", "type": "bytes" },
+                    { "internalType": "uint8", "name": "operation", "type": "uint8" }
+                ],
+                "name": "execJobFromHub",
+                "outputs": [
+                    { "internalType": "bool", "name": "success", "type": "bool" }
+                ],
+                "stateMutability": "nonpayable",
+                "type": "function"
             }
         ]);
-        // Ensure we don't carry static args in safe mode
-        jobInput.arguments = undefined;
+        // Handle static vs dynamic safe wallet jobs
+        const hasDynamicUrl = !!jobInput.dynamicArgumentsScriptUrl;
+        const hasSafeTransactions = !!(jobInput.safeTransactions && jobInput.safeTransactions.length > 0);
+        if (hasDynamicUrl) {
+            // Dynamic safe wallet job - keep existing behavior
+            jobInput.arguments = undefined;
+        }
+        else if (hasSafeTransactions) {
+            // Static safe wallet job - encode transactions into arguments
+            const safeTransactions = jobInput.safeTransactions;
+            const safeAddress = jobInput.safeAddress;
+            if (safeTransactions.length === 1) {
+                // Single transaction: use transaction directly
+                const tx = safeTransactions[0];
+                jobInput.arguments = [
+                    safeAddress,
+                    tx.to,
+                    tx.value,
+                    tx.data,
+                    '0' // CALL
+                ];
+            }
+            else {
+                // Multiple transactions: use multisend
+                if (!multisendCallOnly) {
+                    return (0, errors_1.createErrorResponse)(new errors_1.ConfigurationError('MultisendCallOnly address not configured for this chain.'), 'Configuration error');
+                }
+                const encodedMultisendData = encodeMultisendData(safeTransactions);
+                jobInput.arguments = [
+                    safeAddress,
+                    multisendCallOnly,
+                    '0',
+                    encodedMultisendData,
+                    '1' // DELEGATECALL
+                ];
+            }
+        }
+        else {
+            // Will be caught by validation
+            jobInput.arguments = undefined;
+        }
     }
     // 0. Validate user input thoroughly before proceeding (after safe overrides)
     try {
@@ -330,9 +406,10 @@ 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
+    // Use chainId if available, so we can use SDK RPC provider even if user's RPC fails
     let tgBalanceWei, tgBalance;
     try {
-        const balanceResult = await (0, checkTgBalance_1.checkTgBalance)(signer);
+        const balanceResult = await (0, checkTgBalance_1.checkTgBalance)(signer, chainIdStr);
         if (!balanceResult.success || !balanceResult.data) {
             return (0, errors_1.createErrorResponse)(new errors_1.BalanceError('Failed to check TG balance', balanceResult.details), 'Balance check error');
         }
@@ -410,6 +487,7 @@ async function createJob(client, params) {
             ether_balance: typeof jobData.ether_balance === 'bigint' ? Number(jobData.ether_balance) : Number(jobData.ether_balance),
             token_balance: typeof jobData.token_balance === 'bigint' ? Number(jobData.token_balance) : Number(jobData.token_balance),
         };
+        console.log('jobDataForApi', jobDataForApi);
         const res = await client.post('/api/jobs', [jobDataForApi], {
             headers: { 'Content-Type': 'application/json', 'X-API-KEY': apiKey },
         });

package/dist/config.d.ts

@@ -1,3 +1,4 @@
+import { ethers } from 'ethers';
 export interface SDKConfig {
     apiKey: string;
     apiUrl: string;
@@ -8,12 +9,23 @@ export declare const CONTRACT_ADDRESSES_BY_CHAIN: Record<string, {
     safeFactory?: string;
     safeModule?: string;
     safeSingleton?: string;
+    multisendCallOnly?: string;
+    rpcUrl?: string;
 }>;
 export declare function getConfig(): SDKConfig;
+/**
+ * Get RPC provider for a given chain ID using SDK-configured RPC URLs
+ * This ensures reliable connection even if user's RPC fails
+ * @param chainId - Chain ID as string or number
+ * @returns ethers.JsonRpcProvider instance or null if chain not supported
+ */
+export declare function getRpcProvider(chainId: string | number | undefined): ethers.JsonRpcProvider | null;
 export declare function getChainAddresses(chainId: string | number | undefined): {
     gasRegistry: string;
     jobRegistry: string;
     safeFactory: string | undefined;
     safeModule: string | undefined;
     safeSingleton: string | undefined;
+    multisendCallOnly: string | undefined;
+    rpcUrl: string | undefined;
 };

package/dist/config.js

@@ -4,7 +4,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.CONTRACT_ADDRESSES_BY_CHAIN = void 0;
 exports.getConfig = getConfig;
+exports.getRpcProvider = getRpcProvider;
 exports.getChainAddresses = getChainAddresses;
+const ethers_1 = require("ethers");
 // Contract addresses per chain
 // Keyed by chainId as string to avoid bigint conversions throughout the SDK
 exports.CONTRACT_ADDRESSES_BY_CHAIN = {
@@ -15,6 +17,8 @@ exports.CONTRACT_ADDRESSES_BY_CHAIN = {
         jobRegistry: '0x476ACc7949a95e31144cC84b8F6BC7abF0967E4b',
         safeFactory: '0x04359eDC46Cd6C6BD7F6359512984222BE10F8Be',
         safeModule: '0xa0bC1477cfc452C05786262c377DE51FB8bc4669',
+        multisendCallOnly: '0x9641d764fc13c8B624c04430C7356C1C7C8102e2',
+        rpcUrl: 'https://sepolia.optimism.io',
     },
     // Ethereum Sepolia (11155111) - Ethereum Sepolia Testnet
     '11155111': {
@@ -22,6 +26,8 @@ exports.CONTRACT_ADDRESSES_BY_CHAIN = {
         jobRegistry: '0x476ACc7949a95e31144cC84b8F6BC7abF0967E4b',
         safeFactory: '0xdf76E2A796a206D877086c717979054544B1D9Bc',
         safeModule: '0xa0bC1477cfc452C05786262c377DE51FB8bc4669',
+        multisendCallOnly: '0x9641d764fc13c8B624c04430C7356C1C7C8102e2',
+        rpcUrl: 'https://rpc.sepolia.org',
     },
     // Arbitrum Sepolia (421614) - Arbitrum Sepolia Testnet
     '421614': {
@@ -29,6 +35,8 @@ exports.CONTRACT_ADDRESSES_BY_CHAIN = {
         jobRegistry: '0x476ACc7949a95e31144cC84b8F6BC7abF0967E4b',
         safeFactory: '0x04359eDC46Cd6C6BD7F6359512984222BE10F8Be',
         safeModule: '0xa0bC1477cfc452C05786262c377DE51FB8bc4669',
+        multisendCallOnly: '0x9641d764fc13c8B624c04430C7356C1C7C8102e2',
+        rpcUrl: 'https://sepolia-rollup.arbitrum.io/rpc',
         // safeSingleton can be provided per deployment (Safe or SafeL2)
     },
     // Base Sepolia (84532) - Base Sepolia Testnet
@@ -37,12 +45,16 @@ exports.CONTRACT_ADDRESSES_BY_CHAIN = {
         jobRegistry: '0x476ACc7949a95e31144cC84b8F6BC7abF0967E4b',
         safeFactory: '0x04359eDC46Cd6C6BD7F6359512984222BE10F8Be',
         safeModule: '0xa0bC1477cfc452C05786262c377DE51FB8bc4669',
+        multisendCallOnly: '0x9641d764fc13c8B624c04430C7356C1C7C8102e2',
+        rpcUrl: 'https://sepolia.base.org',
     },
     // MAINNET CONFIGURATIONS
     // Arbitrum One (42161) - Mainnet
     '42161': {
         gasRegistry: '0x93dDB2307F3Af5df85F361E5Cddd898Acd3d132d',
         jobRegistry: '0xAf1189aFd1F1880F09AeC3Cbc32cf415c735C710',
+        multisendCallOnly: '0x9641d764fc13c8B624c04430C7356C1C7C8102e2',
+        rpcUrl: 'https://arb1.arbitrum.io/rpc',
     },
     // Default/fallbacks can be extended as needed for other networks
 };
@@ -52,6 +64,19 @@ function getConfig() {
         apiUrl: '',
     };
 }
+/**
+ * Get RPC provider for a given chain ID using SDK-configured RPC URLs
+ * This ensures reliable connection even if user's RPC fails
+ * @param chainId - Chain ID as string or number
+ * @returns ethers.JsonRpcProvider instance or null if chain not supported
+ */
+function getRpcProvider(chainId) {
+    const { rpcUrl } = getChainAddresses(chainId);
+    if (!rpcUrl) {
+        return null;
+    }
+    return new ethers_1.ethers.JsonRpcProvider(rpcUrl);
+}
 function getChainAddresses(chainId) {
     const chainKey = String(chainId ?? '');
     const mapped = exports.CONTRACT_ADDRESSES_BY_CHAIN[chainKey];
@@ -61,5 +86,7 @@ function getChainAddresses(chainId) {
         safeFactory: mapped ? mapped.safeFactory : '',
         safeModule: mapped ? mapped.safeModule : '',
         safeSingleton: mapped ? mapped.safeSingleton : '',
+        multisendCallOnly: mapped ? mapped.multisendCallOnly : '',
+        rpcUrl: mapped ? mapped.rpcUrl : '',
     };
 }

package/dist/types.d.ts

@@ -33,6 +33,11 @@ export declare enum ArgType {
     Dynamic = "dynamic"
 }
 export type WalletMode = 'regular' | 'safe';
+export interface SafeTransaction {
+    to: string;
+    value: string;
+    data: string;
+}
 export type CreateJobInput = (TimeBasedJobInput & {
     jobType: JobType.Time;
     argType: ArgType.Static | ArgType.Dynamic;
@@ -67,6 +72,13 @@ export interface TimeBasedJobInput {
      * Required if walletMode is 'safe'.
      */
     safeAddress?: string;
+    /**
+     * Array of transactions for safe wallet jobs with static parameters.
+     * If length === 1: single call (operation 0)
+     * If length > 1: batch call via multisend (operation 1)
+     * Only used when walletMode is 'safe' and argType is 'static'.
+     */
+    safeTransactions?: SafeTransaction[];
 }
 export interface EventBasedJobInput {
     jobTitle: string;
@@ -92,6 +104,13 @@ export interface EventBasedJobInput {
      * Required if walletMode is 'safe'.
      */
     safeAddress?: string;
+    /**
+     * Array of transactions for safe wallet jobs with static parameters.
+     * If length === 1: single call (operation 0)
+     * If length > 1: batch call via multisend (operation 1)
+     * Only used when walletMode is 'safe' and argType is 'static'.
+     */
+    safeTransactions?: SafeTransaction[];
 }
 export interface ConditionBasedJobInput {
     jobTitle: string;
@@ -119,6 +138,13 @@ export interface ConditionBasedJobInput {
      * Required if walletMode is 'safe'.
      */
     safeAddress?: string;
+    /**
+     * Array of transactions for safe wallet jobs with static parameters.
+     * If length === 1: single call (operation 0)
+     * If length > 1: batch call via multisend (operation 1)
+     * Only used when walletMode is 'safe' and argType is 'static'.
+     */
+    safeTransactions?: SafeTransaction[];
 }
 export interface CreateJobData {
     job_id: string;

package/dist/utils/validation.js

@@ -68,6 +68,26 @@ function validateStaticArguments(abiString, targetFunction, args, fieldPrefix =
         throw new errors_1.ValidationError(`${fieldPrefix}Args`, 'All function arguments are required for static argument type.');
     }
 }
+function validateSafeTransactions(transactions) {
+    if (!transactions || !Array.isArray(transactions) || transactions.length === 0) {
+        throw new errors_1.ValidationError('safeTransactions', 'safeTransactions array is required and must contain at least one transaction for static safe wallet jobs.');
+    }
+    for (let i = 0; i < transactions.length; i++) {
+        const tx = transactions[i];
+        if (!tx || typeof tx !== 'object') {
+            throw new errors_1.ValidationError('safeTransactions', `Transaction at index ${i} is invalid.`);
+        }
+        if (!isNonEmptyString(tx.to) || !ethers_1.ethers.isAddress(tx.to)) {
+            throw new errors_1.ValidationError('safeTransactions', `Transaction at index ${i}: 'to' must be a valid Ethereum address.`);
+        }
+        if (typeof tx.value !== 'string') {
+            throw new errors_1.ValidationError('safeTransactions', `Transaction at index ${i}: 'value' must be a string representing wei amount.`);
+        }
+        if (!isNonEmptyString(tx.data) || !tx.data.startsWith('0x')) {
+            throw new errors_1.ValidationError('safeTransactions', `Transaction at index ${i}: 'data' must be a hex string starting with 0x.`);
+        }
+    }
+}
 function validateTimeBasedJobInput(input, argType) {
     if (!isNonEmptyString(input.jobTitle)) {
         throw new errors_1.ValidationError('jobTitle', 'Job title is required.');
@@ -103,18 +123,37 @@ function validateTimeBasedJobInput(input, argType) {
     else {
         throw new errors_1.ValidationError('scheduleType', 'scheduleType must be one of interval | cron | specific.');
     }
-    if (input.walletMode !== 'safe') {
-        validateContractBasics(input.targetContractAddress, input.abi, input.targetFunction, 'contract');
-    }
     // Arg type checks
     const isDynamic = argType === 'dynamic' || argType === 2;
-    if (isDynamic) {
-        if (!isNonEmptyString(input.dynamicArgumentsScriptUrl) || !isValidUrl(input.dynamicArgumentsScriptUrl)) {
-            throw new errors_1.ValidationError('contractIpfs', 'IPFS Code URL is required and must be valid for dynamic argument type.');
+    // Safe wallet mode validation
+    if (input.walletMode === 'safe') {
+        // Ensure static and dynamic are mutually exclusive
+        if (isDynamic && input.safeTransactions && input.safeTransactions.length > 0) {
+            throw new errors_1.ValidationError('safeTransactions', 'Cannot provide both dynamicArgumentsScriptUrl and safeTransactions. Use one or the other.');
+        }
+        if (!isDynamic && !input.safeTransactions) {
+            throw new errors_1.ValidationError('safeTransactions', 'For static safe wallet jobs, either provide safeTransactions or use dynamicArgumentsScriptUrl for dynamic jobs.');
+        }
+        if (isDynamic) {
+            // Dynamic safe wallet job
+            if (!isNonEmptyString(input.dynamicArgumentsScriptUrl) || !isValidUrl(input.dynamicArgumentsScriptUrl)) {
+                throw new errors_1.ValidationError('contractIpfs', 'IPFS Code URL is required and must be valid for dynamic argument type.');
+            }
+        }
+        else {
+            // Static safe wallet job
+            validateSafeTransactions(input.safeTransactions);
         }
     }
     else {
-        if (input.walletMode !== 'safe') {
+        // Regular wallet mode
+        validateContractBasics(input.targetContractAddress, input.abi, input.targetFunction, 'contract');
+        if (isDynamic) {
+            if (!isNonEmptyString(input.dynamicArgumentsScriptUrl) || !isValidUrl(input.dynamicArgumentsScriptUrl)) {
+                throw new errors_1.ValidationError('contractIpfs', 'IPFS Code URL is required and must be valid for dynamic argument type.');
+            }
+        }
+        else {
             validateStaticArguments(input.abi, input.targetFunction, input.arguments, 'contract');
         }
     }
@@ -136,17 +175,37 @@ function validateEventBasedJobInput(input, argType) {
         throw new errors_1.ValidationError('triggerChainId', 'Trigger chain ID is required.');
     }
     validateContractBasics(input.triggerContractAddress, input.abi, input.triggerEvent, 'eventContract');
-    if (input.walletMode !== 'safe') {
-        validateContractBasics(input.targetContractAddress, input.abi, input.targetFunction, 'contract');
-    }
+    // Arg type checks
     const isDynamic = argType === 'dynamic' || argType === 2;
-    if (isDynamic) {
-        if (!isNonEmptyString(input.dynamicArgumentsScriptUrl) || !isValidUrl(input.dynamicArgumentsScriptUrl)) {
-            throw new errors_1.ValidationError('contractIpfs', 'IPFS Code URL is required and must be valid for dynamic argument type.');
+    // Safe wallet mode validation
+    if (input.walletMode === 'safe') {
+        // Ensure static and dynamic are mutually exclusive
+        if (isDynamic && input.safeTransactions && input.safeTransactions.length > 0) {
+            throw new errors_1.ValidationError('safeTransactions', 'Cannot provide both dynamicArgumentsScriptUrl and safeTransactions. Use one or the other.');
+        }
+        if (!isDynamic && !input.safeTransactions) {
+            throw new errors_1.ValidationError('safeTransactions', 'For static safe wallet jobs, either provide safeTransactions or use dynamicArgumentsScriptUrl for dynamic jobs.');
+        }
+        if (isDynamic) {
+            // Dynamic safe wallet job
+            if (!isNonEmptyString(input.dynamicArgumentsScriptUrl) || !isValidUrl(input.dynamicArgumentsScriptUrl)) {
+                throw new errors_1.ValidationError('contractIpfs', 'IPFS Code URL is required and must be valid for dynamic argument type.');
+            }
+        }
+        else {
+            // Static safe wallet job
+            validateSafeTransactions(input.safeTransactions);
         }
     }
     else {
-        if (input.walletMode !== 'safe') {
+        // Regular wallet mode
+        validateContractBasics(input.targetContractAddress, input.abi, input.targetFunction, 'contract');
+        if (isDynamic) {
+            if (!isNonEmptyString(input.dynamicArgumentsScriptUrl) || !isValidUrl(input.dynamicArgumentsScriptUrl)) {
+                throw new errors_1.ValidationError('contractIpfs', 'IPFS Code URL is required and must be valid for dynamic argument type.');
+            }
+        }
+        else {
             validateStaticArguments(input.abi, input.targetFunction, input.arguments, 'contract');
         }
     }
@@ -184,17 +243,37 @@ function validateConditionBasedJobInput(input, argType) {
             throw new errors_1.ValidationError('contractLimits', 'Value is required.');
         }
     }
-    if (input.walletMode !== 'safe') {
-        validateContractBasics(input.targetContractAddress, input.abi, input.targetFunction, 'contract');
-    }
+    // Arg type checks
     const isDynamic = argType === 'dynamic' || argType === 2;
-    if (isDynamic) {
-        if (!isNonEmptyString(input.dynamicArgumentsScriptUrl) || !isValidUrl(input.dynamicArgumentsScriptUrl)) {
-            throw new errors_1.ValidationError('contractIpfs', 'IPFS Code URL is required and must be valid for dynamic argument type.');
+    // Safe wallet mode validation
+    if (input.walletMode === 'safe') {
+        // Ensure static and dynamic are mutually exclusive
+        if (isDynamic && input.safeTransactions && input.safeTransactions.length > 0) {
+            throw new errors_1.ValidationError('safeTransactions', 'Cannot provide both dynamicArgumentsScriptUrl and safeTransactions. Use one or the other.');
+        }
+        if (!isDynamic && !input.safeTransactions) {
+            throw new errors_1.ValidationError('safeTransactions', 'For static safe wallet jobs, either provide safeTransactions or use dynamicArgumentsScriptUrl for dynamic jobs.');
+        }
+        if (isDynamic) {
+            // Dynamic safe wallet job
+            if (!isNonEmptyString(input.dynamicArgumentsScriptUrl) || !isValidUrl(input.dynamicArgumentsScriptUrl)) {
+                throw new errors_1.ValidationError('contractIpfs', 'IPFS Code URL is required and must be valid for dynamic argument type.');
+            }
+        }
+        else {
+            // Static safe wallet job
+            validateSafeTransactions(input.safeTransactions);
         }
     }
     else {
-        if (input.walletMode !== 'safe') {
+        // Regular wallet mode
+        validateContractBasics(input.targetContractAddress, input.abi, input.targetFunction, 'contract');
+        if (isDynamic) {
+            if (!isNonEmptyString(input.dynamicArgumentsScriptUrl) || !isValidUrl(input.dynamicArgumentsScriptUrl)) {
+                throw new errors_1.ValidationError('contractIpfs', 'IPFS Code URL is required and must be valid for dynamic argument type.');
+            }
+        }
+        else {
             validateStaticArguments(input.abi, input.targetFunction, input.arguments, 'contract');
         }
     }

package/package.json

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