sdk-triggerx 0.1.28 → 0.1.29

package/dist/api/checkTgBalance.js

@@ -6,7 +6,7 @@ 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");
 /**
  * Check TG balance for a given signer using SDK-provided RPC
@@ -22,36 +22,31 @@ const checkTgBalance = async (signer, chainId) => {
         return (0, errors_1.createErrorResponse)(new errors_1.ValidationError('signer', 'Signer is required'), 'Validation error');
     }
     try {
-        // 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);
+        // 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');
         }
-        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');
+        // Get contract address
+        let gasRegistryContractAddress;
+        try {
+            gasRegistryContractAddress = (0, contractUtils_1.getContractAddress)(resolvedChainId, 'gasRegistry');
         }
-        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: ${resolvedChainId}`), 'Configuration error');
+        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');
         }
-        // Use SDK-provided RPC provider instead of user's provider
+        // Create contract instance with SDK RPC provider (read-only)
         // 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');
-        }
-        // Create contract instance with our RPC provider (read-only)
-        const contract = new ethers_1.ethers.Contract(gasRegistryContractAddress, GasRegistry_json_1.default, rpcProvider);
+        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

package/dist/api/jobs.js

@@ -372,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;
@@ -383,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;
@@ -399,8 +405,11 @@ 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.
@@ -419,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;
@@ -434,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.js

@@ -75,7 +75,19 @@ function getRpcProvider(chainId) {
     if (!rpcUrl) {
         return null;
     }
-    return new ethers_1.ethers.JsonRpcProvider(rpcUrl);
+    // 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 ?? '');

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.28",
+  "version": "0.1.29",
   "description": "SDK for interacting with the TriggerX backend and smart contracts.",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",