zkcloudworker 0.7.1 → 0.7.3

package/lib/ts/src/api/api.d.ts

@@ -1,10 +1,24 @@
 import { zkCloudWorker, Cloud } from "../cloud/cloud";
 import { blockchain } from "../networks";
+/**
+ * The APICommand type for interacting with the zkCloudWorker
+ * @typedef { "recursiveProof" | "execute" | "sendTransactions" | "jobResult" | "deploy" | "getBalance" | "queryBilling" } ApiCommand
+ * @property recursiveProof The command for the recursiveProof calculation
+ * @property execute The command for the execute function call (sync or async)
+ * @property sendTransactions The command for sending transactions to the cloud
+ * @property jobResult The command for getting the result of the job
+ * @property deploy The command for deploying the code to the cloud, it is recommended use CLI tools for deployment
+ * @property getBalance The command for getting the balance of the user's account with zkCloudWorker
+ * @property queryBilling The command for getting the billing report of the user's account with zkCloudWorker
+ */
 export type ApiCommand = "recursiveProof" | "execute" | "sendTransactions" | "jobResult" | "deploy" | "getBalance" | "queryBilling";
 /**
  * API class for interacting with the zkCloudWorker
  * @property jwt The jwt token for authentication, get it at https://t.me/minanft_bot?start=auth
  * @property endpoint The endpoint of the serverless api
+ * @property chain The blockchain network to use
+ * @property webhook The webhook for the serverless api to get the results
+ * @property localWorker The local worker for the serverless api to test the code locally
  */
 export declare class zkCloudWorkerClient {
     readonly jwt: string;
@@ -15,6 +29,9 @@ export declare class zkCloudWorkerClient {
     /**
      * Constructor for the API class
      * @param jwt The jwt token for authentication, get it at https://t.me/minanft_bot?start=auth
+     * @param zkcloudworker The local worker for the serverless api to test the code locally
+     * @param chain The blockchain network to use
+     * @param webhook The webhook for the serverless api to get the results
      */
     constructor(params: {
         jwt: string;
@@ -24,19 +41,20 @@ export declare class zkCloudWorkerClient {
     });
     /**
      * Starts a new job for the proof calculation using serverless api call
-     * The developer and name should correspond to the BackupPlugin of the API
-     * All other parameters should correspond to the parameters of the BackupPlugin
      * @param data the data for the proof call
-     * @param data.transactions the transactions
      * @param data.developer the developer
      * @param data.repo the repo to use
+     * @param data.transactions the transactions
      * @param data.task the task of the job
-     * @param data.args the arguments of the job
+     * @param data.userId the userId of the job
+     * @param data.args the arguments of the job, should be serialized JSON or string
+     * @param data.metadata the metadata of the job, should be serialized JSON or string
+     * @param data.webhook the webhook for the job
      * @returns { success: boolean, error?: string, jobId?: string }
      * where jonId is the jobId of the job
      *
-     * The developers repo should provide a BackupPlugin with the name task
-     * that can be called with the given parameters
+     * The developers repo should provide a zkcloudworker function
+     * that can be called with the given parameters, see the examples
      */
     recursiveProof(data: {
         developer: string;
@@ -54,8 +72,6 @@ export declare class zkCloudWorkerClient {
     }>;
     /**
      * Starts a new job for the function call using serverless api call
-     * The developer and name should correspond to the BackupPlugin of the API
-     * All other parameters should correspond to the parameters of the BackupPlugin
      * @param data the data for the proof call
      * @param data.developer the developer
      * @param data.repo the repo to use
@@ -65,8 +81,8 @@ export declare class zkCloudWorkerClient {
      * @param data.args the arguments of the job
      * @param data.metadata the metadata of the job
      * @param data.mode the mode of the job execution: "sync" will not create a job, it will execute the function synchronously within 30 seconds and with the memory limit of 256 MB
-     * @returns { success: boolean, error?: string, jobId?: string }
-     * where jonId is the jobId of the job
+     * @returns { success: boolean, error?: string, jobId?: string, result?: any }
+     * where jonId is the jobId of the job (for async calls), result is the result of the job (for sync calls)
      */
     execute(data: {
         developer: string;
@@ -84,16 +100,13 @@ export declare class zkCloudWorkerClient {
         result?: any;
     }>;
     /**
-     * Starts a new job for the function call using serverless api call
-     * The developer and name should correspond to the BackupPlugin of the API
-     * All other parameters should correspond to the parameters of the BackupPlugin
+     * Sends transactions to the blockchain using serverless api call
      * @param data the data for the proof call
      * @param data.developer the developer
      * @param data.repo the repo to use
-     * @param data.task the task of the job
-     * @param data.args the arguments of the job
-     * @returns { success: boolean, error?: string, jobId?: string }
-     * where jonId is the jobId of the job
+     * @param data.transactions the transactions
+     * @returns { success: boolean, error?: string, txId?: string[] }
+     * where txId is the transaction id of the transaction, in the sequence of the input transactions
      */
     sendTransactions(data: {
         developer: string;
@@ -125,15 +138,13 @@ export declare class zkCloudWorkerClient {
         result?: any;
     }>;
     /**
-     * Gets the result of the job using serverless api call
+     * Deploys the code to the cloud using serverless api call
      * @param data the data for the deploy call
-     * @param data.packageName the name of the zip file with the code to be deployed
-     * @returns { success: boolean, error?: string, result?: any }
-     * where result is the result of the job
-     * if the job is not finished yet, the result will be undefined
-     * if the job failed, the result will be undefined and error will be set
-     * if the job is finished, the result will be set and error will be undefined
-     * if the job is not found, the result will be undefined and error will be set
+     * @param data.repo the repo to use
+     * @param data.developer the developer
+     * @param data.packageManager the package manager to use
+     * @returns { success: boolean, error?: string, jobId?: string}
+     * where jobId is the jobId of the job
      */
     deploy(data: {
         repo: string;
@@ -157,7 +168,7 @@ export declare class zkCloudWorkerClient {
     /**
      * Gets the remaining balance
      * @returns { success: boolean, error?: string, result?: any }
-     * where result is the billing report
+     * where result is the balance
      */
     getBalance(): Promise<{
         success: boolean;

package/lib/ts/src/api/api.js

@@ -14,11 +14,17 @@ const { ZKCLOUDWORKER_AUTH, ZKCLOUDWORKER_API } = config_1.default;
  * API class for interacting with the zkCloudWorker
  * @property jwt The jwt token for authentication, get it at https://t.me/minanft_bot?start=auth
  * @property endpoint The endpoint of the serverless api
+ * @property chain The blockchain network to use
+ * @property webhook The webhook for the serverless api to get the results
+ * @property localWorker The local worker for the serverless api to test the code locally
  */
 class zkCloudWorkerClient {
     /**
      * Constructor for the API class
      * @param jwt The jwt token for authentication, get it at https://t.me/minanft_bot?start=auth
+     * @param zkcloudworker The local worker for the serverless api to test the code locally
+     * @param chain The blockchain network to use
+     * @param webhook The webhook for the serverless api to get the results
      */
     constructor(params) {
         const { jwt, zkcloudworker, chain, webhook } = params;
@@ -34,19 +40,20 @@ class zkCloudWorkerClient {
     }
     /**
      * Starts a new job for the proof calculation using serverless api call
-     * The developer and name should correspond to the BackupPlugin of the API
-     * All other parameters should correspond to the parameters of the BackupPlugin
      * @param data the data for the proof call
-     * @param data.transactions the transactions
      * @param data.developer the developer
      * @param data.repo the repo to use
+     * @param data.transactions the transactions
      * @param data.task the task of the job
-     * @param data.args the arguments of the job
+     * @param data.userId the userId of the job
+     * @param data.args the arguments of the job, should be serialized JSON or string
+     * @param data.metadata the metadata of the job, should be serialized JSON or string
+     * @param data.webhook the webhook for the job
      * @returns { success: boolean, error?: string, jobId?: string }
      * where jonId is the jobId of the job
      *
-     * The developers repo should provide a BackupPlugin with the name task
-     * that can be called with the given parameters
+     * The developers repo should provide a zkcloudworker function
+     * that can be called with the given parameters, see the examples
      */
     async recursiveProof(data) {
         const result = await this.apiHub("recursiveProof", data);
@@ -77,8 +84,6 @@ class zkCloudWorkerClient {
     }
     /**
      * Starts a new job for the function call using serverless api call
-     * The developer and name should correspond to the BackupPlugin of the API
-     * All other parameters should correspond to the parameters of the BackupPlugin
      * @param data the data for the proof call
      * @param data.developer the developer
      * @param data.repo the repo to use
@@ -88,8 +93,8 @@ class zkCloudWorkerClient {
      * @param data.args the arguments of the job
      * @param data.metadata the metadata of the job
      * @param data.mode the mode of the job execution: "sync" will not create a job, it will execute the function synchronously within 30 seconds and with the memory limit of 256 MB
-     * @returns { success: boolean, error?: string, jobId?: string }
-     * where jonId is the jobId of the job
+     * @returns { success: boolean, error?: string, jobId?: string, result?: any }
+     * where jonId is the jobId of the job (for async calls), result is the result of the job (for sync calls)
      */
     async execute(data) {
         const result = await this.apiHub("execute", data);
@@ -130,16 +135,13 @@ class zkCloudWorkerClient {
             };
     }
     /**
-     * Starts a new job for the function call using serverless api call
-     * The developer and name should correspond to the BackupPlugin of the API
-     * All other parameters should correspond to the parameters of the BackupPlugin
+     * Sends transactions to the blockchain using serverless api call
      * @param data the data for the proof call
      * @param data.developer the developer
      * @param data.repo the repo to use
-     * @param data.task the task of the job
-     * @param data.args the arguments of the job
-     * @returns { success: boolean, error?: string, jobId?: string }
-     * where jonId is the jobId of the job
+     * @param data.transactions the transactions
+     * @returns { success: boolean, error?: string, txId?: string[] }
+     * where txId is the transaction id of the transaction, in the sequence of the input transactions
      */
     async sendTransactions(data) {
         const result = await this.apiHub("sendTransactions", data);
@@ -184,15 +186,13 @@ class zkCloudWorkerClient {
             };
     }
     /**
-     * Gets the result of the job using serverless api call
+     * Deploys the code to the cloud using serverless api call
      * @param data the data for the deploy call
-     * @param data.packageName the name of the zip file with the code to be deployed
-     * @returns { success: boolean, error?: string, result?: any }
-     * where result is the result of the job
-     * if the job is not finished yet, the result will be undefined
-     * if the job failed, the result will be undefined and error will be set
-     * if the job is finished, the result will be set and error will be undefined
-     * if the job is not found, the result will be undefined and error will be set
+     * @param data.repo the repo to use
+     * @param data.developer the developer
+     * @param data.packageManager the package manager to use
+     * @returns { success: boolean, error?: string, jobId?: string}
+     * where jobId is the jobId of the job
      */
     async deploy(data) {
         // TODO: encrypt env.json
@@ -238,7 +238,7 @@ class zkCloudWorkerClient {
     /**
      * Gets the remaining balance
      * @returns { success: boolean, error?: string, result?: any }
-     * where result is the billing report
+     * where result is the balance
      */
     async getBalance() {
         const result = await this.apiHub("getBalance", {});
@@ -370,7 +370,7 @@ class zkCloudWorkerClient {
                     });
                     return {
                         success: true,
-                        data: jobId,
+                        data: { success: true, jobId },
                     };
                 }
                 case "execute": {

package/lib/ts/src/cloud/cloud.d.ts

@@ -1,6 +1,17 @@
 /// <reference types="node" />
 import { blockchain } from "../networks";
 import { JobData } from "./job";
+/**
+ * Interface for the deployed smart contract
+ * Used to get verification keys and addresses of the deployed smart contracts
+ * to be published in the blockchain explorer
+ * @param address: the address of the deployed smart contract
+ * @param name: the name of the deployed smart contract
+ * @param chain: the blockchain network where the smart contract is deployed
+ * @param verificationKey: the verification key of the deployed smart contract
+ * @param verificationKey.hash: the hash of the verification key
+ * @param verificationKey.data: the data of the verification key
+ */
 export interface DeployedSmartContract {
     address: string;
     name: string;
@@ -10,10 +21,24 @@ export interface DeployedSmartContract {
         data: string;
     };
 }
+/**
+ * Interface for the deployer key pair
+ * Used to get the public and private keys of the deployer for test networks only
+ * Devnet and Zeko are supported
+ * @param publicKey: the public key of the deployer
+ * @param privateKey: the private key of the deployer
+ */
 export interface DeployerKeyPair {
     publicKey: string;
     privateKey: string;
 }
+/**
+ * Interface for the cloud transaction
+ * Used to get the transaction id, the transaction, and the time received
+ * @param txId: the transaction id
+ * @param transaction: the transaction
+ * @param timeReceived: the time received
+ */
 export interface CloudTransaction {
     txId: string;
     transaction: string;
@@ -33,6 +58,22 @@ export declare abstract class Cloud {
     readonly metadata?: string;
     readonly chain: blockchain;
     readonly isLocalCloud: boolean;
+    /**
+     * Constructor for the Cloud class
+     * @param id: the id of the user
+     * @param jobId: the job id
+     * @param stepId: the step id
+     * @param taskId: the task id
+     * @param cache: the cache folder. Use it to get the Cache object: cache = Cache.FileSystem(this.cloud.cache);
+     * @param developer: the developer id
+     * @param repo: the repo id
+     * @param task: the task id
+     * @param userId: the user id
+     * @param args: the arguments, should be a string or serialized JSON
+     * @param metadata: the metadata, should be a string or serialized JSON
+     * @param chain: the blockchain network
+     * @param isLocalCloud: a boolean to check if the cloud is local or not
+     */
     constructor(params: {
         id: string;
         jobId: string;
@@ -48,16 +89,69 @@ export declare abstract class Cloud {
         isLocalCloud?: boolean;
         chain: blockchain;
     });
+    /**
+     * Abstract method to get the deployer key pair
+     * Used to get the public and private keys of the deployer for test networks only
+     * Devnet and Zeko are supported
+     * @returns the deployer key pair
+     */
     abstract getDeployer(): Promise<DeployerKeyPair | undefined>;
+    /**
+     * Abstract method to release the deployer
+     * @param params: the public key of the deployer and the transactions hashes
+     * Used to release the deployer after the transactions are sent to the blockchain
+     * @param publicKey: the public key of the deployer
+     * @param txsHashes: the transactions hashes
+     */
     abstract releaseDeployer(params: {
         publicKey: string;
         txsHashes: string[];
     }): Promise<void>;
+    /**
+     * Abstract method to get the data by key
+     * Used to get the data by key from the cloud storage
+     * @param key: the key
+     * @returns the value of the key
+     */
     abstract getDataByKey(key: string): Promise<string | undefined>;
+    /**
+     * Abstract method to save the data by key
+     * Used to save the data by key to the cloud storage
+     * @param key: the key
+     * @param value: the value
+     */
     abstract saveDataByKey(key: string, value: string | undefined): Promise<void>;
+    /**
+     * Abstract method to save the file
+     * Used to save the file to the cloud storage
+     * @param filename: the filename
+     * @param value: the value
+     */
     abstract saveFile(filename: string, value: Buffer): Promise<void>;
+    /**
+     * Abstract method to load the file
+     * Used to load the file from the cloud storage
+     * @param filename: the filename
+     * @returns the value of the file
+     */
     abstract loadFile(filename: string): Promise<Buffer | undefined>;
+    /**
+     * Abstract method to load the environment
+     * Used to load the environment from the cloud storage
+     * @param password: the password
+     */
     abstract loadEnvironment(password: string): Promise<void>;
+    /**
+     * Abstract method to calculate the recursive proof
+     * Used to calculate the recursive proof
+     * @param data: the data
+     * @param data.transactions: the transactions
+     * @param data.task: the task
+     * @param data.userId: the user id
+     * @param data.args: the arguments
+     * @param data.metadata: the metadata
+     * @returns the proof
+     */
     abstract recursiveProof(data: {
         transactions: string[];
         task?: string;
@@ -65,6 +159,17 @@ export declare abstract class Cloud {
         args?: string;
         metadata?: string;
     }): Promise<string>;
+    /**
+     * Abstract method to execute the transactions
+     * Used to execute the transactions
+     * @param data: the data
+     * @param data.transactions: the transactions
+     * @param data.task: the task
+     * @param data.userId: the user id
+     * @param data.args: the arguments
+     * @param data.metadata: the metadata
+     * @returns the result
+     */
     abstract execute(data: {
         transactions: string[];
         task: string;
@@ -72,6 +177,18 @@ export declare abstract class Cloud {
         args?: string;
         metadata?: string;
     }): Promise<string>;
+    /**
+     * Abstract method to add the task
+     * Used to add the task
+     * @param data: the data
+     * @param data.task: the task
+     * @param data.startTime: the start time
+     * @param data.userId: the user id
+     * @param data.args: the arguments
+     * @param data.metadata: the metadata
+     * @param data.maxAttempts: the maximum attempts
+     * @returns the task id
+     */
     abstract addTask(data: {
         task: string;
         startTime?: number;
@@ -80,19 +197,77 @@ export declare abstract class Cloud {
         metadata?: string;
         maxAttempts?: number;
     }): Promise<string>;
+    /**
+     * Abstract method to delete the transaction
+     * Used to delete the transaction
+     * @param txId: the transaction id
+     */
     abstract deleteTransaction(txId: string): Promise<void>;
+    /**
+     * Abstract method to get the transactions
+     * Used to get the transactions
+     * @returns the transactions
+     */
     abstract getTransactions(): Promise<CloudTransaction[]>;
+    /**
+     * Abstract method to delete the task
+     * Used to delete the task
+     * @param taskId: the task id
+     */
     abstract deleteTask(taskId: string): Promise<void>;
+    /**
+     * Abstract method to process the tasks
+     */
     abstract processTasks(): Promise<void>;
+    /**
+     * Abstract method to get the job result
+     * Used to get the job result
+     * @param jobId: the job id
+     * @returns the job result
+     */
     abstract jobResult(jobId: string): Promise<JobData | undefined>;
 }
+/**
+ * Abstract class for the zkCloudWorker
+ * Used to define the zkCloudWorker methods and properties
+ * Should be implemented for by the developer for the zkCloudWorker in the cloud
+ * @param cloud: the cloud
+ */
 export declare abstract class zkCloudWorker {
     readonly cloud: Cloud;
+    /**
+     * Constructor for the zkCloudWorker class
+     * @param cloud: the cloud instance provided by the zkCloudWorker in the local environment or in the cloud
+     */
     constructor(cloud: Cloud);
+    /**
+     * Returns the deployed smart contracts for verification in the blockchain explorer
+     * @returns the deployed smart contracts
+     */
     deployedContracts(): Promise<DeployedSmartContract[]>;
+    /**
+     * Creates a new proof from a transaction
+     * @param transaction: the transaction
+     * @returns the serialized proof
+     */
     create(transaction: string): Promise<string | undefined>;
+    /**
+     * Merges two proofs
+     * @param proof1: the first proof
+     * @param proof2: the second proof
+     * @returns the merged proof
+     */
     merge(proof1: string, proof2: string): Promise<string | undefined>;
+    /**
+     * Executes the transactions
+     * @param transactions: the transactions, can be empty list
+     * @returns the result
+     */
     execute(transactions: string[]): Promise<string | undefined>;
     processTransactions(transactions: CloudTransaction[]): Promise<void>;
+    /**
+     * process the task defined by the developer
+     * @returns the result
+     */
     task(): Promise<string | undefined>;
 }

package/lib/ts/src/cloud/cloud.js

@@ -1,7 +1,41 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.zkCloudWorker = exports.Cloud = void 0;
+/*
+ * Abstract class for the cloud
+ * Used to define the cloud methods and properties
+ * Should be implemented by for local testing and for the zkCloudWorker in the cloud
+ * @param id: the id of the user
+ * @param jobId: the job id
+ * @param stepId: the step id
+ * @param taskId: the task id
+ * @param cache: the cache folder. Use it to get the Cache object: cache = Cache.FileSystem(this.cloud.cache);
+ * @param developer: the developer id
+ * @param repo: the repo id
+ * @param task: the task id
+ * @param userId: the user id
+ * @param args: the arguments, should be a string or serialized JSON
+ * @param metadata: the metadata, should be a string or serialized JSON
+ * @param chain: the blockchain network
+ * @param isLocalCloud: a boolean to check if the cloud is local or not
+ */
 class Cloud {
+    /**
+     * Constructor for the Cloud class
+     * @param id: the id of the user
+     * @param jobId: the job id
+     * @param stepId: the step id
+     * @param taskId: the task id
+     * @param cache: the cache folder. Use it to get the Cache object: cache = Cache.FileSystem(this.cloud.cache);
+     * @param developer: the developer id
+     * @param repo: the repo id
+     * @param task: the task id
+     * @param userId: the user id
+     * @param args: the arguments, should be a string or serialized JSON
+     * @param metadata: the metadata, should be a string or serialized JSON
+     * @param chain: the blockchain network
+     * @param isLocalCloud: a boolean to check if the cloud is local or not
+     */
     constructor(params) {
         const { id, jobId, stepId, taskId, cache, developer, repo, task, userId, args, metadata, isLocalCloud, chain, } = params;
         this.id = id;
@@ -20,28 +54,62 @@ class Cloud {
     }
 }
 exports.Cloud = Cloud;
+/**
+ * Abstract class for the zkCloudWorker
+ * Used to define the zkCloudWorker methods and properties
+ * Should be implemented for by the developer for the zkCloudWorker in the cloud
+ * @param cloud: the cloud
+ */
 class zkCloudWorker {
+    /**
+     * Constructor for the zkCloudWorker class
+     * @param cloud: the cloud instance provided by the zkCloudWorker in the local environment or in the cloud
+     */
     constructor(cloud) {
         this.cloud = cloud;
     }
-    // To verify the SmartContract code
+    /**
+     * Returns the deployed smart contracts for verification in the blockchain explorer
+     * @returns the deployed smart contracts
+     */
     async deployedContracts() {
         return [];
     }
     // Those methods should be implemented for recursive proofs calculations
+    /**
+     * Creates a new proof from a transaction
+     * @param transaction: the transaction
+     * @returns the serialized proof
+     */
     async create(transaction) {
         return undefined;
     }
+    /**
+     * Merges two proofs
+     * @param proof1: the first proof
+     * @param proof2: the second proof
+     * @returns the merged proof
+     */
     async merge(proof1, proof2) {
         return undefined;
     }
     // Those methods should be implemented for anything except for recursive proofs
+    /**
+     * Executes the transactions
+     * @param transactions: the transactions, can be empty list
+     * @returns the result
+     */
     async execute(transactions) {
         return undefined;
     }
-    // process the transactions received by the cloud
+    /* Process the transactions received by the cloud
+     * @param transactions: the transactions
+     */
     async processTransactions(transactions) { }
-    // process the task defined by the developer
+    /**
+     * process the task defined by the developer
+     * @returns the result
+     */
     async task() {
         return undefined;
     }

package/lib/ts/src/cloud/job.d.ts

@@ -1,10 +1,57 @@
 import { blockchain } from "../networks";
 export type JobStatus = "created" | "started" | "finished" | "failed" | "used";
+/**
+ * LogStream is a subset of the log stream data returned by AWS CloudWatch Logs when running the worker
+ * https://docs.aws.amazon.com/AWSJavaScriptSDK/v3/latest/client/cloudwatch-logs/command/GetLogEventsCommand/
+ * example:
+ * {
+ * logGroupName: '/aws/lambda/zkcloudworker-dev-test',
+ * logStreamName: '2024/05/09/[$LATEST]52d048f64e894d2e8ba2800df93629c5'
+ * awsRequestId: '581d0d45-9165-47e8-84d9-678599938811',
+ * }
+ * @param logGroupName the log group name
+ * @param logStreamName the log stream name
+ * @param awsRequestId the AWS request ID
+ */
 export interface LogStream {
     logGroupName: string;
     logStreamName: string;
     awsRequestId: string;
 }
+/**
+ * JobData is the data structure for a job, keeping track of the job status, result, logs, and metadata
+ * @param id the id of the user
+ * @param jobId the id of the job
+ * @param taskId the id of the task
+ * @param developer the developer of the repo executing the job
+ * @param repo the repo executing the job
+ * @param task the task to execute
+ * @param userId the id of the user
+ * @param args the arguments for the job
+ * @param metadata the metadata for the job
+ * @param chain the blockchain to execute the job on
+ * @param webhook the webhook to call after the job finishes
+ * @param cloudhook the cloudhook to call after the job finishes
+ * @param cloudIteration the recursive call number, must be less than 5
+ * @param previousJob the previous job data, provided in case of the cloudhook
+ *
+ * @param filename the filename where transactions data is stored
+ * @param txNumber the number of transactions
+ * @param timeCreated the time the job was created
+ * @param timeCreatedString the time the job was created as a string
+ * @param timeStarted the time the job was started
+ * @param timeFinished the time the job was finished
+ * @param timeFailed the time the job failed
+ * @param timeUsed the time the job result was used
+ * @param billedDuration the duration the job was billed for
+ * @param feeMINA the fee in MINA
+ * @param feeUSD the fee in USD
+ * @param jobStatus the status of the job
+ * @param maxAttempts the maximum number of attempts
+ * @param result the result of the job
+ * @param logStreams the log streams of the job
+ * @param logs the logs of the job
+ */
 export interface JobData {
     id: string;
     jobId: string;