Unlock grace period contracts

packages/grid_client/src/clients/tf-grid/contracts.ts

@@ -1,4 +1,6 @@
 import {
+  Contract,
+  ContractLock,
   ContractLockOptions,
   Contracts,
   ExtrinsicResult,
@@ -100,6 +102,14 @@ export interface CancelMyContractOptions {
   graphqlURL: string;
 }
 
+export type LockDetails = { [key: number]: ContractLock };
+export interface LockContracts {
+  nameContracts: LockDetails;
+  nodeContracts: LockDetails;
+  rentContracts: LockDetails;
+  totalAmountLocked: number;
+}
+
 class TFContracts extends Contracts {
   async listContractsByTwinId(options: ListContractByTwinIdOptions): Promise<GqlContracts> {
     options.stateList = options.stateList || [ContractStates.Created, ContractStates.GracePeriod];
@@ -326,6 +336,29 @@ class TFContracts extends Contracts {
     return ids;
   }
 
+  async batchUnlockContracts(ids: number[]) {
+    const billableContractsIDs: number[] = [];
+    for (const id of ids) {
+      if ((await this.contractLock({ id })).amountLocked > 0) billableContractsIDs.push(id);
+    }
+    const extrinsics: ExtrinsicResult<number>[] = [];
+    for (const id of billableContractsIDs) {
+      extrinsics.push(await this.unlock(id));
+    }
+    return this.client.applyAllExtrinsics(extrinsics);
+  }
+
+  async unlockMyContracts(graphqlURL: string) {
+    const contracts = await this.listMyContracts({
+      stateList: [ContractStates.GracePeriod],
+      graphqlURL,
+    });
+    const ids: number[] = [...contracts.nameContracts, ...contracts.nodeContracts, ...contracts.rentContracts].map(
+      contract => parseInt(contract.contractID),
+    );
+    return await this.batchUnlockContracts(ids);
+  }
+
   async getDedicatedNodeExtraFee(options: GetDedicatedNodePriceOptions): Promise<number> {
     // converting fees from milli to usd before getting
     const fee = new Decimal(await super.getDedicatedNodeExtraFee(options));

packages/grid_client/src/modules/contracts.ts

@@ -1,7 +1,8 @@
+import { Contract } from "@threefold/tfchain_client";
 import { DeploymentKeyDeletionError, InsufficientBalanceError } from "@threefold/types";
 import * as PATH from "path";
 
-import { GqlNameContract, GqlNodeContract, GqlRentContract } from "../clients/tf-grid";
+import { GqlNameContract, GqlNodeContract, GqlRentContract, LockContracts } from "../clients/tf-grid";
 import { TFClient } from "../clients/tf-grid/client";
 import { GridClientConfig } from "../config";
 import { events } from "../helpers/events";
@@ -19,6 +20,7 @@ import {
   ContractsByAddress,
   ContractsByTwinId,
   ContractState,
+  ContractStates,
   CreateServiceContractModel,
   GetActiveContractsModel,
   GetDedicatedNodePriceModel,
@@ -271,6 +273,55 @@ class Contracts {
   async getDeletionTime(options: ContractGetModel): Promise<string | number> {
     return this.client.contracts.getDeletionTime(options);
   }
+  /**
+   * Retrieves lock details of contracts.
+   * @returns A Promise that resolves to an object of type LockContracts containing details of locked contracts.
+   */
+  @expose
+  @validateInput
+  async getContractsLockDetails(): Promise<LockContracts> {
+    const LockedContracts: LockContracts = {
+      nameContracts: {},
+      nodeContracts: {},
+      rentContracts: {},
+      totalAmountLocked: 0,
+    };
+    const contracts = await this.listMyContracts({ state: [ContractStates.GracePeriod] });
+
+    if (contracts == undefined) return LockedContracts;
+
+    const contractTypes = ["nameContracts", "nodeContracts", "rentContracts"];
+
+    for (const type of contractTypes) {
+      for (const contract of contracts[type]) {
+        const contractID = parseInt(contract.contractID);
+        const contractLockDetails = await this.contractLock({ id: contractID });
+        LockedContracts[type][contractID] = contractLockDetails;
+        LockedContracts.totalAmountLocked += contractLockDetails.amountLocked;
+      }
+    }
+    return LockedContracts;
+  }
+
+  /**
+   * Unlocks multiple contracts.
+   * @param ids An array of contract IDs to be unlocked.
+   * @returns A Promise that resolves to an array of billed contracts representing the result of batch unlocking.
+   */
+  @expose
+  @validateInput
+  async unlockContracts(ids: number[]): Promise<number[]> {
+    return await this.client.contracts.batchUnlockContracts(ids);
+  }
+  /**
+   * Unlocks contracts associated with the current user.
+   * @returns A Promise that resolves to an array of billed contracts.
+   */
+  @expose
+  @validateInput
+  async unlockMyContracts(): Promise<number[]> {
+    return await this.client.contracts.unlockMyContracts(this.config.graphqlURL);
+  }
 }
 
 export { Contracts as contracts };