sdk-triggerx 0.1.0

package/dist/types.d.ts

@@ -0,0 +1,134 @@
+export interface Task {
+    id: string;
+    name: string;
+    status: 'pending' | 'completed' | 'failed';
+    createdAt: string;
+}
+export interface ApiResponse<T> {
+    data: T;
+    error?: string;
+}
+export declare enum JobType {
+    Time = "time",
+    Event = "event",
+    Condition = "condition"
+}
+export declare enum ArgType {
+    Static = "static",
+    Dynamic = "dynamic"
+}
+export type CreateJobInput = (TimeBasedJobInput & {
+    jobType: JobType.Time;
+    argType: ArgType.Static | ArgType.Dynamic;
+}) | (EventBasedJobInput & {
+    jobType: JobType.Event;
+    argType: ArgType.Static | ArgType.Dynamic;
+}) | (ConditionBasedJobInput & {
+    jobType: JobType.Condition;
+    argType: ArgType.Static | ArgType.Dynamic;
+});
+export interface TimeBasedJobInput {
+    userAddress: string;
+    etherBalance: BigInt | number;
+    tokenBalance: BigInt | number;
+    jobTitle: string;
+    timeFrame: number;
+    scheduleType: 'cron' | 'specific' | 'interval';
+    timeInterval?: number;
+    cronExpression?: string;
+    specificSchedule?: string;
+    timezone: string;
+    recurring?: boolean;
+    jobCostPrediction: number;
+    createdChainId: string;
+    targetChainId: string;
+    targetContractAddress: string;
+    targetFunction: string;
+    abi: string;
+    isImua?: boolean;
+    arguments?: string[];
+    dynamicArgumentsScriptUrl?: string;
+}
+export interface EventBasedJobInput {
+    userAddress: string;
+    etherBalance: BigInt | number;
+    tokenBalance: BigInt | number;
+    jobTitle: string;
+    timeFrame: number;
+    triggerChainId: string;
+    triggerContractAddress: string;
+    triggerEvent: string;
+    timezone: string;
+    recurring?: boolean;
+    jobCostPrediction: number;
+    createdChainId: string;
+    targetChainId: string;
+    targetContractAddress: string;
+    targetFunction: string;
+    abi: string;
+    isImua?: boolean;
+    arguments?: string[];
+    dynamicArgumentsScriptUrl?: string;
+}
+export interface ConditionBasedJobInput {
+    userAddress: string;
+    etherBalance: BigInt | number;
+    tokenBalance: BigInt | number;
+    jobTitle: string;
+    timeFrame: number;
+    conditionType: string;
+    upperLimit: number;
+    lowerLimit: number;
+    valueSourceType: string;
+    valueSourceUrl: string;
+    timezone: string;
+    recurring?: boolean;
+    jobCostPrediction: number;
+    createdChainId: string;
+    targetChainId: string;
+    targetContractAddress: string;
+    targetFunction: string;
+    abi: string;
+    isImua?: boolean;
+    arguments?: string[];
+    dynamicArgumentsScriptUrl?: string;
+}
+export interface CreateJobData {
+    job_id: string;
+    user_address: string;
+    ether_balance: BigInt | number;
+    token_balance: BigInt | number;
+    job_title: string;
+    task_definition_id: number;
+    custom: boolean;
+    time_frame: number;
+    recurring: boolean;
+    job_cost_prediction: number;
+    timezone: string;
+    created_chain_id: string;
+    schedule_type?: string;
+    time_interval?: number;
+    cron_expression?: string;
+    specific_schedule?: string;
+    trigger_chain_id?: string;
+    trigger_contract_address?: string;
+    trigger_event?: string;
+    condition_type?: string;
+    upper_limit?: number;
+    lower_limit?: number;
+    value_source_type?: string;
+    value_source_url?: string;
+    target_chain_id: string;
+    target_contract_address: string;
+    target_function: string;
+    abi: string;
+    arg_type: number;
+    arguments?: string[];
+    dynamic_arguments_script_url?: string;
+    is_imua: boolean;
+}
+export interface JobResponse {
+    success: boolean;
+    data?: any;
+    error?: string;
+}

package/dist/types.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ArgType = exports.JobType = void 0;
+// Enums for job type and argument type
+var JobType;
+(function (JobType) {
+    JobType["Time"] = "time";
+    JobType["Event"] = "event";
+    JobType["Condition"] = "condition";
+})(JobType || (exports.JobType = JobType = {}));
+var ArgType;
+(function (ArgType) {
+    ArgType["Static"] = "static";
+    ArgType["Dynamic"] = "dynamic";
+})(ArgType || (exports.ArgType = ArgType = {}));

package/dist/utils/errors.d.ts

@@ -0,0 +1,4 @@
+export declare class TriggerXError extends Error {
+    constructor(message: string);
+}
+export declare function wrapError(error: unknown): TriggerXError;

package/dist/utils/errors.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TriggerXError = void 0;
+exports.wrapError = wrapError;
+class TriggerXError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'TriggerXError';
+    }
+}
+exports.TriggerXError = TriggerXError;
+function wrapError(error) {
+    if (error instanceof Error) {
+        return new TriggerXError(error.message);
+    }
+    return new TriggerXError('Unknown error');
+}

package/jest.config.js

@@ -0,0 +1,7 @@
+module.exports = {
+  preset: 'ts-jest',
+  testEnvironment: 'node',
+  testMatch: ['**/test/**/*.test.ts'],
+  moduleFileExtensions: ['ts', 'js', 'json'],
+  roots: ['<rootDir>/src', '<rootDir>/test'],
+}; 

package/package.json

@@ -0,0 +1,32 @@
+{
+  "name": "sdk-triggerx",
+  "version": "0.1.0",
+  "description": "SDK for interacting with the TriggerX backend and smart contracts.",
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "scripts": {
+    "build": "tsc",
+    "test": "jest",
+    "lint": "eslint src --ext .ts"
+  },
+  "author": "",
+  "license": "MIT",
+  "directories": {
+    "test": "test"
+  },
+  "keywords": [],
+  "dependencies": {
+    "axios": "^1.11.0",
+    "dotenv": "^17.2.1",
+    "ethers": "^6.15.0"
+  },
+  "devDependencies": {
+    "@types/jest": "^30.0.0",
+    "@typescript-eslint/eslint-plugin": "^8.38.0",
+    "@typescript-eslint/parser": "^8.38.0",
+    "eslint": "^9.32.0",
+    "jest": "^30.0.5",
+    "ts-jest": "^29.4.0",
+    "typescript": "^5.8.3"
+  }
+}

package/scripts/deploy.ts

@@ -0,0 +1,9 @@
+// scripts/deploy.ts
+// Script for deploying/testing contracts
+
+async function main() {
+  // TODO: Implement contract deployment logic
+  console.log('Deploy script placeholder');
+}
+
+main(); 

package/src/api/checkTgBalance.ts

@@ -0,0 +1,27 @@
+import { ethers } from 'ethers';
+import gasRegistryAbi from '../contracts/abi/GasRegistry.json';
+
+export const checkTgBalance = async (signer: ethers.Signer) => {
+    const gasRegistryContractAddress = process.env.GAS_REGISTRY_CONTRACT_ADDRESS as string || '0x85ea3eB894105bD7e7e2A8D34cf66C8E8163CD2a';
+    if (!gasRegistryContractAddress) {
+        throw new Error('GAS_REGISTRY_CONTRACT_ADDRESS is not set in the environment variables');
+    }
+    const contract = new ethers.Contract(gasRegistryContractAddress, gasRegistryAbi, signer);
+    const address = await signer.getAddress();
+    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
+    // If balance is an array: [ethSpent, TGbalance]
+    // If balance is an object: { ethSpent, TGbalance }
+    let tgBalanceWei;
+    if (Array.isArray(balance)) {
+        tgBalanceWei = balance[1];
+    } else if (balance && balance.TGbalance !== undefined) {
+        tgBalanceWei = balance.TGbalance;
+    } else {
+        throw new Error('Unexpected balance format');
+    }
+    const tgBalanceEth = ethers.formatEther(tgBalanceWei);
+    console.log('tgBalanceEth', tgBalanceEth);
+    return tgBalanceEth;
+};

package/src/api/deleteJob.ts

@@ -0,0 +1,22 @@
+// sdk-triggerx/src/api/deleteJob.ts
+
+import { TriggerXClient } from '../client';
+
+export const deleteJob = async (client: TriggerXClient, jobId: string): Promise<void> => {
+  const apiKey = client.getApiKey(); // Assuming you have a method to get the API key
+
+  try {
+    await client.put<void>(
+      `api/jobs/delete/${jobId}`, {}, 
+      {
+        headers: {
+          'Content-Type': 'application/json',
+          'X-API-KEY': apiKey,
+        },
+      }
+    );
+  } catch (error) {
+    console.error('Error deleting job:', error);
+    throw error; // Rethrow the error for handling in the calling function
+  }
+};

package/src/api/getJobDataById.ts

@@ -0,0 +1,24 @@
+// sdk-triggerx/src/api/getJobDataById.ts
+
+import { TriggerXClient } from '../client';
+import { JobDataAPI } from '../types';
+
+export const getJobDataById = async (client: TriggerXClient, jobId: string): Promise<JobDataAPI> => {
+  const apiKey = client.getApiKey(); // Assuming you have a method to get the API key
+
+  try {
+    const response = await client.get<JobDataAPI>(
+        `/api/jobs/${jobId}`, 
+        {
+            headers: {
+                'Content-Type': 'application/json',
+                'X-API-KEY': apiKey,
+            },
+        }
+    );
+    return response; // Assuming the response data matches the JobDataAPI interface
+  } catch (error) {
+    console.error('Error fetching job data by ID:', error);
+    throw error; // Rethrow the error for handling in the calling function
+  }
+};

package/src/api/getUserData.ts

@@ -0,0 +1,24 @@
+// sdk-triggerx/src/api/getUserData.ts
+
+import { TriggerXClient } from '../client';
+import { UserData } from '../types';
+
+export const getUserData = async (client: TriggerXClient, address: string): Promise<UserData> => {
+  const apiKey = client.getApiKey(); // Assuming you have a method to get the API key
+
+  try {
+    const response = await client.get<UserData>(
+      `api/users/${address}`, 
+      {
+        headers: {
+          'Content-Type': 'application/json',
+          'X-API-KEY': apiKey,
+        },
+      }
+    );
+    return response; // Assuming the response data matches the UserData interface
+  } catch (error) {
+    console.error('Error fetching user data:', error);
+    throw error; // Rethrow the error for handling in the calling function
+  }
+};

package/src/api/getjob.ts

@@ -0,0 +1,26 @@
+import { TriggerXClient } from '../client';
+import { JobResponseUser, JobResponseAPI } from '../types';
+
+/**
+ * Fetch job data for a given API key by calling the backend endpoint.
+ * @param client TriggerXClient instance
+ * @returns JobResponse containing job data or error
+ */
+export async function getJobData(client: TriggerXClient): Promise<JobResponseUser> {
+  try {
+
+    const apiKey = client.getApiKey(); // Assuming you have a method to get the API key
+    const data = await client.get<JobResponseUser>(
+      '/api/jobs/by-apikey',
+      {
+        headers: {
+          'Content-Type': 'application/json',
+          'X-API-KEY': apiKey,
+        },
+      }
+    );
+    return { success: true, jobs: data.jobs };
+  } catch (error) {
+    return { success: false, error: (error as Error).message,};
+  }
+} 

package/src/api/jobs.ts

@@ -0,0 +1,303 @@
+import { TriggerXClient } from '../client';
+import {
+  TimeBasedJobInput,
+  EventBasedJobInput,
+  ConditionBasedJobInput,
+  CreateJobData,
+  JobResponse,
+} from '../types';
+import { createJobOnChain } from '../contracts/JobRegistry';
+import { ethers, Signer } from 'ethers';
+import jobRegistryAbi from '../contracts/abi/JobRegistry.json';
+import { topupTg } from './topupTg';
+import { checkTgBalance } from './checkTgBalance';
+const JOB_ID = '300949528249665590178224313442040528409305273634097553067152835846309150732';
+const DYNAMIC_ARGS_URL = 'https://teal-random-koala-993.mypinata.cloud/ipfs/bafkreif426p7t7takzhw3g6we2h6wsvf27p5jxj3gaiynqf22p3jvhx4la';
+const JOB_REGISTRY_ADDRESS = '0xdB66c11221234C6B19cCBd29868310c31494C21C'; // Set your fixed contract address here
+
+export function toCreateJobDataFromTime(input: TimeBasedJobInput): CreateJobData {
+  return {
+    job_id: JOB_ID,
+    user_address: input.userAddress,
+    ether_balance: input.etherBalance,
+    token_balance: input.tokenBalance,
+    job_title: input.jobTitle,
+    task_definition_id: input.dynamicArgumentsScriptUrl ? 2 : 1,
+    custom: true,
+    time_frame: input.timeFrame,
+    recurring: input.recurring ?? false,
+    job_cost_prediction: input.jobCostPrediction,
+    timezone: input.timezone,
+    created_chain_id: input.createdChainId,
+    schedule_type: input.scheduleType,
+    time_interval: input.timeInterval,
+    cron_expression: input.cronExpression,
+    specific_schedule: input.specificSchedule,
+    target_chain_id: input.targetChainId,
+    target_contract_address: input.targetContractAddress,
+    target_function: input.targetFunction,
+    abi: input.abi,
+    arg_type: input.dynamicArgumentsScriptUrl ? 2 : 1,
+    arguments: input.arguments,
+    dynamic_arguments_script_url: input.dynamicArgumentsScriptUrl,
+    is_imua: input.isImua ?? true,
+  };
+}
+
+export function toCreateJobDataFromEvent(input: EventBasedJobInput): CreateJobData {
+  return {
+    job_id: JOB_ID,
+    user_address: input.userAddress,
+    ether_balance: input.etherBalance,
+    token_balance: input.tokenBalance,
+    job_title: input.jobTitle,
+    task_definition_id: input.dynamicArgumentsScriptUrl ? 4 : 3,
+    custom: true,
+    time_frame: input.timeFrame,
+    recurring: input.recurring ?? false,
+    job_cost_prediction: input.jobCostPrediction,
+    timezone: input.timezone,
+    created_chain_id: input.createdChainId,
+    trigger_chain_id: input.triggerChainId,
+    trigger_contract_address: input.triggerContractAddress,
+    trigger_event: input.triggerEvent,
+    target_chain_id: input.targetChainId,
+    target_contract_address: input.targetContractAddress,
+    target_function: input.targetFunction,
+    abi: input.abi,
+    arg_type: input.dynamicArgumentsScriptUrl ? 2 : 1,
+    arguments: input.arguments,
+    dynamic_arguments_script_url: input.dynamicArgumentsScriptUrl,
+    is_imua: input.isImua ?? true,
+  };
+}
+
+export function toCreateJobDataFromCondition(input: ConditionBasedJobInput): CreateJobData {
+  return {
+    job_id: JOB_ID,
+    user_address: input.userAddress,
+    ether_balance: input.etherBalance,
+    token_balance: input.tokenBalance,
+    job_title: input.jobTitle,
+    task_definition_id: input.dynamicArgumentsScriptUrl ? 6 : 5,
+    custom: true,
+    time_frame: input.timeFrame,
+    recurring: input.recurring ?? false,
+    job_cost_prediction: input.jobCostPrediction,
+    timezone: input.timezone,
+    created_chain_id: input.createdChainId,
+    condition_type: input.conditionType,
+    upper_limit: input.upperLimit,
+    lower_limit: input.lowerLimit,
+    value_source_type: input.valueSourceType,
+    value_source_url: input.valueSourceUrl,
+    target_chain_id: input.targetChainId,
+    target_contract_address: input.targetContractAddress,
+    target_function: input.targetFunction,
+    abi: input.abi,
+    arg_type: input.dynamicArgumentsScriptUrl ? 2 : 1,
+    arguments: input.arguments,
+    dynamic_arguments_script_url: input.dynamicArgumentsScriptUrl,
+    is_imua: input.isImua ?? true,
+  };
+}
+
+// --- Encoding helpers for different job types ---
+function encodeJobType1Data(timeInterval: number) {
+  return ethers.AbiCoder.defaultAbiCoder().encode(
+    ['uint256'],
+    [timeInterval]
+  );
+}
+
+function encodeJobType2Data(timeInterval: number, ipfsHash: string) {
+  return ethers.AbiCoder.defaultAbiCoder().encode(
+    ['uint256', 'bytes32'],
+    [timeInterval, ipfsHash]
+  );
+}
+
+function encodeJobType3or5Data(recurringJob: boolean) {
+  return ethers.AbiCoder.defaultAbiCoder().encode(
+    ['bool'],
+    [recurringJob]
+  );
+}
+
+function encodeJobType4or6Data(recurringJob: boolean, ipfsHash: string) {
+  return ethers.AbiCoder.defaultAbiCoder().encode(
+    ['bool', 'bytes32'],
+    [recurringJob, ipfsHash]
+  );
+}
+
+export interface CreateJobParams {
+  jobInput: TimeBasedJobInput | EventBasedJobInput | ConditionBasedJobInput;
+  signer: Signer;
+  encodedData?: string;
+}
+
+/**
+ * Create a job on the blockchain.
+ * @param client TriggerXClient instance
+ * @param params Parameters for creating the job
+ * @returns JobResponse containing the result of the job creation
+ */
+export async function createJob(
+  client: TriggerXClient,
+  params: CreateJobParams
+): Promise<JobResponse> {
+  let { jobInput, signer, encodedData } = params;
+
+  // Use the API key from the client instance
+  const apiKey = client.getApiKey();
+
+  let jobTitle: string, timeFrame: number, targetContractAddress: string, jobType: number;
+  if ('jobTitle' in jobInput) jobTitle = jobInput.jobTitle;
+  if ('timeFrame' in jobInput) timeFrame = jobInput.timeFrame;
+  if ('targetContractAddress' in jobInput) targetContractAddress = jobInput.targetContractAddress;
+
+  // Infer jobType from jobInput
+  if ('scheduleType' in jobInput) {
+    jobType = jobInput.dynamicArgumentsScriptUrl ? 2 : 1; // Time-based job
+  } else if ('triggerChainId' in jobInput) {
+    jobType = jobInput.dynamicArgumentsScriptUrl ? 4 : 3; // Event-based job
+  } else {
+    jobType = jobInput.dynamicArgumentsScriptUrl ? 6 : 5; // Condition-based job
+  }
+
+  // --- Generate encodedData if not provided ---
+  if (!encodedData) {
+    // Time-based jobs
+    if ('scheduleType' in jobInput) {
+      if (jobType === 1) {
+        encodedData = encodeJobType1Data(jobInput.timeInterval ?? 0);
+      } else if (jobType === 2) {
+        encodedData = encodeJobType2Data(jobInput.timeInterval ?? 0, jobInput.dynamicArgumentsScriptUrl || '');
+      }
+    }
+    // Event-based jobs
+    else if ('triggerChainId' in jobInput) {
+      if (jobType === 3 || jobType === 5) {
+        encodedData = encodeJobType3or5Data(jobInput.recurring ?? false);
+      } else if (jobType === 4 || jobType === 6) {
+        encodedData = encodeJobType4or6Data(jobInput.recurring ?? false, jobInput.dynamicArgumentsScriptUrl || '');
+      }
+    }
+    // Condition-based jobs
+    else {
+      if (jobType === 3 || jobType === 5) {
+        encodedData = encodeJobType3or5Data(jobInput.recurring ?? false);
+      } else if (jobType === 4 || jobType === 6) {
+        encodedData = encodeJobType4or6Data(jobInput.recurring ?? false, jobInput.dynamicArgumentsScriptUrl || '');
+      }
+    }
+  }
+  // Handle job_cost_prediction logic based on argType (static/dynamic)
+  // If static, set to 0.1. If dynamic, call backend API to get fee and ask user to proceed.
+
+  // Determine argType directly from user input
+  let argType: number = 1; // default to static
+  if ('argType' in jobInput) {
+    if (jobInput.argType === 'dynamic' || jobInput.argType === 2) {
+      argType = 2;
+    } else {
+      argType = 1;
+    }
+  }
+
+  //if jobis time based then check the no of executions of the job from time frame and time interval by deviding time frame by time interval
+  let noOfExecutions: number = 1;
+  if ('scheduleType' in jobInput) {
+    noOfExecutions = jobInput.timeFrame / (jobInput.timeInterval ?? 0);
+  }
+
+  // Set job_cost_prediction
+  let job_cost_prediction: number = 0.1 * noOfExecutions; // default for static
+
+  if (argType === 2) {
+    // Dynamic: call backend API to get fee
+    const ipfs_url = jobInput.dynamicArgumentsScriptUrl;
+    if (!ipfs_url) {
+      throw new Error('dynamicArgumentsScriptUrl is required for dynamic argType');
+    }
+
+    
+    // Call backend API to get fee
+    let fee: number = 0;
+    try {
+      const feeRes = await client.get<any>(
+        '/api/fees',
+        { params: { ipfs_url } }
+      );
+      // The API now returns { total_fee: number }
+      if (feeRes && typeof feeRes.total_fee === 'number') {
+        fee = feeRes.total_fee;
+      } else if (feeRes && feeRes.data && typeof feeRes.data.total_fee === 'number') {
+        fee = feeRes.data.total_fee;
+      } else {
+        throw new Error('Invalid response from /api/fees: missing total_fee');
+      }
+    } catch (err) {
+      throw new Error('Failed to fetch job cost prediction: ' + (err as Error).message);
+    }
+    job_cost_prediction = fee * noOfExecutions;
+  }
+    // 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
+    const tgBalance = await checkTgBalance(signer);
+    if (Number(tgBalance) < job_cost_prediction) {
+      // Check if user has enabled auto topup
+      // For each job type, autotopupTG should be present in jobInput
+      const autoTopupTG = (jobInput as any).autotopupTG === true;
+      if (!autoTopupTG) {
+        throw new Error(`Insufficient TG balance. Job cost prediction is ${job_cost_prediction}. Current TG balance: ${tgBalance}. Please set autotopupTG: true in jobInput.`);
+      } else {
+        // autotopupTG is true, automatically top up
+        await topupTg(job_cost_prediction, signer);
+      }
+    } 
+  // Patch jobInput with job_cost_prediction for downstream usage
+  (jobInput as any).jobCostPrediction = job_cost_prediction;
+
+  const jobId = await createJobOnChain({
+    jobTitle: jobTitle!,
+    jobType,
+    timeFrame: timeFrame!,
+    targetContractAddress: targetContractAddress!,
+    encodedData: encodedData || '',
+    contractAddress: JOB_REGISTRY_ADDRESS,
+    abi: jobRegistryAbi.abi,
+    signer,
+  });
+
+  // 2. Convert input to CreateJobData
+  let jobData: CreateJobData;
+  if ('scheduleType' in jobInput) {
+    jobData = toCreateJobDataFromTime(jobInput as TimeBasedJobInput);
+  } else if ('triggerChainId' in jobInput) {
+    jobData = toCreateJobDataFromEvent(jobInput as EventBasedJobInput);
+  } else {
+    jobData = toCreateJobDataFromCondition(jobInput as ConditionBasedJobInput);
+  }
+  // 3. Set the job_id from contract
+  jobData.job_id = jobId;
+
+  // 4. Call the API
+  try {
+    const res = await client.post<any>(
+      '/api/jobs',
+      [jobData],
+      {
+        headers: { 'Content-Type': 'application/json', 'X-API-KEY': apiKey },
+      }
+    );
+    return { success: true, data: res };
+  } catch (error) {
+    return { success: false, error: (error as Error).message };
+  }
+} 

package/src/api/topupTg.ts

@@ -0,0 +1,17 @@
+import { ethers } from 'ethers';
+import gasRegistryAbi from '../contracts/abi/GasRegistry.json';
+
+export const topupTg = async (tgAmount: number, signer: ethers.Signer) => {
+    const gasRegistryContractAddress = process.env.GAS_REGISTRY_CONTRACT_ADDRESS as string || '0x85ea3eB894105bD7e7e2A8D34cf66C8E8163CD2a';
+    const contract = new ethers.Contract(gasRegistryContractAddress, gasRegistryAbi, signer);
+
+    // Each TG costs 0.001 ETH, so calculate the ETH required for the given TG amount
+    const amountInEth = tgAmount * 0.001;
+    const amountInEthWei = ethers.parseEther(amountInEth.toString());
+    const tx = await contract.purchaseTG(
+        amountInEthWei,
+        { value: amountInEthWei }
+    );
+    await tx.wait();
+    return tx;
+};