@human-protocol/sdk 1.0.0 → 1.0.1

package/README.md

@@ -0,0 +1,9 @@
+# Human Protocol Node.js SDK
+
+Node.js SDK to launch/manage jobs on [Human Protocol](https://www.humanprotocol.org/)
+
+## Installation
+
+This SDK is available on [NPM](https://www.npmjs.com/package/@human-protocol/sdk).
+
+    yarn @human-protocol/sdk

package/example/simple-existing-job.ts

@@ -0,0 +1,86 @@
+/* eslint-disable no-console */
+import { Job } from '../src';
+import {
+  DEFAULT_GAS_PAYER_PRIVKEY,
+  DEFAULT_HMTOKEN_ADDR,
+  REPUTATION_ORACLE_PRIVKEY,
+  WORKER1_ADDR,
+  WORKER2_ADDR,
+} from '../test/utils/constants';
+import { manifest } from '../test/utils/manifest';
+import * as dotenv from 'dotenv';
+
+dotenv.config();
+
+const main = async () => {
+  // Create job object
+  const newJob = new Job({
+    gasPayer: DEFAULT_GAS_PAYER_PRIVKEY,
+    reputationOracle: REPUTATION_ORACLE_PRIVKEY,
+    manifest: manifest,
+    hmTokenAddr: DEFAULT_HMTOKEN_ADDR,
+    logLevel: 'debug',
+  });
+
+  // Initialize new job object
+  await newJob.initialize();
+
+  // Launch the job
+  await newJob.launch();
+
+  // Access the existing job
+  const job = new Job({
+    gasPayer: DEFAULT_GAS_PAYER_PRIVKEY,
+    reputationOracle: REPUTATION_ORACLE_PRIVKEY,
+    manifest: manifest,
+    hmTokenAddr: DEFAULT_HMTOKEN_ADDR,
+    factoryAddr: newJob.contractData?.factoryAddr,
+    escrowAddr: newJob.contractData?.escrowAddr,
+    storageAccessKeyId: process.env.AWS_ACCESS_KEY_ID,
+    storageSecretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+    storageEndpoint: process.env.AWS_ENDPOINT,
+    storageBucket: process.env.AWS_BUCKET,
+    storagePublicBucket: process.env.AWS_PUBLIC_BUCKET,
+    logLevel: 'debug',
+  });
+
+  // Initialize the job object
+  await job.initialize();
+
+  // Setup the job
+  await job.setup();
+
+  console.log(
+    `Status: ${await job.status()}, Balance: ${(
+      await job.balance()
+    )?.toString()}`
+  );
+
+  // Bulk payout workers
+  await job.bulkPayout(
+    [
+      {
+        address: WORKER1_ADDR,
+        amount: 70,
+      },
+      {
+        address: WORKER2_ADDR,
+        amount: 30,
+      },
+    ],
+    {
+      result: 'result',
+    }
+  );
+
+  // Complete the job
+  await job.complete();
+
+  console.log(
+    `Status: ${await job.status()}, Balance: ${(
+      await job.balance()
+    )?.toString()}`
+  );
+};
+
+main();

package/example/simple-new-job-public.ts

@@ -0,0 +1,74 @@
+/* eslint-disable no-console */
+import { Job } from '../src';
+import {
+  DEFAULT_GAS_PAYER_PRIVKEY,
+  DEFAULT_HMTOKEN_ADDR,
+  REPUTATION_ORACLE_PRIVKEY,
+  WORKER1_ADDR,
+  WORKER2_ADDR,
+} from '../test/utils/constants';
+import { manifest } from '../test/utils/manifest';
+import * as dotenv from 'dotenv';
+
+dotenv.config();
+
+const main = async () => {
+  // Create job object
+  const job = new Job({
+    gasPayer: DEFAULT_GAS_PAYER_PRIVKEY,
+    reputationOracle: REPUTATION_ORACLE_PRIVKEY,
+    manifest: manifest,
+    hmTokenAddr: DEFAULT_HMTOKEN_ADDR,
+    storageAccessKeyId: process.env.AWS_ACCESS_KEY_ID,
+    storageSecretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+    storageEndpoint: process.env.AWS_ENDPOINT,
+    storageBucket: process.env.AWS_BUCKET,
+    storagePublicBucket: process.env.AWS_PUBLIC_BUCKET,
+    logLevel: 'debug',
+  });
+
+  // Initialize new job
+  await job.initialize();
+
+  // Launch the job
+  await job.launch();
+
+  // Setup the job
+  await job.setup();
+
+  console.log(
+    `Status: ${await job.status()}, Balance: ${(
+      await job.balance()
+    )?.toString()}`
+  );
+
+  // Bulk payout workers
+  await job.bulkPayout(
+    [
+      {
+        address: WORKER1_ADDR,
+        amount: 70,
+      },
+      {
+        address: WORKER2_ADDR,
+        amount: 30,
+      },
+    ],
+    {
+      result: 'result',
+    },
+    false,
+    true
+  );
+
+  // Complete the job
+  await job.complete();
+
+  console.log(
+    `Status: ${await job.status()}, Balance: ${(
+      await job.balance()
+    )?.toString()}`
+  );
+};
+
+main();

package/example/simple-new-job.ts

@@ -0,0 +1,72 @@
+/* eslint-disable no-console */
+import { Job } from '../src';
+import {
+  DEFAULT_GAS_PAYER_PRIVKEY,
+  DEFAULT_HMTOKEN_ADDR,
+  REPUTATION_ORACLE_PRIVKEY,
+  WORKER1_ADDR,
+  WORKER2_ADDR,
+} from '../test/utils/constants';
+import { manifest } from '../test/utils/manifest';
+import * as dotenv from 'dotenv';
+
+dotenv.config();
+
+const main = async () => {
+  // Create job object
+  const job = new Job({
+    gasPayer: DEFAULT_GAS_PAYER_PRIVKEY,
+    reputationOracle: REPUTATION_ORACLE_PRIVKEY,
+    manifest: manifest,
+    hmTokenAddr: DEFAULT_HMTOKEN_ADDR,
+    storageAccessKeyId: process.env.AWS_ACCESS_KEY_ID,
+    storageSecretAccessKey: process.env.AWS_SECRET_ACCESS_KEY,
+    storageEndpoint: process.env.AWS_ENDPOINT,
+    storageBucket: process.env.AWS_BUCKET,
+    storagePublicBucket: process.env.AWS_PUBLIC_BUCKET,
+    logLevel: 'debug',
+  });
+
+  // Initialize new job
+  await job.initialize();
+
+  // Launch the job
+  await job.launch();
+
+  // Setup the job
+  await job.setup();
+
+  console.log(
+    `Status: ${await job.status()}, Balance: ${(
+      await job.balance()
+    )?.toString()}`
+  );
+
+  // Bulk payout workers
+  await job.bulkPayout(
+    [
+      {
+        address: WORKER1_ADDR,
+        amount: 70,
+      },
+      {
+        address: WORKER2_ADDR,
+        amount: 30,
+      },
+    ],
+    {
+      result: 'result',
+    }
+  );
+
+  // Complete the job
+  await job.complete();
+
+  console.log(
+    `Status: ${await job.status()}, Balance: ${(
+      await job.balance()
+    )?.toString()}`
+  );
+};
+
+main();

package/package.json

@@ -1,10 +1,12 @@
 {
   "name": "@human-protocol/sdk",
   "description": "Human Protocol SDK",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "files": [
     "src",
-    "dist"
+    "dist",
+    "example",
+    "test"
   ],
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -36,12 +38,15 @@
     ]
   },
   "dependencies": {
-    "@human-protocol/core": "workspace:*",
+    "@human-protocol/core": "^1.0.9",
     "aws-sdk": "^2.1255.0",
     "crypto": "^1.0.1",
     "dotenv": "^16.0.3",
     "ethers": "^5.7.2",
     "secp256k1": "^4.0.3",
     "winston": "^3.8.2"
+  },
+  "peerDependencies": {
+    "@human-protocol/core": "^1.0.9"
   }
 }

package/src/job.ts

@@ -142,8 +142,8 @@ export class Job {
       accessKeyId: storageAccessKeyId || '',
       secretAccessKey: storageSecretAccessKey || '',
       endpoint: storageEndpoint,
-      publicBucket: storagePublicBucket || DEFAULT_BUCKET,
-      bucket: storageBucket || DEFAULT_PUBLIC_BUCKET,
+      publicBucket: storagePublicBucket || DEFAULT_PUBLIC_BUCKET,
+      bucket: storageBucket || DEFAULT_BUCKET,
     };
 
     this._logger = createLogger(logLevel);
@@ -204,6 +204,8 @@ export class Job {
 
       if (!hasEscrow) {
         this._logError(new Error('Factory does not contain the escrow'));
+        this.contractData.factory = undefined;
+
         return false;
       }
 
@@ -214,17 +216,34 @@ export class Job {
       );
       this._logger.info('Accessed the escrow successfully.');
 
-      this.manifestData = {
-        ...this.manifestData,
-        manifestlink: {
-          url: await this.contractData?.escrow.manifestUrl(),
-          hash: await this.contractData?.escrow.manifestHash(),
-        },
-      };
+      const manifestUrl = await this.contractData?.escrow.manifestUrl();
+      const manifestHash = await this.contractData?.escrow.manifestHash();
+
+      if (
+        (!manifestUrl.length || !manifestHash.length) &&
+        !this.manifestData?.manifest
+      ) {
+        this._logError(ErrorManifestMissing);
+
+        this.contractData.factory = undefined;
+        this.contractData.escrow = undefined;
+
+        return false;
+      }
 
-      this.manifestData.manifest = (await this._download(
-        this.manifestData.manifestlink?.url
-      )) as Manifest;
+      if (manifestUrl.length && manifestHash.length) {
+        this.manifestData = {
+          ...this.manifestData,
+          manifestlink: {
+            url: manifestUrl,
+            hash: manifestHash,
+          },
+        };
+
+        this.manifestData.manifest = (await this._download(
+          manifestUrl
+        )) as Manifest;
+      }
     }
 
     return true;
@@ -238,18 +257,13 @@ export class Job {
    * @returns {Promise<boolean>} - True if the escrow is launched successfully.
    */
   async launch(): Promise<boolean> {
-    if (!this.contractData || this.contractData.escrow) {
-      this._logError(ErrorJobAlreadyLaunched);
-      return false;
-    }
-
     if (!this.contractData || !this.contractData.factory) {
       this._logError(ErrorJobNotInitialized);
       return false;
     }
 
-    if (!this.manifestData || !this.manifestData.manifest) {
-      this._logError(ErrorManifestMissing);
+    if (!this.contractData || this.contractData.escrow) {
+      this._logError(ErrorJobAlreadyLaunched);
       return false;
     }
 
@@ -281,21 +295,6 @@ export class Job {
       this.providerData?.gasPayer
     );
 
-    this._logger.info('Uploading manifest...');
-    const uploadResult = await this._upload(this.manifestData.manifest);
-    if (!uploadResult) {
-      this._logError(new Error('Error uploading manifest'));
-      return false;
-    }
-
-    this.manifestData.manifestlink = {
-      url: uploadResult.key,
-      hash: uploadResult.hash,
-    };
-    this._logger.info(
-      `Uploaded manifest.\n\tKey: ${uploadResult.key}\n\tHash: ${uploadResult.hash}`
-    );
-
     return (
       (await this.status()) == EscrowStatus.Launched &&
       (await this.balance())?.toNumber() === 0
@@ -316,6 +315,16 @@ export class Job {
       return false;
     }
 
+    if (!this.manifestData || !this.manifestData.manifest) {
+      this._logError(ErrorManifestMissing);
+      return false;
+    }
+
+    if (this.manifestData.manifestlink) {
+      this._logError(new Error('Job is already setup'));
+      return false;
+    }
+
     if (!this.contractData.hmToken) {
       this._logError(ErrorHMTokenMissing);
       return false;
@@ -358,6 +367,21 @@ export class Job {
     }
     this._logger.info('HMT transferred.');
 
+    this._logger.info('Uploading manifest...');
+    const uploadResult = await this._upload(this.manifestData.manifest);
+    if (!uploadResult) {
+      this._logError(new Error('Error uploading manifest'));
+      return false;
+    }
+
+    this.manifestData.manifestlink = {
+      url: uploadResult.key,
+      hash: uploadResult.hash,
+    };
+    this._logger.info(
+      `Uploaded manifest.\n\tKey: ${uploadResult.key}\n\tHash: ${uploadResult.hash}`
+    );
+
     this._logger.info('Setting up the escrow...');
     const contractSetup = await this._raffleExecute(
       this.contractData.escrow,

package/src/storage.ts

@@ -128,7 +128,7 @@ export const upload = async (
     Body: content,
   };
 
-  await s3.putObject(params);
+  await s3.putObject(params).promise();
 
   return { key, hash };
 };

package/test/job.test.ts

@@ -0,0 +1,753 @@
+import { getPublicURL } from './../src/storage';
+import { EscrowStatus, Job } from '../src';
+import { upload } from '../src/storage';
+import { toFullDigit } from '../src/utils';
+import {
+  DEFAULT_GAS_PAYER_ADDR,
+  DEFAULT_GAS_PAYER_PRIVKEY,
+  DEFAULT_HMTOKEN_ADDR,
+  NOT_TRUSTED_OPERATOR_PRIVKEY,
+  REPUTATION_ORACLE_PRIVKEY,
+  TRUSTED_OPERATOR1_ADDR,
+  TRUSTED_OPERATOR1_PRIVKEY,
+  TRUSTED_OPERATOR2_ADDR,
+  WORKER1_ADDR,
+  WORKER2_ADDR,
+  WORKER3_ADDR,
+} from './utils/constants';
+import { manifest } from './utils/manifest';
+
+jest.mock('../src/storage', () => ({
+  ...jest.requireActual('../src/storage'),
+  upload: jest.fn().mockResolvedValue({
+    key: 'uploaded-key',
+    hash: 'uploaded-hash',
+  }),
+  download: jest.fn().mockResolvedValue({
+    results: 0,
+  }),
+  getPublicURL: jest.fn().mockResolvedValue('public-url'),
+}));
+
+describe('Test Job', () => {
+  describe('New job', () => {
+    let job: Job;
+
+    beforeEach(() => {
+      job = new Job({
+        gasPayer: DEFAULT_GAS_PAYER_PRIVKEY,
+        reputationOracle: REPUTATION_ORACLE_PRIVKEY,
+        manifest: manifest,
+        hmTokenAddr: DEFAULT_HMTOKEN_ADDR,
+        logLevel: 'debug',
+      });
+    });
+
+    afterEach(() => {
+      jest.clearAllMocks();
+    });
+
+    it('Should be able to initializes the job by deploying escrow factory', async () => {
+      const initialized = await job.initialize();
+      expect(initialized).toBe(true);
+
+      expect(await job.contractData?.factory?.address).not.toBeNull();
+    });
+
+    it('Should be able to launch the job', async () => {
+      // Fail to launch the job before initialization
+      expect(await job.launch()).toBe(false);
+
+      await job.initialize();
+
+      expect(await job.launch()).toBe(true);
+      expect(await job.status()).toBe(EscrowStatus.Launched);
+    });
+
+    it('Should be able to setup the job', async () => {
+      // Fail to setup the job before launch
+      expect(await job.setup()).toBe(false);
+
+      await job.initialize();
+      await job.launch();
+
+      expect(await job.setup()).toBe(true);
+    });
+
+    it('Should be able to add trusted handlers', async () => {
+      await job.initialize();
+      await job.launch();
+
+      expect(await job.isTrustedHandler(DEFAULT_GAS_PAYER_ADDR)).toBe(true);
+
+      expect(
+        await job.addTrustedHandlers([
+          TRUSTED_OPERATOR1_ADDR,
+          TRUSTED_OPERATOR2_ADDR,
+        ])
+      ).toBe(true);
+
+      expect(await job.isTrustedHandler(TRUSTED_OPERATOR1_ADDR)).toBe(true);
+      expect(await job.isTrustedHandler(TRUSTED_OPERATOR2_ADDR)).toBe(true);
+    });
+
+    it('Should be able to bulk payout workers', async () => {
+      await job.initialize();
+      await job.launch();
+      await job.setup();
+
+      expect(
+        await job.bulkPayout(
+          [
+            {
+              address: WORKER1_ADDR,
+              amount: 20,
+            },
+            {
+              address: WORKER2_ADDR,
+              amount: 50,
+            },
+          ],
+          {}
+        )
+      ).toBe(true);
+
+      // The escrow contract is still in Partial state as there's still balance left.
+      expect((await job.balance())?.toString()).toBe(
+        toFullDigit(30).toString()
+      );
+      expect(await job.status()).toBe(EscrowStatus.Partial);
+
+      // Trying to pay more than the contract balance results in failure.
+      expect(
+        await job.bulkPayout(
+          [
+            {
+              address: WORKER3_ADDR,
+              amount: 50,
+            },
+          ],
+          {}
+        )
+      ).toBe(false);
+
+      // Paying the remaining amount empties the escrow and updates the status correctly.
+      expect(
+        await job.bulkPayout(
+          [
+            {
+              address: WORKER3_ADDR,
+              amount: 30,
+            },
+          ],
+          {}
+        )
+      ).toBe(true);
+      expect((await job.balance())?.toString()).toBe(toFullDigit(0).toString());
+      expect(await job.status()).toBe(EscrowStatus.Paid);
+    });
+
+    it('Should encrypt result, when bulk paying out workers', async () => {
+      await job.initialize();
+      await job.launch();
+      await job.setup();
+
+      jest.clearAllMocks();
+      const finalResults = { results: 0 };
+      await job.bulkPayout(
+        [
+          {
+            address: WORKER1_ADDR,
+            amount: 100,
+          },
+        ],
+        finalResults,
+        true
+      );
+
+      expect(upload).toHaveBeenCalledWith(
+        job.storageAccessData,
+        finalResults,
+        job.providerData?.reputationOracle?.publicKey,
+        true,
+        false
+      );
+      expect(upload).toHaveBeenCalledTimes(1);
+    });
+
+    it('Should not encrypt result, when bulk paying out workers', async () => {
+      await job.initialize();
+      await job.launch();
+      await job.setup();
+
+      jest.clearAllMocks();
+      const finalResults = { results: 0 };
+      await job.bulkPayout(
+        [
+          {
+            address: WORKER1_ADDR,
+            amount: 100,
+          },
+        ],
+        finalResults,
+        false
+      );
+
+      expect(upload).toHaveBeenCalledWith(
+        job.storageAccessData,
+        finalResults,
+        job.providerData?.reputationOracle?.publicKey,
+        false,
+        false
+      );
+      expect(upload).toHaveBeenCalledTimes(1);
+    });
+
+    it('Should store result in private storage, when bulk paying out workers', async () => {
+      await job.initialize();
+      await job.launch();
+      await job.setup();
+
+      jest.clearAllMocks();
+      const finalResults = { results: 0 };
+      await job.bulkPayout(
+        [
+          {
+            address: WORKER1_ADDR,
+            amount: 100,
+          },
+        ],
+        finalResults,
+        false,
+        false
+      );
+
+      expect(upload).toHaveBeenCalledWith(
+        job.storageAccessData,
+        finalResults,
+        job.providerData?.reputationOracle?.publicKey,
+        false,
+        false
+      );
+      expect(upload).toHaveBeenCalledTimes(1);
+    });
+
+    it('Should store result in public storage, when bulk paying out workers', async () => {
+      await job.initialize();
+      await job.launch();
+      await job.setup();
+
+      jest.clearAllMocks();
+      const finalResults = { results: 0 };
+      await job.bulkPayout(
+        [
+          {
+            address: WORKER1_ADDR,
+            amount: 50,
+          },
+        ],
+        finalResults,
+        false,
+        true
+      );
+
+      expect(upload).toHaveBeenCalledWith(
+        job.storageAccessData,
+        finalResults,
+        job.providerData?.reputationOracle?.publicKey,
+        false,
+        true
+      );
+      expect(upload).toHaveBeenCalledTimes(1);
+      expect(getPublicURL).toHaveBeenCalledTimes(1);
+    });
+
+    it('Should return final result', async () => {
+      await job.initialize();
+      await job.launch();
+      await job.setup();
+
+      const finalResults = { results: 0 };
+      await job.bulkPayout(
+        [
+          {
+            address: WORKER1_ADDR,
+            amount: 100,
+          },
+        ],
+        finalResults,
+        true
+      );
+
+      expect(JSON.stringify(await job.finalResults())).toBe(
+        JSON.stringify(finalResults)
+      );
+    });
+
+    it('Should be able to abort the job', async () => {
+      await job.initialize();
+      await job.launch();
+      await job.setup();
+
+      expect(await job.abort()).toBe(true);
+    });
+
+    it('Should be able to abort partially paid job', async () => {
+      await job.initialize();
+      await job.launch();
+      await job.setup();
+
+      const finalResults = { results: 0 };
+      await job.bulkPayout(
+        [
+          {
+            address: WORKER1_ADDR,
+            amount: 50,
+          },
+        ],
+        finalResults,
+        true
+      );
+
+      expect(await job.abort()).toBe(true);
+    });
+
+    it('Should not be able to abort fully paid job', async () => {
+      await job.initialize();
+      await job.launch();
+      await job.setup();
+
+      const finalResults = { results: 0 };
+      await job.bulkPayout(
+        [
+          {
+            address: WORKER1_ADDR,
+            amount: 100,
+          },
+        ],
+        finalResults,
+        true
+      );
+
+      expect(await job.abort()).toBe(false);
+    });
+
+    it('Should be able to cancel the job', async () => {
+      await job.initialize();
+      await job.launch();
+      await job.setup();
+
+      expect(await job.cancel()).toBe(true);
+      expect((await job.balance())?.toString()).toBe(toFullDigit(0).toString());
+    });
+
+    it('Should be able to cancel partially paid job', async () => {
+      await job.initialize();
+      await job.launch();
+      await job.setup();
+
+      const finalResults = { results: 0 };
+      await job.bulkPayout(
+        [
+          {
+            address: WORKER1_ADDR,
+            amount: 50,
+          },
+        ],
+        finalResults,
+        true
+      );
+
+      expect(await job.cancel()).toBe(true);
+      expect((await job.balance())?.toString()).toBe(toFullDigit(0).toString());
+    });
+
+    it('Should not be able to cancel paid job', async () => {
+      await job.initialize();
+      await job.launch();
+      await job.setup();
+
+      const finalResults = { results: 0 };
+      await job.bulkPayout(
+        [
+          {
+            address: WORKER1_ADDR,
+            amount: 100,
+          },
+        ],
+        finalResults,
+        true
+      );
+
+      expect(await job.cancel()).toBe(false);
+    });
+  });
+
+  describe('Access existing job from trusted handler', () => {
+    let job: Job;
+
+    beforeEach(async () => {
+      const originalJob = new Job({
+        gasPayer: DEFAULT_GAS_PAYER_PRIVKEY,
+        reputationOracle: REPUTATION_ORACLE_PRIVKEY,
+        manifest: manifest,
+        hmTokenAddr: DEFAULT_HMTOKEN_ADDR,
+        trustedHandlers: [TRUSTED_OPERATOR1_PRIVKEY],
+        logLevel: 'error',
+      });
+
+      await originalJob.initialize();
+      await originalJob.launch();
+      await originalJob.setup();
+
+      job = new Job({
+        gasPayer: NOT_TRUSTED_OPERATOR_PRIVKEY,
+        hmTokenAddr: DEFAULT_HMTOKEN_ADDR,
+        reputationOracle: REPUTATION_ORACLE_PRIVKEY,
+        escrowAddr: originalJob.contractData?.escrowAddr,
+        factoryAddr: originalJob.contractData?.factoryAddr,
+        trustedHandlers: [TRUSTED_OPERATOR1_PRIVKEY],
+        logLevel: 'debug',
+      });
+    });
+
+    afterEach(() => {
+      jest.clearAllMocks();
+    });
+
+    it('Should be able to initializes the job by accessing existing escrow', async () => {
+      const initialized = await job.initialize();
+      expect(initialized).toBe(true);
+
+      expect(await job.manifestData?.manifestlink?.url).toBe('uploaded-key');
+      expect(await job.manifestData?.manifestlink?.hash).toBe('uploaded-hash');
+    });
+
+    it('Should not be able to launch the job again', async () => {
+      await job.initialize();
+
+      expect(await job.launch()).toBe(false);
+      expect(await job.status()).toBe(EscrowStatus.Pending);
+    });
+
+    it('Should be able to setup the job again', async () => {
+      await job.initialize();
+
+      expect(await job.setup()).toBe(false);
+
+      expect((await job.balance())?.toString()).toBe(
+        toFullDigit(100).toString()
+      );
+      expect(await job.manifestData?.manifestlink?.url).toBe('uploaded-key');
+      expect(await job.manifestData?.manifestlink?.hash).toBe('uploaded-hash');
+    });
+
+    it('Should be able to add trusted handlers', async () => {
+      await job.initialize();
+      await job.launch();
+
+      expect(await job.isTrustedHandler(DEFAULT_GAS_PAYER_ADDR)).toBe(true);
+
+      expect(
+        await job.addTrustedHandlers([
+          TRUSTED_OPERATOR1_ADDR,
+          TRUSTED_OPERATOR2_ADDR,
+        ])
+      ).toBe(true);
+
+      expect(await job.isTrustedHandler(TRUSTED_OPERATOR1_ADDR)).toBe(true);
+      expect(await job.isTrustedHandler(TRUSTED_OPERATOR2_ADDR)).toBe(true);
+    });
+
+    it('Should be able to bulk payout workers', async () => {
+      await job.initialize();
+      await job.launch();
+      await job.setup();
+
+      expect(
+        await job.bulkPayout(
+          [
+            {
+              address: WORKER1_ADDR,
+              amount: 20,
+            },
+            {
+              address: WORKER2_ADDR,
+              amount: 50,
+            },
+          ],
+          {}
+        )
+      ).toBe(true);
+
+      // The escrow contract is still in Partial state as there's still balance left.
+      expect((await job.balance())?.toString()).toBe(
+        toFullDigit(30).toString()
+      );
+      expect(await job.status()).toBe(EscrowStatus.Partial);
+
+      // Trying to pay more than the contract balance results in failure.
+      expect(
+        await job.bulkPayout(
+          [
+            {
+              address: WORKER3_ADDR,
+              amount: 50,
+            },
+          ],
+          {}
+        )
+      ).toBe(false);
+
+      // Paying the remaining amount empties the escrow and updates the status correctly.
+      expect(
+        await job.bulkPayout(
+          [
+            {
+              address: WORKER3_ADDR,
+              amount: 30,
+            },
+          ],
+          {}
+        )
+      ).toBe(true);
+      expect((await job.balance())?.toString()).toBe(toFullDigit(0).toString());
+      expect(await job.status()).toBe(EscrowStatus.Paid);
+    });
+
+    it('Should encrypt result, when bulk paying out workers', async () => {
+      await job.initialize();
+      await job.launch();
+      await job.setup();
+
+      jest.clearAllMocks();
+      const finalResults = { results: 0 };
+      await job.bulkPayout(
+        [
+          {
+            address: WORKER1_ADDR,
+            amount: 100,
+          },
+        ],
+        finalResults,
+        true
+      );
+
+      expect(upload).toHaveBeenCalledWith(
+        job.storageAccessData,
+        finalResults,
+        job.providerData?.reputationOracle?.publicKey,
+        true,
+        false
+      );
+      expect(upload).toHaveBeenCalledTimes(1);
+    });
+
+    it('Should not encrypt result, when bulk paying out workers', async () => {
+      await job.initialize();
+      await job.launch();
+      await job.setup();
+
+      jest.clearAllMocks();
+      const finalResults = { results: 0 };
+      await job.bulkPayout(
+        [
+          {
+            address: WORKER1_ADDR,
+            amount: 100,
+          },
+        ],
+        finalResults,
+        false
+      );
+
+      expect(upload).toHaveBeenCalledWith(
+        job.storageAccessData,
+        finalResults,
+        job.providerData?.reputationOracle?.publicKey,
+        false,
+        false
+      );
+      expect(upload).toHaveBeenCalledTimes(1);
+    });
+
+    it('Should store result in private storage, when bulk paying out workers', async () => {
+      await job.initialize();
+      await job.launch();
+      await job.setup();
+
+      jest.clearAllMocks();
+      const finalResults = { results: 0 };
+      await job.bulkPayout(
+        [
+          {
+            address: WORKER1_ADDR,
+            amount: 100,
+          },
+        ],
+        finalResults,
+        false,
+        false
+      );
+
+      expect(upload).toHaveBeenCalledWith(
+        job.storageAccessData,
+        finalResults,
+        job.providerData?.reputationOracle?.publicKey,
+        false,
+        false
+      );
+      expect(upload).toHaveBeenCalledTimes(1);
+    });
+
+    it('Should store result in public storage, when bulk paying out workers', async () => {
+      await job.initialize();
+      await job.launch();
+      await job.setup();
+
+      jest.clearAllMocks();
+      const finalResults = { results: 0 };
+      await job.bulkPayout(
+        [
+          {
+            address: WORKER1_ADDR,
+            amount: 50,
+          },
+        ],
+        finalResults,
+        false,
+        true
+      );
+
+      expect(upload).toHaveBeenCalledWith(
+        job.storageAccessData,
+        finalResults,
+        job.providerData?.reputationOracle?.publicKey,
+        false,
+        true
+      );
+      expect(upload).toHaveBeenCalledTimes(1);
+      expect(getPublicURL).toHaveBeenCalledTimes(1);
+    });
+
+    it('Should return final result', async () => {
+      await job.initialize();
+      await job.launch();
+      await job.setup();
+
+      const finalResults = { results: 0 };
+      await job.bulkPayout(
+        [
+          {
+            address: WORKER1_ADDR,
+            amount: 100,
+          },
+        ],
+        finalResults,
+        true
+      );
+
+      expect(JSON.stringify(await job.finalResults())).toBe(
+        JSON.stringify(finalResults)
+      );
+    });
+
+    it('Should be able to abort the job', async () => {
+      await job.initialize();
+      await job.launch();
+      await job.setup();
+
+      expect(await job.abort()).toBe(true);
+    });
+
+    it('Should be able to abort partially paid job', async () => {
+      await job.initialize();
+      await job.launch();
+      await job.setup();
+
+      const finalResults = { results: 0 };
+      await job.bulkPayout(
+        [
+          {
+            address: WORKER1_ADDR,
+            amount: 50,
+          },
+        ],
+        finalResults,
+        true
+      );
+
+      expect(await job.abort()).toBe(true);
+    });
+
+    it('Should not be able to abort fully paid job', async () => {
+      await job.initialize();
+      await job.launch();
+      await job.setup();
+
+      const finalResults = { results: 0 };
+      await job.bulkPayout(
+        [
+          {
+            address: WORKER1_ADDR,
+            amount: 100,
+          },
+        ],
+        finalResults,
+        true
+      );
+
+      expect(await job.abort()).toBe(false);
+    });
+
+    it('Should be able to cancel the job', async () => {
+      await job.initialize();
+      await job.launch();
+      await job.setup();
+
+      expect(await job.cancel()).toBe(true);
+      expect((await job.balance())?.toString()).toBe(toFullDigit(0).toString());
+    });
+
+    it('Should be able to cancel partially paid job', async () => {
+      await job.initialize();
+      await job.launch();
+      await job.setup();
+
+      const finalResults = { results: 0 };
+      await job.bulkPayout(
+        [
+          {
+            address: WORKER1_ADDR,
+            amount: 50,
+          },
+        ],
+        finalResults,
+        true
+      );
+
+      expect(await job.cancel()).toBe(true);
+      expect((await job.balance())?.toString()).toBe(toFullDigit(0).toString());
+    });
+
+    it('Should not be able to cancel paid job', async () => {
+      await job.initialize();
+      await job.launch();
+      await job.setup();
+
+      const finalResults = { results: 0 };
+      await job.bulkPayout(
+        [
+          {
+            address: WORKER1_ADDR,
+            amount: 100,
+          },
+        ],
+        finalResults,
+        true
+      );
+
+      expect(await job.cancel()).toBe(false);
+    });
+  });
+});

package/test/utils/constants.ts

@@ -0,0 +1,27 @@
+export const DEFAULT_HMTOKEN_ADDR =
+  '0x5FbDB2315678afecb367f032d93F642f64180aa3';
+
+export const DEFAULT_GAS_PAYER_ADDR =
+  '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266';
+export const DEFAULT_GAS_PAYER_PRIVKEY =
+  'ac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80';
+
+export const REPUTATION_ORACLE_ADDR =
+  '0x70997970C51812dc3A010C7d01b50e0d17dc79C8';
+export const REPUTATION_ORACLE_PRIVKEY =
+  '59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d';
+
+export const TRUSTED_OPERATOR1_ADDR =
+  '0x3C44CdDdB6a900fa2b585dd299e03d12FA4293BC';
+export const TRUSTED_OPERATOR1_PRIVKEY =
+  '5de4111afa1a4b94908f83103eb1f1706367c2e68ca870fc3fb9a804cdab365a';
+
+export const TRUSTED_OPERATOR2_ADDR =
+  '0x90F79bf6EB2c4f870365E785982E1f101E93b906';
+
+export const WORKER1_ADDR = '0x15d34AAf54267DB7D7c367839AAf71A00a2C6A65';
+export const WORKER2_ADDR = '0x9965507D1a55bcC2695C58ba16FB37d819B0A4dc';
+export const WORKER3_ADDR = '0x976EA74026E726554dB657fA54763abd0C3a0aa9';
+
+export const NOT_TRUSTED_OPERATOR_PRIVKEY =
+  '5de4111afa1a4b94908f83103eb1f1706367c2e68ca870fc3fb9a804cdab365b';

package/test/utils/manifest.ts

@@ -0,0 +1,33 @@
+import { Manifest } from '../../src';
+
+const CALLBACK_URL = 'http://google.com/webback';
+const GAS_PAYER = '0x1413862c2b7054cdbfdc181b83962cb0fc11fd92';
+const FAKE_URL = 'http://google.com/fake';
+const IMAGE_LABEL_BINARY = 'image_label_binary';
+
+export const manifest: Manifest = {
+  requester_restricted_answer_set: {
+    '0': { en: 'English Answer 1' },
+    '1': {
+      en: 'English Answer 2',
+      answer_example_uri: 'https://hcaptcha.com/example_answer2.jpg',
+    },
+  },
+  job_mode: 'batch',
+  request_type: IMAGE_LABEL_BINARY,
+  unsafe_content: false,
+  task_bid_price: 1,
+  oracle_stake: 0.05,
+  expiration_date: 0,
+  minimum_trust_server: 0.1,
+  minimum_trust_client: 0.1,
+  requester_accuracy_target: 0.1,
+  recording_oracle_addr: GAS_PAYER,
+  reputation_oracle_addr: GAS_PAYER,
+  reputation_agent_addr: GAS_PAYER,
+  instant_result_delivery_webhook: CALLBACK_URL,
+  requester_question: { en: 'How much money are we to make' },
+  requester_question_example: FAKE_URL,
+  job_total_tasks: 100,
+  taskdata_uri: FAKE_URL,
+};