sdk-triggerx 0.1.27 → 0.1.29

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

@@ -6,23 +6,50 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.checkTgBalance = void 0;
 const ethers_1 = require("ethers");
 const GasRegistry_json_1 = __importDefault(require("../contracts/abi/GasRegistry.json"));
-const config_1 = require("../config");
+const contractUtils_1 = require("../contracts/contractUtils");
 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);
-        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);
+        // Resolve chain ID (use provided chainId or resolve from signer)
+        let resolvedChainId;
+        try {
+            resolvedChainId = await (0, contractUtils_1.resolveChainId)(signer, chainId);
+        }
+        catch (configError) {
+            if (configError instanceof errors_1.ConfigurationError) {
+                return (0, errors_1.createErrorResponse)(configError, 'Configuration error');
+            }
+            return (0, errors_1.createErrorResponse)(new errors_1.ConfigurationError('Failed to resolve chain ID', { originalError: configError }), 'Configuration error');
+        }
+        // Get contract address
+        let gasRegistryContractAddress;
+        try {
+            gasRegistryContractAddress = (0, contractUtils_1.getContractAddress)(resolvedChainId, 'gasRegistry');
+        }
+        catch (configError) {
+            if (configError instanceof errors_1.ConfigurationError) {
+                return (0, errors_1.createErrorResponse)(configError, 'Configuration error');
+            }
+            return (0, errors_1.createErrorResponse)(new errors_1.ConfigurationError('Failed to get contract address', { originalError: configError }), 'Configuration error');
+        }
+        // Create contract instance with SDK RPC provider (read-only)
+        // This ensures we can read balance even if user's RPC fails
+        const contract = await (0, contractUtils_1.createContractWithSdkRpc)(gasRegistryContractAddress, GasRegistry_json_1.default, resolvedChainId, signer);
+        // 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,8 +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 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:
@@ -55,7 +53,7 @@ function encodeMultisendData(transactions) {
 }
 function toCreateJobDataFromTime(input, balances, userAddress, jobCostPrediction) {
     return {
-        job_id: JOB_ID,
+        job_id: "",
         user_address: userAddress,
         ether_balance: balances.etherBalance,
         token_balance: balances.tokenBalanceWei,
@@ -87,7 +85,7 @@ function toCreateJobDataFromTime(input, balances, userAddress, jobCostPrediction
 }
 function toCreateJobDataFromEvent(input, balances, userAddress, jobCostPrediction) {
     return {
-        job_id: JOB_ID,
+        job_id: "",
         user_address: userAddress,
         ether_balance: balances.etherBalance,
         token_balance: balances.tokenBalanceWei,
@@ -118,7 +116,7 @@ function toCreateJobDataFromEvent(input, balances, userAddress, jobCostPredictio
 }
 function toCreateJobDataFromCondition(input, balances, userAddress, jobCostPrediction) {
     return {
-        job_id: JOB_ID,
+        job_id: "",
         user_address: userAddress,
         ether_balance: balances.etherBalance,
         token_balance: balances.tokenBalanceWei,
@@ -374,7 +372,9 @@ async function createJob(client, params) {
         noOfExecutions = jobInput.timeFrame / (jobInput.timeInterval ?? 0);
     }
     // Set job_cost_prediction
-    let job_cost_prediction = 0.1 * noOfExecutions; // default for static
+    // ethers.parseEther expects a string, so we construct the ether amount string safely
+    let job_cost_prediction = Number(ethers_1.ethers.parseEther((0.1 * noOfExecutions).toString()).toString()); // default for static
+    // console.log('job_cost_prediction', job_cost_prediction);
     if (argType === 2) {
         // Dynamic: call backend API to get fee
         const ipfs_url = jobInput.dynamicArgumentsScriptUrl;
@@ -385,6 +385,10 @@ async function createJob(client, params) {
         let fee = 0;
         try {
             const feeRes = await client.get('/api/fees', { params: { ipfs_url } });
+            // console.log('feeRes', feeRes);
+            // console.log('feeRes.total_fee', feeRes.total_fee);
+            // console.log('typeof feeRes', typeof feeRes);
+            // console.log('typeof feeRes.total_fee', typeof feeRes.total_fee);
             // The API now returns { total_fee: number }
             if (feeRes && typeof feeRes.total_fee === 'number') {
                 fee = feeRes.total_fee;
@@ -401,16 +405,20 @@ async function createJob(client, params) {
             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');
         }
+        // console.log('fee', fee);
+        // console.log('noOfExecutions', noOfExecutions);
         job_cost_prediction = fee * noOfExecutions;
     }
+    // console.log('job_cost_prediction', job_cost_prediction);
     // Ask user if they want to proceed
     // Since this is a library, we can't prompt in Node.js directly.
     // 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');
         }
@@ -420,7 +428,7 @@ async function createJob(client, params) {
     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) {
+    if (Number(tgBalanceWei) < 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;
@@ -435,6 +443,7 @@ async function createJob(client, params) {
             // autotopupTG is true, automatically top up
             const requiredTG = Math.ceil(job_cost_prediction); // 1 TG = 0.001 ETH
             try {
+                console.log('topping up TG balance', requiredTG);
                 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');

package/dist/api/topupTg.js

@@ -4,11 +4,11 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 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 contractUtils_1 = require("../contracts/contractUtils");
 const errors_1 = require("../utils/errors");
 const topupTg = async (tgAmount, signer) => {
+    console.log('topping up TG balance', tgAmount);
     // 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');
@@ -17,20 +17,66 @@ const topupTg = async (tgAmount, 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');
+        // Get contract address and create contract instances with SDK RPC provider
+        // This ensures we can interact with the contract even if user's RPC fails
+        let gasRegistryContractAddress;
+        let contract;
+        let contractWithSigner;
+        let resolvedChainId;
+        let signerAddress;
+        try {
+            // Get signer address (this doesn't require the signer's provider to work)
+            signerAddress = await signer.getAddress();
+            // Resolve chain ID from signer
+            resolvedChainId = await (0, contractUtils_1.resolveChainId)(signer);
+            // Get contract address
+            gasRegistryContractAddress = (0, contractUtils_1.getContractAddress)(resolvedChainId, 'gasRegistry');
+            // Create contract instances with SDK RPC provider
+            const contractInstances = await (0, contractUtils_1.createContractWithSdkRpcAndSigner)(gasRegistryContractAddress, GasRegistry_json_1.default, signer, resolvedChainId);
+            contract = contractInstances.contract;
+            contractWithSigner = contractInstances.contractWithSigner;
+        }
+        catch (configError) {
+            if (configError instanceof errors_1.ConfigurationError) {
+                return (0, errors_1.createErrorResponse)(configError, 'Configuration error');
+            }
+            return (0, errors_1.createErrorResponse)(new errors_1.ConfigurationError('Failed to initialize contract', { originalError: configError }), '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
+        console.log('tgAmount', tgAmount);
         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 };
+        console.log('amountInEthWei', amountInEthWei);
+        // Estimate gas for the transaction using SDK RPC provider
+        // This ensures gas estimation works even if user's RPC fails
+        let estimatedGas;
+        try {
+            console.log('Estimating gas using SDK RPC provider...');
+            // Use contract instance with SDK RPC provider for estimation
+            // Specify the signer's address in the estimation options
+            estimatedGas = await contract.purchaseTG.estimateGas(amountInEthWei, {
+                value: amountInEthWei,
+                from: signerAddress // Specify the sender address for accurate estimation
+            });
+            console.log('Estimated gas (using SDK RPC):', estimatedGas.toString());
+            // Add 10% buffer to ensure transaction doesn't fail
+            const gasWithBuffer = (estimatedGas * BigInt(110)) / BigInt(100);
+            console.log('Gas with 10% buffer:', gasWithBuffer.toString());
+            // Execute transaction using signer (for signing)
+            const tx = await contractWithSigner.purchaseTG(amountInEthWei, {
+                value: amountInEthWei,
+                gasLimit: gasWithBuffer
+            });
+            await tx.wait();
+            return { success: true, data: tx };
+        }
+        catch (gasEstimateError) {
+            // If gas estimation fails, try without gas limit (let provider estimate)
+            console.warn('Gas estimation failed (using SDK RPC), proceeding without gas limit:', gasEstimateError);
+            const tx = await contractWithSigner.purchaseTG(amountInEthWei, { value: amountInEthWei });
+            await tx.wait();
+            return { success: true, data: tx };
+        }
     }
     catch (error) {
         console.error('Error topping up TG:', error);

package/dist/api/withdrawTg.js

@@ -6,7 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 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 contractUtils_1 = require("../contracts/contractUtils");
 const errors_1 = require("../utils/errors");
 /**
  * Withdraw ETH in exchange for TG tokens.
@@ -23,17 +23,27 @@ const withdrawTg = async (signer, amountTG) => {
         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');
+        // Resolve chain ID and create contract instances with SDK RPC provider
+        let resolvedChainId;
+        let contractWithSigner;
+        try {
+            // Resolve chain ID from signer
+            resolvedChainId = await (0, contractUtils_1.resolveChainId)(signer);
+            // Get contract address
+            const gasRegistryContractAddress = (0, contractUtils_1.getContractAddress)(resolvedChainId, 'gasRegistry');
+            // Create contract instances with SDK RPC provider
+            const contractInstances = await (0, contractUtils_1.createContractWithSdkRpcAndSigner)(gasRegistryContractAddress, GasRegistry_json_1.default, signer, resolvedChainId);
+            contractWithSigner = contractInstances.contractWithSigner;
+        }
+        catch (configError) {
+            if (configError instanceof errors_1.ConfigurationError) {
+                return (0, errors_1.createErrorResponse)(configError, 'Configuration error');
+            }
+            return (0, errors_1.createErrorResponse)(new errors_1.ConfigurationError('Failed to initialize contract', { originalError: configError }), '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);
+        const tx = await contractWithSigner.claimETHForTG(amountTGWei);
         await tx.wait();
         return { success: true, data: tx };
     }

package/dist/config.d.ts

@@ -1,3 +1,4 @@
+import { ethers } from 'ethers';
 export interface SDKConfig {
     apiKey: string;
     apiUrl: string;
@@ -9,8 +10,16 @@ export declare const CONTRACT_ADDRESSES_BY_CHAIN: Record<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;
@@ -18,4 +27,5 @@ export declare function getChainAddresses(chainId: string | number | 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 = {
@@ -16,6 +18,7 @@ exports.CONTRACT_ADDRESSES_BY_CHAIN = {
         safeFactory: '0x04359eDC46Cd6C6BD7F6359512984222BE10F8Be',
         safeModule: '0xa0bC1477cfc452C05786262c377DE51FB8bc4669',
         multisendCallOnly: '0x9641d764fc13c8B624c04430C7356C1C7C8102e2',
+        rpcUrl: 'https://sepolia.optimism.io',
     },
     // Ethereum Sepolia (11155111) - Ethereum Sepolia Testnet
     '11155111': {
@@ -24,6 +27,7 @@ exports.CONTRACT_ADDRESSES_BY_CHAIN = {
         safeFactory: '0xdf76E2A796a206D877086c717979054544B1D9Bc',
         safeModule: '0xa0bC1477cfc452C05786262c377DE51FB8bc4669',
         multisendCallOnly: '0x9641d764fc13c8B624c04430C7356C1C7C8102e2',
+        rpcUrl: 'https://rpc.sepolia.org',
     },
     // Arbitrum Sepolia (421614) - Arbitrum Sepolia Testnet
     '421614': {
@@ -32,6 +36,7 @@ exports.CONTRACT_ADDRESSES_BY_CHAIN = {
         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
@@ -41,6 +46,7 @@ exports.CONTRACT_ADDRESSES_BY_CHAIN = {
         safeFactory: '0x04359eDC46Cd6C6BD7F6359512984222BE10F8Be',
         safeModule: '0xa0bC1477cfc452C05786262c377DE51FB8bc4669',
         multisendCallOnly: '0x9641d764fc13c8B624c04430C7356C1C7C8102e2',
+        rpcUrl: 'https://sepolia.base.org',
     },
     // MAINNET CONFIGURATIONS
     // Arbitrum One (42161) - Mainnet
@@ -48,6 +54,7 @@ exports.CONTRACT_ADDRESSES_BY_CHAIN = {
         gasRegistry: '0x93dDB2307F3Af5df85F361E5Cddd898Acd3d132d',
         jobRegistry: '0xAf1189aFd1F1880F09AeC3Cbc32cf415c735C710',
         multisendCallOnly: '0x9641d764fc13c8B624c04430C7356C1C7C8102e2',
+        rpcUrl: 'https://arb1.arbitrum.io/rpc',
     },
     // Default/fallbacks can be extended as needed for other networks
 };
@@ -57,6 +64,31 @@ 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;
+    }
+    // Convert chainId to number for network configuration
+    const chainIdNum = chainId ? Number(chainId) : undefined;
+    if (!chainIdNum) {
+        // If no chainId, create provider without network (will auto-detect)
+        return new ethers_1.ethers.JsonRpcProvider(rpcUrl);
+    }
+    // Create a Network object with the chainId to explicitly set the network
+    // This prevents the provider from trying to auto-detect the network,
+    // which can cause timeouts when the RPC is slow or unresponsive
+    const network = ethers_1.ethers.Network.from(chainIdNum);
+    // Create provider with explicit network to skip network detection
+    // This prevents timeout issues when RPC is slow or unresponsive
+    return new ethers_1.ethers.JsonRpcProvider(rpcUrl, network);
+}
 function getChainAddresses(chainId) {
     const chainKey = String(chainId ?? '');
     const mapped = exports.CONTRACT_ADDRESSES_BY_CHAIN[chainKey];
@@ -67,5 +99,6 @@ function getChainAddresses(chainId) {
         safeModule: mapped ? mapped.safeModule : '',
         safeSingleton: mapped ? mapped.safeSingleton : '',
         multisendCallOnly: mapped ? mapped.multisendCallOnly : '',
+        rpcUrl: mapped ? mapped.rpcUrl : '',
     };
 }

package/dist/contracts/JobRegistry.js

@@ -2,12 +2,17 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createJobOnChain = createJobOnChain;
 exports.deleteJobOnChain = deleteJobOnChain;
-const ethers_1 = require("ethers");
+const contractUtils_1 = require("./contractUtils");
 async function createJobOnChain({ jobTitle, jobType, timeFrame, targetContractAddress, encodedData, contractAddress, abi, signer, }) {
-    const contract = new ethers_1.ethers.Contract(contractAddress, abi, signer);
-    const tx = await contract.createJob(jobTitle, jobType, timeFrame, targetContractAddress, encodedData);
+    // Resolve chain ID and create contract with SDK RPC provider
+    const chainId = await (0, contractUtils_1.resolveChainId)(signer);
+    const { contract, contractWithSigner } = await (0, contractUtils_1.createContractWithSdkRpcAndSigner)(contractAddress, abi, signer, chainId);
+    // Use contractWithSigner for transaction (signing)
+    // Use contract for reading/parsing logs (SDK RPC)
+    const tx = await contractWithSigner.createJob(jobTitle, jobType, timeFrame, targetContractAddress, encodedData);
     const receipt = await tx.wait();
     // Try to extract jobId from event logs (assume event is JobCreated(jobId,...))
+    // Use contract (with SDK RPC) for parsing logs
     const event = receipt.logs
         .map((log) => {
         try {
@@ -24,7 +29,9 @@ async function createJobOnChain({ jobTitle, jobType, timeFrame, targetContractAd
     throw new Error('Job ID not found in contract events');
 }
 async function deleteJobOnChain({ jobId, contractAddress, abi, signer, }) {
-    const contract = new ethers_1.ethers.Contract(contractAddress, abi.abi, signer);
-    const tx = await contract.deleteJob(jobId);
+    // Resolve chain ID and create contract with SDK RPC provider
+    const chainId = await (0, contractUtils_1.resolveChainId)(signer);
+    const { contractWithSigner } = await (0, contractUtils_1.createContractWithSdkRpcAndSigner)(contractAddress, abi.abi || abi, signer, chainId);
+    const tx = await contractWithSigner.deleteJob(jobId);
     await tx.wait();
 }

package/dist/contracts/contractUtils.d.ts

@@ -0,0 +1,54 @@
+import { ethers, Contract } from 'ethers';
+/**
+ * Get SDK RPC provider for a given chain ID
+ * This ensures reliable connection even if user's RPC fails
+ * @param chainId - Chain ID as string or number
+ * @returns ethers.JsonRpcProvider instance
+ * @throws ConfigurationError if RPC provider is not available
+ */
+export declare function getSdkRpcProvider(chainId: string | number | undefined): ethers.JsonRpcProvider;
+/**
+ * Resolve chain ID from signer's provider or use provided chainId
+ * @param signer - ethers.Signer instance
+ * @param chainId - Optional chain ID (takes precedence if provided)
+ * @returns Resolved chain ID as string
+ * @throws ConfigurationError if chain ID cannot be resolved
+ */
+export declare function resolveChainId(signer: ethers.Signer, chainId?: string | number): Promise<string>;
+/**
+ * Create a contract instance with SDK RPC provider for read operations and gas estimation
+ * This ensures reliable contract interaction even if user's RPC fails
+ * @param contractAddress - Contract address
+ * @param abi - Contract ABI
+ * @param chainId - Chain ID (will be resolved if not provided)
+ * @param signer - Optional signer (used to resolve chainId if not provided)
+ * @returns Contract instance connected to SDK RPC provider
+ */
+export declare function createContractWithSdkRpc(contractAddress: string, abi: any, chainId: string | number | undefined, signer?: ethers.Signer): Promise<Contract>;
+/**
+ * Create a contract instance with SDK RPC provider and connect signer for transactions
+ * This pattern is used for operations that need:
+ * - SDK RPC for reads/estimations (reliable even if user's RPC fails)
+ * - User's signer for transaction signing
+ * @param contractAddress - Contract address
+ * @param abi - Contract ABI
+ * @param signer - Signer instance (used for signing transactions)
+ * @param chainId - Optional chain ID (will be resolved from signer if not provided)
+ * @returns Object containing:
+ *   - contract: Contract instance with SDK RPC (for reads/estimations)
+ *   - contractWithSigner: Contract instance connected to signer (for transactions)
+ *   - chainId: Resolved chain ID
+ */
+export declare function createContractWithSdkRpcAndSigner(contractAddress: string, abi: any, signer: ethers.Signer, chainId?: string | number): Promise<{
+    contract: Contract;
+    contractWithSigner: Contract;
+    chainId: string;
+}>;
+/**
+ * Get contract address for a given chain ID
+ * @param chainId - Chain ID as string or number
+ * @param contractType - Type of contract ('gasRegistry' | 'jobRegistry')
+ * @returns Contract address
+ * @throws ConfigurationError if contract address is not configured
+ */
+export declare function getContractAddress(chainId: string | number | undefined, contractType: 'gasRegistry' | 'jobRegistry'): string;

package/dist/contracts/contractUtils.js

@@ -0,0 +1,125 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSdkRpcProvider = getSdkRpcProvider;
+exports.resolveChainId = resolveChainId;
+exports.createContractWithSdkRpc = createContractWithSdkRpc;
+exports.createContractWithSdkRpcAndSigner = createContractWithSdkRpcAndSigner;
+exports.getContractAddress = getContractAddress;
+const ethers_1 = require("ethers");
+const config_1 = require("../config");
+const errors_1 = require("../utils/errors");
+/**
+ * Get SDK RPC provider for a given chain ID
+ * This ensures reliable connection even if user's RPC fails
+ * @param chainId - Chain ID as string or number
+ * @returns ethers.JsonRpcProvider instance
+ * @throws ConfigurationError if RPC provider is not available
+ */
+function getSdkRpcProvider(chainId) {
+    if (!chainId) {
+        throw new errors_1.ConfigurationError('Chain ID is required to get RPC provider');
+    }
+    const rpcProvider = (0, config_1.getRpcProvider)(chainId);
+    if (!rpcProvider) {
+        throw new errors_1.ConfigurationError(`RPC URL not configured for chain ID: ${chainId}`);
+    }
+    return rpcProvider;
+}
+/**
+ * Resolve chain ID from signer's provider or use provided chainId
+ * @param signer - ethers.Signer instance
+ * @param chainId - Optional chain ID (takes precedence if provided)
+ * @returns Resolved chain ID as string
+ * @throws ConfigurationError if chain ID cannot be resolved
+ */
+async function resolveChainId(signer, chainId) {
+    // If chainId is provided, use it
+    if (chainId) {
+        return chainId.toString();
+    }
+    // Try to get chainId from signer's provider
+    try {
+        const network = await signer.provider?.getNetwork();
+        if (network?.chainId) {
+            return network.chainId.toString();
+        }
+    }
+    catch (providerError) {
+        // If user's RPC fails, we can't get chainId from it
+        console.warn('Could not get network from signer provider:', providerError);
+    }
+    throw new errors_1.ConfigurationError('Chain ID is required. Please provide chainId parameter or ensure signer has a working provider.');
+}
+/**
+ * Create a contract instance with SDK RPC provider for read operations and gas estimation
+ * This ensures reliable contract interaction even if user's RPC fails
+ * @param contractAddress - Contract address
+ * @param abi - Contract ABI
+ * @param chainId - Chain ID (will be resolved if not provided)
+ * @param signer - Optional signer (used to resolve chainId if not provided)
+ * @returns Contract instance connected to SDK RPC provider
+ */
+async function createContractWithSdkRpc(contractAddress, abi, chainId, signer) {
+    // Resolve chain ID
+    let resolvedChainId;
+    if (chainId) {
+        resolvedChainId = chainId.toString();
+    }
+    else if (signer) {
+        resolvedChainId = await resolveChainId(signer);
+    }
+    else {
+        throw new errors_1.ConfigurationError('Chain ID or signer is required to create contract');
+    }
+    // Get SDK RPC provider
+    const rpcProvider = getSdkRpcProvider(resolvedChainId);
+    // Create contract instance with SDK RPC provider
+    return new ethers_1.ethers.Contract(contractAddress, abi, rpcProvider);
+}
+/**
+ * Create a contract instance with SDK RPC provider and connect signer for transactions
+ * This pattern is used for operations that need:
+ * - SDK RPC for reads/estimations (reliable even if user's RPC fails)
+ * - User's signer for transaction signing
+ * @param contractAddress - Contract address
+ * @param abi - Contract ABI
+ * @param signer - Signer instance (used for signing transactions)
+ * @param chainId - Optional chain ID (will be resolved from signer if not provided)
+ * @returns Object containing:
+ *   - contract: Contract instance with SDK RPC (for reads/estimations)
+ *   - contractWithSigner: Contract instance connected to signer (for transactions)
+ *   - chainId: Resolved chain ID
+ */
+async function createContractWithSdkRpcAndSigner(contractAddress, abi, signer, chainId) {
+    // Resolve chain ID
+    const resolvedChainId = await resolveChainId(signer, chainId);
+    // Get SDK RPC provider
+    const rpcProvider = getSdkRpcProvider(resolvedChainId);
+    // Create contract instance with SDK RPC provider (for reads/estimations)
+    const contract = new ethers_1.ethers.Contract(contractAddress, abi, rpcProvider);
+    // Connect signer to contract (for transactions)
+    const contractWithSigner = contract.connect(signer);
+    return {
+        contract,
+        contractWithSigner,
+        chainId: resolvedChainId,
+    };
+}
+/**
+ * Get contract address for a given chain ID
+ * @param chainId - Chain ID as string or number
+ * @param contractType - Type of contract ('gasRegistry' | 'jobRegistry')
+ * @returns Contract address
+ * @throws ConfigurationError if contract address is not configured
+ */
+function getContractAddress(chainId, contractType) {
+    if (!chainId) {
+        throw new errors_1.ConfigurationError('Chain ID is required to get contract address');
+    }
+    const addresses = (0, config_1.getChainAddresses)(chainId);
+    const address = contractType === 'gasRegistry' ? addresses.gasRegistry : addresses.jobRegistry;
+    if (!address) {
+        throw new errors_1.ConfigurationError(`${contractType} address not configured for chain ID: ${chainId}`);
+    }
+    return address;
+}

package/dist/contracts/index.d.ts

@@ -2,3 +2,4 @@ export * from './JobRegistry';
 export * from './safe/SafeFactory';
 export * from './safe/SafeWallet';
 export * from './TriggerXContract';
+export * from './contractUtils';

package/dist/contracts/index.js

@@ -19,3 +19,5 @@ __exportStar(require("./JobRegistry"), exports);
 __exportStar(require("./safe/SafeFactory"), exports);
 __exportStar(require("./safe/SafeWallet"), exports);
 __exportStar(require("./TriggerXContract"), exports);
+// Contract utilities for RPC provider management
+__exportStar(require("./contractUtils"), exports);

package/package.json

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