@human-protocol/sdk 1.0.1 → 1.0.25

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@human-protocol/sdk",
   "description": "Human Protocol SDK",
-  "version": "1.0.1",
+  "version": "1.0.25",
   "files": [
     "src",
     "dist",
@@ -14,7 +14,7 @@
     "clean": "rm -rf ./dist",
     "build": "npm run clean && tsc",
     "prepublish": "npm run build",
-    "test": "./scripts/run-test.sh",
+    "test": "concurrently -k -s first -g --hide 0 \"yarn workspace @human-protocol/core local\" \"sleep 5 && jest --runInBand\"",
     "lint": "eslint .",
     "lint:fix": "eslint . --fix",
     "format": "prettier --write '**/*.{ts,json}'"
@@ -38,7 +38,7 @@
     ]
   },
   "dependencies": {
-    "@human-protocol/core": "^1.0.9",
+    "@human-protocol/core": "^1.0.12",
     "aws-sdk": "^2.1255.0",
     "crypto": "^1.0.1",
     "dotenv": "^16.0.3",
@@ -47,6 +47,6 @@
     "winston": "^3.8.2"
   },
   "peerDependencies": {
-    "@human-protocol/core": "^1.0.9"
+    "@human-protocol/core": "^1.0.12"
   }
-}
+}

package/src/error.ts

@@ -36,3 +36,8 @@ export const ErrorHMTokenMissing = new Error('HMToken is missing');
 export const ErrorStorageAccessDataMissing = new Error(
   'Storage access data is missing'
 );
+
+/**
+ * @constant {Error} - The Staking contract is missing.
+ */
+export const ErrorStakingMissing = new Error('Staking contract is missing');

package/src/job.ts

@@ -20,6 +20,7 @@ import {
   getEscrow,
   getEscrowFactory,
   getHmToken,
+  getStaking,
   toFullDigit,
 } from './utils';
 import {
@@ -29,6 +30,7 @@ import {
   ErrorJobNotLaunched,
   ErrorManifestMissing,
   ErrorReputationOracleMissing,
+  ErrorStakingMissing,
   ErrorStorageAccessDataMissing,
 } from './error';
 import { createLogger } from './logger';
@@ -94,6 +96,7 @@ export class Job {
     storageEndpoint,
     storagePublicBucket,
     storageBucket,
+    stakingAddr,
     logLevel = 'info',
   }: JobArguments) {
     const provider = network
@@ -134,6 +137,7 @@ export class Job {
       hmTokenAddr,
       escrowAddr,
       factoryAddr,
+      stakingAddr,
     };
 
     this.manifestData = { manifest };
@@ -174,9 +178,21 @@ export class Job {
         return false;
       }
 
+      if (!this.contractData.stakingAddr) {
+        this._logError(new Error('Staking contract is missing'));
+        return false;
+      }
+
+      this._logger.info('Getting staking...');
+      this.contractData.staking = await getStaking(
+        this.contractData.stakingAddr,
+        this.providerData?.gasPayer
+      );
+
       this._logger.info('Deploying escrow factory...');
       this.contractData.factory = await deployEscrowFactory(
         this.contractData.hmTokenAddr,
+        this.contractData.stakingAddr,
         this.providerData?.gasPayer
       );
       this.contractData.factoryAddr = this.contractData.factory.address;
@@ -197,6 +213,31 @@ export class Job {
         this.providerData?.gasPayer
       );
 
+      this._logger.info('Checking if staking is configured...');
+      const stakingAddr = await this.contractData.factory.staking();
+      if (!stakingAddr) {
+        this._logError(new Error('Factory is not configured with staking'));
+        this.contractData.factory = undefined;
+
+        return false;
+      }
+      this._logger.info('Getting staking...');
+      this.contractData.staking = await getStaking(
+        stakingAddr,
+        this.providerData?.gasPayer
+      );
+      this.contractData.stakingAddr = stakingAddr;
+
+      this._logger.info('Checking if reward pool is configured...');
+      const rewardPoolAddr = await this.contractData.staking.rewardPool();
+      if (!rewardPoolAddr) {
+        this._logError(new Error('Staking is not configured with reward pool'));
+        this.contractData.staking = undefined;
+        this.contractData.factory = undefined;
+
+        return false;
+      }
+
       this._logger.info('Checking if escrow exists in the factory...');
       const hasEscrow = await this.contractData?.factory.hasEscrow(
         this.contractData?.escrowAddr
@@ -274,26 +315,32 @@ export class Job {
 
     this._logger.info('Launching escrow...');
 
-    const txReceipt = await this.contractData?.factory?.createEscrow(
-      this.providerData?.trustedHandlers?.map(
-        (trustedHandler) => trustedHandler.address
-      ) || []
-    );
+    try {
+      const txReceipt = await this.contractData?.factory?.createEscrow(
+        this.providerData?.trustedHandlers?.map(
+          (trustedHandler) => trustedHandler.address
+        ) || []
+      );
 
-    const txResponse = await txReceipt?.wait();
+      const txResponse = await txReceipt?.wait();
 
-    const event = txResponse?.events?.find(
-      (event) => event.event === 'Launched'
-    );
+      const event = txResponse?.events?.find(
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        (event: any) => event.event === 'Launched'
+      );
 
-    const escrowAddr = event?.args?.[1];
-    this._logger.info(`Escrow is deployed at ${escrowAddr}.`);
+      const escrowAddr = event?.args?.[1];
+      this._logger.info(`Escrow is deployed at ${escrowAddr}.`);
 
-    this.contractData.escrowAddr = escrowAddr;
-    this.contractData.escrow = await getEscrow(
-      escrowAddr,
-      this.providerData?.gasPayer
-    );
+      this.contractData.escrowAddr = escrowAddr;
+      this.contractData.escrow = await getEscrow(
+        escrowAddr,
+        this.providerData?.gasPayer
+      );
+    } catch {
+      this._logError(new Error('Error creating escrow...'));
+      return false;
+    }
 
     return (
       (await this.status()) == EscrowStatus.Launched &&
@@ -633,6 +680,184 @@ export class Job {
     return (await this.status()) === EscrowStatus.Complete;
   }
 
+  /**
+   * **Stake HMTokens**
+   *
+   * @param {number} amount - Amount to stake
+   * @param {string | undefined} from - Address to stake
+   * @returns {Promise<boolean>} - True if the token is staked
+   */
+  async stake(amount: number, from?: string) {
+    if (!this.contractData?.staking) {
+      this._logError(ErrorStakingMissing);
+      return false;
+    }
+    if (!this.contractData.hmToken) {
+      this._logError(ErrorHMTokenMissing);
+      return false;
+    }
+
+    const operator = this._findOperator(from);
+
+    if (!operator) {
+      this._logError(new Error('Unknown wallet'));
+      return false;
+    }
+
+    try {
+      const approved = await this.contractData.hmToken
+        .connect(operator)
+        .approve(this.contractData.staking.address, toFullDigit(amount));
+
+      if (!approved) {
+        throw new Error('Not approved');
+      }
+    } catch {
+      this._logError(new Error('Error approving HMTokens for staking'));
+      return false;
+    }
+
+    try {
+      await this.contractData.staking
+        .connect(operator)
+        .stake(toFullDigit(amount));
+    } catch {
+      this._logError(new Error(`Error executing transaction from ${from}`));
+      return false;
+    }
+    return true;
+  }
+
+  /**
+   * **Unstake HMTokens**
+   *
+   * @param {number} amount - Amount to unstake
+   * @param {string | undefined} from - Address to unstake
+   * @returns {Promise<boolean>} - True if the token is unstaked
+   */
+  async unstake(amount: number, from?: string) {
+    if (!this.contractData?.staking) {
+      this._logError(ErrorStakingMissing);
+      return false;
+    }
+
+    const operator = this._findOperator(from);
+
+    if (!operator) {
+      this._logError(new Error('Unknown wallet'));
+      return false;
+    }
+
+    try {
+      await this.contractData.staking
+        .connect(operator)
+        .unstake(toFullDigit(amount));
+    } catch {
+      this._logError(new Error(`Error executing transaction from ${from}`));
+      return false;
+    }
+    return true;
+  }
+
+  /**
+   * **Withdraw unstaked HMTokens**
+   *
+   * @param {string | undefined} from - Address to withdraw
+   * @returns {Promise<boolean>} - True if the token is withdrawn
+   */
+  async withdraw(from?: string) {
+    if (!this.contractData?.staking) {
+      this._logError(ErrorStakingMissing);
+      return false;
+    }
+
+    const operator = this._findOperator(from);
+
+    if (!operator) {
+      this._logError(new Error('Unknown wallet'));
+      return false;
+    }
+
+    try {
+      await this.contractData.staking.connect(operator).withdraw();
+    } catch {
+      this._logError(new Error(`Error executing transaction from ${from}`));
+      return false;
+    }
+    return true;
+  }
+
+  /**
+   * **Allocate HMTokens staked to the job**
+   *
+   * @param {number} amount - Amount to allocate
+   * @param {string | undefined} - Address to allocate with
+   * @returns {Promise<boolean>} - True if the token is allocated
+   */
+  async allocate(amount: number, from?: string) {
+    if (!this.contractData?.staking) {
+      this._logError(ErrorStakingMissing);
+      return false;
+    }
+
+    if (!this.contractData.escrowAddr) {
+      this._logError(ErrorJobNotLaunched);
+      return false;
+    }
+
+    const operator = this._findOperator(from);
+
+    if (!operator) {
+      this._logError(new Error('Unknown wallet'));
+      return false;
+    }
+
+    try {
+      await this.contractData.staking
+        .connect(operator)
+        .allocate(this.contractData.escrowAddr, toFullDigit(amount));
+    } catch {
+      this._logError(new Error(`Error executing transaction from ${from}`));
+      return false;
+    }
+    return true;
+  }
+
+  /**
+   * **Unallocate HMTokens from the job**
+   *
+   * @param {string | undefined} - Address to close allocation with
+   * @returns {Promise<boolean>} - True if the token is unallocated.
+   */
+  async closeAllocation(from?: string) {
+    if (!this.contractData?.staking) {
+      this._logError(ErrorStakingMissing);
+      return false;
+    }
+
+    if (!this.contractData.escrowAddr) {
+      this._logError(ErrorJobNotLaunched);
+      return false;
+    }
+
+    const operator = this._findOperator(from);
+
+    if (!operator) {
+      this._logError(new Error('Unknown wallet'));
+      return false;
+    }
+
+    try {
+      await this.contractData.staking
+        .connect(operator)
+        .closeAllocation(this.contractData.escrowAddr);
+    } catch {
+      this._logError(new Error(`Error executing transaction from ${from}`));
+      return false;
+    }
+    return true;
+  }
+
   /**
    * **Get current status of the escrow**
    *
@@ -803,8 +1028,10 @@ export class Job {
         await contract.connect(trustedHandler).functions[functionName](...args);
         return true;
       } catch (err) {
-        new Error(
-          'Error executing the transaction from all of the trusted handlers. Stop continue executing...'
+        this._logError(
+          new Error(
+            'Error executing the transaction from all of the trusted handlers. Stop continue executing...'
+          )
         );
       }
     }
@@ -813,9 +1040,25 @@ export class Job {
 
   /**
    * **Error log**
+   *
    * @param {Error} error - Occured error
    */
-  private async _logError(error: Error) {
+  private _logError(error: Error) {
     this._logger.error(error.message);
   }
+
+  /**
+   * **Find operator to execute tx**
+   *
+   * @param {string} addr - Address of the operator
+   * @returns {ethers.Wallet | undefined} - Operator wallet
+   */
+  private _findOperator(addr?: string): ethers.Wallet | undefined {
+    return addr
+      ? [
+          this.providerData?.gasPayer,
+          ...(this.providerData?.trustedHandlers || []),
+        ].find((account?: ethers.Wallet) => account?.address === addr)
+      : this.providerData?.gasPayer;
+  }
 }

package/src/storage.ts

@@ -76,7 +76,7 @@ export const getKeyFromURL = (url: string): string => {
  * @param {StorageAccessData} storageAccessData - Cloud storage access data
  * @param {string} key - Key of result object
  * @param {string} privateKey - Private key to decode encrypted content
- * @param {string} isPublic - Whether the objest is using public bucket, or private bucket
+ * @param {boolean} isPublic - Whether the objest is using public bucket, or private bucket
  * @returns {Promise<Result>} - Downloaded result
  */
 export const download = async (
@@ -104,14 +104,15 @@ export const download = async (
  * @param {StorageAccessData} storageAccessData - Cloud storage access data
  * @param {Result} result - Result to upload
  * @param {string} publicKey - Public key to encrypt data if necessary
- * @param {string} encrypt - Whether to encrypt the result, or not
- * @param {string} isPublic - Whether to use public bucket, or private bucket
+ * @param {boolean} _encrypt - Whether to encrypt the result, or not
+ * @param {boolean} isPublic - Whether to use public bucket, or private bucket
  * @returns {Promise<UploadResult>} - Uploaded result with key/hash
  */
 export const upload = async (
   storageAccessData: StorageAccessData,
   result: Result,
   publicKey: string,
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
   encrypt = true,
   isPublic = false
 ): Promise<UploadResult> => {

package/src/types.ts

@@ -2,6 +2,7 @@ import {
   Escrow,
   EscrowFactory,
   HMToken,
+  Staking,
 } from '@human-protocol/core/typechain-types';
 import { ethers } from 'ethers';
 
@@ -567,6 +568,14 @@ export type ContractData = {
    * HMToken contract instance
    */
   hmToken?: HMToken;
+  /**
+   * Staking contract address
+   */
+  stakingAddr?: string;
+  /**
+   * Staking contract instance
+   */
+  staking?: Staking;
 };
 
 /**
@@ -627,6 +636,10 @@ export type JobArguments = {
   /**
    * Factory contract address
    */
+  stakingAddr?: string;
+  /**
+   * Staking contract address
+   */
   factoryAddr?: string;
   /**
    * Escrow contract address

package/src/utils.ts

@@ -7,6 +7,10 @@ import {
   EscrowFactory__factory,
   HMToken,
   HMToken__factory,
+  Staking,
+  Staking__factory,
+  RewardPool,
+  RewardPool__factory,
 } from '@human-protocol/core/typechain-types';
 
 /**
@@ -31,16 +35,18 @@ export const getHmToken = async (
  * **Deploy EscrowFactory contract**
  *
  * @param {string} hmTokenAddr HMToken address
+ * @param {string} stakingAddr Staking address
  * @param {ethers.Signer | undefined} signer Deployer signer
  * @returns {Promise<EscrowFactory>} Deployed contract instance
  */
 export const deployEscrowFactory = async (
   hmTokenAddr: string,
+  stakingAddr: string,
   signer?: ethers.Signer
 ): Promise<EscrowFactory> => {
   const factory = new EscrowFactory__factory(signer);
 
-  const contract = await factory.deploy(hmTokenAddr);
+  const contract = await factory.deploy(hmTokenAddr, stakingAddr);
 
   return contract;
 };
@@ -81,6 +87,66 @@ export const getEscrow = async (
   return contract;
 };
 
+/**
+ * **Deploy Staking contract**
+ *
+ * @param {string} hmTokenAddr HMToken address
+ * @param {number} minimumStake Minimum amount to stake
+ * @param {number} lockPeriod Lock period after unstake
+ * @param {ethers.Signer | undefined} signer Deployer signer
+ * @returns {Promise<Staking>} Deployed contract instance
+ */
+export const deployStaking = async (
+  hmTokenAddr: string,
+  minimumStake: number,
+  lockPeriod: number,
+  signer?: ethers.Signer
+): Promise<Staking> => {
+  const staking = new Staking__factory(signer);
+  const contract = await staking.deploy(hmTokenAddr, minimumStake, lockPeriod);
+
+  return contract;
+};
+
+/**
+ * **Get Staking contract instance at given address**
+ *
+ * @param {string} stakingAddr Staking contract address
+ * @param {ethers.Signer | undefined} signer Deployer signer
+ * @returns {Promise<Staking>} Attached contract instance
+ */
+export const getStaking = async (
+  stakingAddr: string,
+  signer?: ethers.Signer
+): Promise<Staking> => {
+  const factory = new Staking__factory(signer);
+
+  const contract = await factory.attach(stakingAddr);
+
+  return contract;
+};
+
+/**
+ * **Deploy RewardPool contract**
+ *
+ * @param {string} hmTokenAddr HMToken address
+ * @param {string} stakingAddr Staking address
+ * @param {number} fee Reward fee of the protocol
+ * @param {ethers.Signer | undefined} signer Deployer signer
+ * @returns {Promise<Staking>} Deployed contract instance
+ */
+export const deployRewardPool = async (
+  hmTokenAddr: string,
+  stakingAddr: string,
+  fee: number,
+  signer?: ethers.Signer
+): Promise<RewardPool> => {
+  const rewardPool = new RewardPool__factory(signer);
+  const contract = await rewardPool.deploy(hmTokenAddr, stakingAddr, fee);
+
+  return contract;
+};
+
 /**
  * **Get specific amount representation in given decimals**
  *

package/test/job.test.ts

@@ -6,6 +6,7 @@ import {
   DEFAULT_GAS_PAYER_ADDR,
   DEFAULT_GAS_PAYER_PRIVKEY,
   DEFAULT_HMTOKEN_ADDR,
+  DEFAULT_STAKING_ADDR,
   NOT_TRUSTED_OPERATOR_PRIVKEY,
   REPUTATION_ORACLE_PRIVKEY,
   TRUSTED_OPERATOR1_ADDR,
@@ -29,6 +30,12 @@ jest.mock('../src/storage', () => ({
   getPublicURL: jest.fn().mockResolvedValue('public-url'),
 }));
 
+const setupJob = async (job: Job) => {
+  await job.initialize();
+  await job.launch();
+  await job.setup();
+};
+
 describe('Test Job', () => {
   describe('New job', () => {
     let job: Job;
@@ -39,7 +46,8 @@ describe('Test Job', () => {
         reputationOracle: REPUTATION_ORACLE_PRIVKEY,
         manifest: manifest,
         hmTokenAddr: DEFAULT_HMTOKEN_ADDR,
-        logLevel: 'debug',
+        stakingAddr: DEFAULT_STAKING_ADDR,
+        logLevel: 'error',
       });
     });
 
@@ -54,11 +62,11 @@ describe('Test Job', () => {
       expect(await job.contractData?.factory?.address).not.toBeNull();
     });
 
-    it('Should be able to launch the job', async () => {
-      // Fail to launch the job before initialization
+    it('Should be able to launch the job after staking', async () => {
+      expect(await job.initialize()).toBe(true);
       expect(await job.launch()).toBe(false);
 
-      await job.initialize();
+      await job.stake(1);
 
       expect(await job.launch()).toBe(true);
       expect(await job.status()).toBe(EscrowStatus.Launched);
@@ -92,9 +100,7 @@ describe('Test Job', () => {
     });
 
     it('Should be able to bulk payout workers', async () => {
-      await job.initialize();
-      await job.launch();
-      await job.setup();
+      await setupJob(job);
 
       expect(
         await job.bulkPayout(
@@ -148,9 +154,7 @@ describe('Test Job', () => {
     });
 
     it('Should encrypt result, when bulk paying out workers', async () => {
-      await job.initialize();
-      await job.launch();
-      await job.setup();
+      await setupJob(job);
 
       jest.clearAllMocks();
       const finalResults = { results: 0 };
@@ -176,9 +180,7 @@ describe('Test Job', () => {
     });
 
     it('Should not encrypt result, when bulk paying out workers', async () => {
-      await job.initialize();
-      await job.launch();
-      await job.setup();
+      await setupJob(job);
 
       jest.clearAllMocks();
       const finalResults = { results: 0 };
@@ -204,9 +206,7 @@ describe('Test Job', () => {
     });
 
     it('Should store result in private storage, when bulk paying out workers', async () => {
-      await job.initialize();
-      await job.launch();
-      await job.setup();
+      await setupJob(job);
 
       jest.clearAllMocks();
       const finalResults = { results: 0 };
@@ -233,9 +233,7 @@ describe('Test Job', () => {
     });
 
     it('Should store result in public storage, when bulk paying out workers', async () => {
-      await job.initialize();
-      await job.launch();
-      await job.setup();
+      await setupJob(job);
 
       jest.clearAllMocks();
       const finalResults = { results: 0 };
@@ -263,9 +261,7 @@ describe('Test Job', () => {
     });
 
     it('Should return final result', async () => {
-      await job.initialize();
-      await job.launch();
-      await job.setup();
+      await setupJob(job);
 
       const finalResults = { results: 0 };
       await job.bulkPayout(
@@ -285,17 +281,13 @@ describe('Test Job', () => {
     });
 
     it('Should be able to abort the job', async () => {
-      await job.initialize();
-      await job.launch();
-      await job.setup();
+      await setupJob(job);
 
       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();
+      await setupJob(job);
 
       const finalResults = { results: 0 };
       await job.bulkPayout(
@@ -313,9 +305,7 @@ describe('Test Job', () => {
     });
 
     it('Should not be able to abort fully paid job', async () => {
-      await job.initialize();
-      await job.launch();
-      await job.setup();
+      await setupJob(job);
 
       const finalResults = { results: 0 };
       await job.bulkPayout(
@@ -333,18 +323,14 @@ describe('Test Job', () => {
     });
 
     it('Should be able to cancel the job', async () => {
-      await job.initialize();
-      await job.launch();
-      await job.setup();
+      await setupJob(job);
 
       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();
+      await setupJob(job);
 
       const finalResults = { results: 0 };
       await job.bulkPayout(
@@ -363,9 +349,7 @@ describe('Test Job', () => {
     });
 
     it('Should not be able to cancel paid job', async () => {
-      await job.initialize();
-      await job.launch();
-      await job.setup();
+      await setupJob(job);
 
       const finalResults = { results: 0 };
       await job.bulkPayout(
@@ -381,6 +365,81 @@ describe('Test Job', () => {
 
       expect(await job.cancel()).toBe(false);
     });
+
+    it('Should be able to allocate token to the job', async () => {
+      await job.initialize();
+
+      expect(await job.launch()).toBe(true);
+      expect(await job.status()).toBe(EscrowStatus.Launched);
+
+      expect(await job.allocate(1)).toBe(true);
+    });
+
+    it('Should be able to launch another job after allocating portion of the stake', async () => {
+      await job.initialize();
+      await job.stake(2);
+
+      expect(await job.launch()).toBe(true);
+      expect(await job.status()).toBe(EscrowStatus.Launched);
+
+      expect(await job.allocate(1)).toBe(true);
+
+      const newJob = new Job({
+        gasPayer: DEFAULT_GAS_PAYER_PRIVKEY,
+        reputationOracle: REPUTATION_ORACLE_PRIVKEY,
+        manifest: manifest,
+        hmTokenAddr: DEFAULT_HMTOKEN_ADDR,
+        stakingAddr: DEFAULT_STAKING_ADDR,
+        logLevel: 'error',
+      });
+
+      await newJob.initialize();
+      expect(await newJob.launch()).toBe(true);
+    });
+
+    it('Should not be able to launch another job after allocating all of the stake', async () => {
+      await job.initialize();
+
+      expect(await job.launch()).toBe(true);
+      expect(await job.status()).toBe(EscrowStatus.Launched);
+
+      expect(await job.allocate(1)).toBe(true);
+
+      const newJob = new Job({
+        gasPayer: DEFAULT_GAS_PAYER_PRIVKEY,
+        reputationOracle: REPUTATION_ORACLE_PRIVKEY,
+        manifest: manifest,
+        hmTokenAddr: DEFAULT_HMTOKEN_ADDR,
+        stakingAddr: DEFAULT_STAKING_ADDR,
+        logLevel: 'error',
+      });
+
+      await newJob.initialize();
+      expect(await newJob.launch()).toBe(false);
+    });
+
+    it('Should be able to launch another job after staking more tokens', async () => {
+      await job.initialize();
+      await job.stake(1);
+
+      expect(await job.launch()).toBe(true);
+      expect(await job.status()).toBe(EscrowStatus.Launched);
+
+      expect(await job.allocate(1)).toBe(true);
+
+      const newJob = new Job({
+        gasPayer: DEFAULT_GAS_PAYER_PRIVKEY,
+        reputationOracle: REPUTATION_ORACLE_PRIVKEY,
+        manifest: manifest,
+        hmTokenAddr: DEFAULT_HMTOKEN_ADDR,
+        stakingAddr: DEFAULT_STAKING_ADDR,
+        logLevel: 'error',
+      });
+
+      await newJob.initialize();
+      await newJob.stake(1);
+      expect(await newJob.launch()).toBe(true);
+    });
   });
 
   describe('Access existing job from trusted handler', () => {
@@ -392,12 +451,14 @@ describe('Test Job', () => {
         reputationOracle: REPUTATION_ORACLE_PRIVKEY,
         manifest: manifest,
         hmTokenAddr: DEFAULT_HMTOKEN_ADDR,
+        stakingAddr: DEFAULT_STAKING_ADDR,
         trustedHandlers: [TRUSTED_OPERATOR1_PRIVKEY],
         logLevel: 'error',
       });
 
       await originalJob.initialize();
       await originalJob.launch();
+      await originalJob.stake(1);
       await originalJob.setup();
 
       job = new Job({
@@ -407,7 +468,7 @@ describe('Test Job', () => {
         escrowAddr: originalJob.contractData?.escrowAddr,
         factoryAddr: originalJob.contractData?.factoryAddr,
         trustedHandlers: [TRUSTED_OPERATOR1_PRIVKEY],
-        logLevel: 'debug',
+        logLevel: 'error',
       });
     });
 
@@ -416,8 +477,7 @@ describe('Test Job', () => {
     });
 
     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.initialize()).toBe(true);
 
       expect(await job.manifestData?.manifestlink?.url).toBe('uploaded-key');
       expect(await job.manifestData?.manifestlink?.hash).toBe('uploaded-hash');
@@ -430,7 +490,7 @@ describe('Test Job', () => {
       expect(await job.status()).toBe(EscrowStatus.Pending);
     });
 
-    it('Should be able to setup the job again', async () => {
+    it('Should not be able to setup the job again', async () => {
       await job.initialize();
 
       expect(await job.setup()).toBe(false);
@@ -444,7 +504,6 @@ describe('Test Job', () => {
 
     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);
 
@@ -461,8 +520,6 @@ describe('Test Job', () => {
 
     it('Should be able to bulk payout workers', async () => {
       await job.initialize();
-      await job.launch();
-      await job.setup();
 
       expect(
         await job.bulkPayout(
@@ -517,8 +574,6 @@ describe('Test Job', () => {
 
     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 };
@@ -545,8 +600,6 @@ describe('Test Job', () => {
 
     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 };
@@ -573,8 +626,6 @@ describe('Test Job', () => {
 
     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 };
@@ -602,8 +653,6 @@ describe('Test Job', () => {
 
     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 };
@@ -632,8 +681,6 @@ describe('Test Job', () => {
 
     it('Should return final result', async () => {
       await job.initialize();
-      await job.launch();
-      await job.setup();
 
       const finalResults = { results: 0 };
       await job.bulkPayout(
@@ -654,16 +701,12 @@ describe('Test Job', () => {
 
     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(
@@ -682,8 +725,6 @@ describe('Test Job', () => {
 
     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(
@@ -702,8 +743,6 @@ describe('Test Job', () => {
 
     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());
@@ -711,8 +750,6 @@ describe('Test Job', () => {
 
     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(
@@ -732,8 +769,6 @@ describe('Test Job', () => {
 
     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(
@@ -749,5 +784,34 @@ describe('Test Job', () => {
 
       expect(await job.cancel()).toBe(false);
     });
+
+    it('Should not be able to allocate to job without staking', async () => {
+      await job.initialize();
+      expect(await job.allocate(1, TRUSTED_OPERATOR1_ADDR)).toBe(false);
+    });
+
+    it('Should be able to allocate to job after staking', async () => {
+      await job.initialize();
+      await job.stake(1, TRUSTED_OPERATOR1_ADDR);
+
+      expect(await job.allocate(1, TRUSTED_OPERATOR1_ADDR)).toBe(true);
+    });
+
+    it('Should be able to launch another job after staking', async () => {
+      await job.initialize();
+      await job.stake(1, TRUSTED_OPERATOR1_ADDR);
+
+      const newJob = new Job({
+        gasPayer: TRUSTED_OPERATOR1_PRIVKEY,
+        reputationOracle: REPUTATION_ORACLE_PRIVKEY,
+        manifest: manifest,
+        hmTokenAddr: DEFAULT_HMTOKEN_ADDR,
+        stakingAddr: DEFAULT_STAKING_ADDR,
+        logLevel: 'error',
+      });
+
+      await newJob.initialize();
+      expect(await newJob.launch()).toBe(true);
+    });
   });
 });

package/test/utils/constants.ts

@@ -1,6 +1,9 @@
 export const DEFAULT_HMTOKEN_ADDR =
   '0x5FbDB2315678afecb367f032d93F642f64180aa3';
 
+export const DEFAULT_STAKING_ADDR =
+  '0xe7f1725E7734CE288F8367e1Bb143E90bb3F0512';
+
 export const DEFAULT_GAS_PAYER_ADDR =
   '0xf39Fd6e51aad88F6F4ce6aB8827279cffFb92266';
 export const DEFAULT_GAS_PAYER_PRIVKEY =