@trustvc/trustvc 2.6.1 → 2.8.0

package/README.md

@@ -26,6 +26,7 @@ TrustVC is a comprehensive wrapper library designed to simplify the signing and
       - [a) Token Registry v4](#a-token-registry-v4)
       - [b) Token Registry V5](#b-token-registry-v5)
     - [8. **Document Builder**](#8-document-builder)
+    - [9. **Document Store**](#9-document-store)
 
 ## Installation
 
@@ -890,3 +891,219 @@ To get the current state of the document as a JSON string:
 const documentJson = builder.toString();
 console.log(documentJson);
 ```
+
+## 9. Document Store
+
+> TrustVC provides comprehensive Document Store functionality for managing blockchain-based document storage and verification. The Document Store module supports both standard DocumentStore and TransferableDocumentStore contracts, enabling secure document issuance, revocation, and role management on various blockchain networks.
+
+### Key Features
+
+- **Dual Contract Support**: Works with both DocumentStore and TransferableDocumentStore contracts
+- **Automatic Contract Detection**: Uses ERC-165 interface checking to automatically identify contract types
+- **Ethers Compatibility**: Full support for both ethers v5 and v6
+- **Type Safety**: Full TypeScript support with comprehensive type definitions
+
+### Functions
+
+#### deployDocumentStore
+
+Deploys a new DocumentStore contract to the blockchain.
+
+**Parameters:**
+- `storeName` (string): The name of the document store
+- `owner` (string): The owner address of the document store
+- `signer` (Signer): Ethers v5 or v6 signer instance
+- `options` (DeployOptions, optional): Deployment configuration
+
+**DeployOptions:**
+- `chainId` (CHAIN_ID, optional): Target blockchain network
+- `maxFeePerGas` (GasValue, optional): Maximum fee per gas
+- `maxPriorityFeePerGas` (GasValue, optional): Maximum priority fee per gas
+- `isTransferable` (boolean, optional): Whether to deploy TransferableDocumentStore
+
+**Returns:** `Promise<TransactionReceipt>` - The deployment transaction receipt
+
+**Example:**
+
+```ts
+import { deployDocumentStore } from '@trustvc/trustvc';
+
+const receipt = await deployDocumentStore(
+  'My Document Store',
+  '0x1234567890123456789012345678901234567890',
+  signer,
+  {
+    chainId: CHAIN_ID.sepolia,
+    isTransferable: true,
+  }
+);
+
+console.log('Contract deployed at:', receipt.contractAddress);
+```
+
+#### documentStoreIssue
+
+Issues a document to the Document Store.
+
+**Parameters:**
+- `documentStoreAddress` (string): Address of the Document Store contract
+- `documentHash` (string): Hash of the document to issue
+- `signer` (Signer): Ethers v5 or v6 signer instance
+- `options` (IssueOptions, optional): Issuance configuration
+
+**IssueOptions:**
+- `chainId` (CHAIN_ID, optional): Target blockchain network
+- `maxFeePerGas` (GasValue, optional): Maximum fee per gas
+- `maxPriorityFeePerGas` (GasValue, optional): Maximum priority fee per gas
+- `isTransferable` (boolean, optional): Whether the contract is TransferableDocumentStore
+
+**Returns:** `Promise<string>` - Transaction hash of the issuance
+
+**Example:**
+
+```ts
+import { documentStoreIssue } from '@trustvc/trustvc';
+
+const txHash = await documentStoreIssue(
+  '0x1234567890123456789012345678901234567890',
+  '0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890',
+  signer,
+  {
+    chainId: CHAIN_ID.sepolia,
+    isTransferable: false,
+  }
+);
+
+console.log('Document issued, transaction:', txHash);
+```
+
+#### documentStoreRevoke
+
+Revokes a document from the Document Store.
+
+**Parameters:**
+- `documentStoreAddress` (string): Address of the Document Store contract
+- `documentHash` (string): Hash of the document to revoke
+- `signer` (Signer): Ethers v5 or v6 signer instance
+- `options` (RevokeOptions, optional): Revocation configuration
+
+**RevokeOptions:**
+- `chainId` (CHAIN_ID, optional): Target blockchain network
+- `maxFeePerGas` (GasValue, optional): Maximum fee per gas
+- `maxPriorityFeePerGas` (GasValue, optional): Maximum priority fee per gas
+- `isTransferable` (boolean, optional): Whether the contract is TransferableDocumentStore
+
+**Returns:** `Promise<string>` - Transaction hash of the revocation
+
+**Example:**
+
+```ts
+import { documentStoreRevoke } from '@trustvc/trustvc';
+
+const txHash = await documentStoreRevoke(
+  '0x1234567890123456789012345678901234567890',
+  '0xabcdef1234567890abcdef1234567890abcdef1234567890abcdef1234567890',
+  signer,
+  {
+    chainId: CHAIN_ID.sepolia,
+    isTransferable: false,
+  }
+);
+
+console.log('Document revoked, transaction:', txHash);
+```
+
+### Contract Types
+
+#### DocumentStore
+- Basic document store functionality
+- Supports document issuance and revocation
+- ERC-165 interface: `0x01ffc9a7` (IDocumentStore)
+
+#### TransferableDocumentStore
+- Extended document store with transfer capabilities
+- All DocumentStore functionality plus transfer features
+- ERC-165 interface: `0x8c5a6b8a` (ITransferableDocumentStore)
+
+### Error Handling
+
+All functions include comprehensive error handling:
+
+- **Validation Errors**: Invalid addresses, missing parameters, provider issues
+- **Contract Errors**: Pre-check failures, insufficient permissions, contract reverts
+- **Network Errors**: Connection issues, transaction failures
+- **Interface Detection**: Automatic fallback when ERC-165 interfaces are not supported
+
+### Gas Optimization
+
+The Document Store functions support gas optimization through configurable transaction options:
+
+```ts
+const options = {
+  maxFeePerGas: '50000000000', // 50 gwei
+  maxPriorityFeePerGas: '2000000000', // 2 gwei
+  chainId: CHAIN_ID.mainnet,
+};
+```
+
+### Usage Patterns
+
+#### Basic Usage
+
+```ts
+import { deployDocumentStore, documentStoreIssue, documentStoreRevoke } from '@trustvc/trustvc';
+
+// Deploy a new document store
+const receipt = await deployDocumentStore('My Store', ownerAddress, signer);
+
+// Issue a document
+await documentStoreIssue(receipt.contractAddress, documentHash, signer);
+
+// Revoke if needed
+await documentStoreRevoke(receipt.contractAddress, documentHash, signer);
+```
+
+#### Advanced Usage with Options
+
+```ts
+import { CHAIN_ID } from '@trustvc/trustvc';
+
+// Deploy with specific network and gas settings
+const receipt = await deployDocumentStore(
+  'Production Store',
+  ownerAddress,
+  signer,
+  {
+    chainId: CHAIN_ID.mainnet,
+    maxFeePerGas: '100000000000', // 100 gwei
+    maxPriorityFeePerGas: '5000000000', // 5 gwei
+    isTransferable: true,
+  }
+);
+
+// Issue with explicit contract type detection
+await documentStoreIssue(
+  receipt.contractAddress,
+  documentHash,
+  signer,
+  {
+    chainId: CHAIN_ID.mainnet,
+    isTransferable: true, // Explicit type detection
+  }
+);
+```
+
+#### Batch Operations
+
+```ts
+// Issue multiple documents
+const documentHashes = [
+  '0xhash1...',
+  '0xhash2...',
+  '0xhash3...',
+];
+
+for (const hash of documentHashes) {
+  await documentStoreIssue(storeAddress, hash, signer);
+}
+```

package/dist/cjs/document-store/contract-interfaces.js

@@ -0,0 +1,24 @@
+'use strict';
+
+var documentStore = require('@trustvc/document-store');
+
+const IDocumentStoreInterface = documentStore.IDocumentStore__factory.createInterface();
+const ITransferableDocumentStoreInterface = documentStore.ITransferableDocumentStore__factory.createInterface();
+const IDocumentStoreFunctions = Object.values(IDocumentStoreInterface.fragments).filter((f) => f.type === "function").map((f) => f.format("sighash"));
+const ITransferableDocumentStoreFunctions = Object.values(
+  ITransferableDocumentStoreInterface.fragments
+).filter((f) => f.type === "function").map((f) => f.format("sighash"));
+const contractInterfaces = {
+  /**
+   * IDocumentStore interface functions
+   * Functions: isActive, isIssued, isRevoked, name, revoke
+   */
+  DocumentStore: IDocumentStoreFunctions,
+  /**
+   * ITransferableDocumentStore interface functions
+   * Functions: isActive, isIssued, isRevoked, issue, name, revoke
+   */
+  TransferableDocumentStore: ITransferableDocumentStoreFunctions
+};
+
+exports.contractInterfaces = contractInterfaces;

package/dist/cjs/document-store/deploy.js

@@ -0,0 +1,49 @@
+'use strict';
+
+var documentStore = require('@trustvc/document-store');
+var ethersV6 = require('ethersV6');
+var ethers$1 = require('ethers');
+var ethers = require('../utils/ethers');
+var utils = require('../token-registry-functions/utils');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const deployDocumentStore = /* @__PURE__ */ __name(async (storeName, owner, signer, options = {}) => {
+  if (!storeName) throw new Error("Store name is required");
+  if (!owner) throw new Error("Owner address is required");
+  if (!signer.provider) throw new Error("Provider is required");
+  const { chainId, maxFeePerGas, maxPriorityFeePerGas } = options;
+  const txOptions = await utils.getTxOptions(signer, chainId, maxFeePerGas, maxPriorityFeePerGas);
+  const isV6 = ethers.isV6EthersProvider(signer.provider);
+  const DocumentStoreFactory = options.isTransferable ? documentStore.TransferableDocumentStore__factory : documentStore.DocumentStore__factory;
+  try {
+    if (isV6) {
+      const ContractFactory = new ethersV6.ContractFactory(
+        DocumentStoreFactory.abi,
+        DocumentStoreFactory.bytecode,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        signer
+      );
+      const contract = await ContractFactory.deploy(storeName, owner, txOptions);
+      const receipt = await contract.deploymentTransaction()?.wait();
+      return receipt;
+    } else {
+      const ContractFactory = new ethers$1.ContractFactory(
+        DocumentStoreFactory.abi,
+        DocumentStoreFactory.bytecode,
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        signer
+      );
+      const contract = await ContractFactory.deploy(storeName, owner, txOptions);
+      const receipt = await contract.deployTransaction.wait();
+      return receipt;
+    }
+  } catch (e) {
+    console.error("Deployment failed:", e);
+    throw new Error(
+      `Failed to deploy DocumentStore: ${e instanceof Error ? e.message : String(e)}`
+    );
+  }
+}, "deployDocumentStore");
+
+exports.deployDocumentStore = deployDocumentStore;

package/dist/cjs/document-store/document-store-roles.js

@@ -0,0 +1,38 @@
+'use strict';
+
+var ttVerify = require('@tradetrust-tt/tt-verify');
+var utils = require('../utils');
+var ethers = require('../utils/ethers');
+var ttDocumentStoreAbi = require('./tt-document-store-abi');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const getRoleString = /* @__PURE__ */ __name(async (documentStoreAddress, role, options) => {
+  const { chainId } = options || {};
+  let provider = options?.provider;
+  if (!provider) {
+    if (!chainId) throw new Error("Either provider or chainId must be provided");
+    provider = ttVerify.utils.getProvider({ network: utils.SUPPORTED_CHAINS[chainId].name });
+  }
+  const Contract = ethers.getEthersContractFromProvider(provider);
+  const documentStore = new Contract(
+    documentStoreAddress,
+    ttDocumentStoreAbi.TT_DOCUMENT_STORE_ABI,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    provider
+  );
+  switch (role) {
+    case "admin":
+      return await documentStore.DEFAULT_ADMIN_ROLE();
+    case "issuer":
+      return await documentStore.ISSUER_ROLE();
+    case "revoker":
+      return await documentStore.REVOKER_ROLE();
+    default:
+      throw new Error("Invalid role");
+  }
+}, "getRoleString");
+const rolesList = ["admin", "issuer", "revoker"];
+
+exports.getRoleString = getRoleString;
+exports.rolesList = rolesList;

package/dist/cjs/document-store/grant-role.js

@@ -0,0 +1,67 @@
+'use strict';
+
+var core = require('../core');
+var supportInterfaceIds = require('./supportInterfaceIds');
+var ttDocumentStoreAbi = require('./tt-document-store-abi');
+var ethers = require('../utils/ethers');
+var documentStore = require('@trustvc/document-store');
+var utils = require('../token-registry-functions/utils');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const documentStoreGrantRole = /* @__PURE__ */ __name(async (documentStoreAddress, role, account, signer, options = {}) => {
+  if (!documentStoreAddress) throw new Error("Document store address is required");
+  if (!signer.provider) throw new Error("Provider is required");
+  if (!role) throw new Error("Role is required");
+  if (!account) throw new Error("Account is required");
+  const { chainId, maxFeePerGas, maxPriorityFeePerGas, isTransferable } = options;
+  let isDocumentStore = !isTransferable;
+  let isTransferableDocumentStore = isTransferable;
+  let isTTDocumentStore = false;
+  if (isTransferable === void 0) {
+    [isDocumentStore, isTransferableDocumentStore] = await Promise.all([
+      core.checkSupportsInterface(
+        documentStoreAddress,
+        supportInterfaceIds.supportInterfaceIds.IDocumentStore,
+        signer.provider
+      ),
+      core.checkSupportsInterface(
+        documentStoreAddress,
+        supportInterfaceIds.supportInterfaceIds.ITransferableDocumentStore,
+        signer.provider
+      )
+    ]);
+    if (!isDocumentStore && !isTransferableDocumentStore) {
+      isTTDocumentStore = true;
+    }
+  }
+  const Contract = ethers.getEthersContractFromProvider(signer.provider);
+  let documentStoreAbi;
+  if (isTTDocumentStore) {
+    documentStoreAbi = ttDocumentStoreAbi.TT_DOCUMENT_STORE_ABI;
+  } else {
+    const DocumentStoreFactory = isTransferableDocumentStore ? documentStore.TransferableDocumentStore__factory : documentStore.DocumentStore__factory;
+    documentStoreAbi = DocumentStoreFactory.abi;
+  }
+  const documentStoreContract = new Contract(
+    documentStoreAddress,
+    documentStoreAbi,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    signer
+  );
+  try {
+    const isV6 = ethers.isV6EthersProvider(signer.provider);
+    if (isV6) {
+      await documentStoreContract.grantRole.staticCall(role, account);
+    } else {
+      await documentStoreContract.callStatic.grantRole(role, account);
+    }
+  } catch (e) {
+    console.error("callStatic failed:", e);
+    throw new Error("Pre-check (callStatic) for grant-role failed");
+  }
+  const txOptions = await utils.getTxOptions(signer, chainId, maxFeePerGas, maxPriorityFeePerGas);
+  return await documentStoreContract.grantRole(role, account, txOptions);
+}, "documentStoreGrantRole");
+
+exports.documentStoreGrantRole = documentStoreGrantRole;

package/dist/cjs/document-store/index.js

@@ -0,0 +1,49 @@
+'use strict';
+
+var issue = require('./issue');
+var revoke = require('./revoke');
+var revokeRole = require('./revoke-role');
+var grantRole = require('./grant-role');
+var transferOwnership = require('./transferOwnership');
+var deploy = require('./deploy');
+var supportInterfaceIds = require('./supportInterfaceIds');
+var documentStore = require('@trustvc/document-store');
+
+
+
+Object.defineProperty(exports, "documentStoreIssue", {
+  enumerable: true,
+  get: function () { return issue.documentStoreIssue; }
+});
+Object.defineProperty(exports, "documentStoreRevoke", {
+  enumerable: true,
+  get: function () { return revoke.documentStoreRevoke; }
+});
+Object.defineProperty(exports, "documentStoreRevokeRole", {
+  enumerable: true,
+  get: function () { return revokeRole.documentStoreRevokeRole; }
+});
+Object.defineProperty(exports, "documentStoreGrantRole", {
+  enumerable: true,
+  get: function () { return grantRole.documentStoreGrantRole; }
+});
+Object.defineProperty(exports, "documentStoreTransferOwnership", {
+  enumerable: true,
+  get: function () { return transferOwnership.documentStoreTransferOwnership; }
+});
+Object.defineProperty(exports, "deployDocumentStore", {
+  enumerable: true,
+  get: function () { return deploy.deployDocumentStore; }
+});
+Object.defineProperty(exports, "supportInterfaceIds", {
+  enumerable: true,
+  get: function () { return supportInterfaceIds.supportInterfaceIds; }
+});
+Object.defineProperty(exports, "DocumentStore__factory", {
+  enumerable: true,
+  get: function () { return documentStore.DocumentStore__factory; }
+});
+Object.defineProperty(exports, "TransferableDocumentStore__factory", {
+  enumerable: true,
+  get: function () { return documentStore.TransferableDocumentStore__factory; }
+});

package/dist/cjs/document-store/issue.js

@@ -0,0 +1,66 @@
+'use strict';
+
+var documentStore = require('@trustvc/document-store');
+var ethers = require('../utils/ethers');
+var utils = require('../token-registry-functions/utils');
+var core = require('../core');
+var supportInterfaceIds = require('./supportInterfaceIds');
+var ttDocumentStoreAbi = require('./tt-document-store-abi');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const documentStoreIssue = /* @__PURE__ */ __name(async (documentStoreAddress, documentHash, signer, options = {}) => {
+  if (!documentStoreAddress) throw new Error("Document store address is required");
+  if (!signer.provider) throw new Error("Provider is required");
+  if (!documentHash) throw new Error("Document hash is required");
+  const { chainId, maxFeePerGas, maxPriorityFeePerGas, isTransferable } = options;
+  let isDocumentStore = !isTransferable;
+  let isTransferableDocumentStore = isTransferable;
+  let isTTDocumentStore = false;
+  if (isTransferable === void 0) {
+    [isDocumentStore, isTransferableDocumentStore] = await Promise.all([
+      core.checkSupportsInterface(
+        documentStoreAddress,
+        supportInterfaceIds.supportInterfaceIds.IDocumentStore,
+        signer.provider
+      ),
+      core.checkSupportsInterface(
+        documentStoreAddress,
+        supportInterfaceIds.supportInterfaceIds.ITransferableDocumentStore,
+        signer.provider
+      )
+    ]);
+    if (!isDocumentStore && !isTransferableDocumentStore) {
+      isTTDocumentStore = true;
+    }
+  }
+  const Contract = ethers.getEthersContractFromProvider(signer.provider);
+  let documentStoreAbi;
+  if (isTTDocumentStore) {
+    documentStoreAbi = ttDocumentStoreAbi.TT_DOCUMENT_STORE_ABI;
+  } else {
+    const DocumentStoreFactory = isTransferableDocumentStore ? documentStore.TransferableDocumentStore__factory : documentStore.DocumentStore__factory;
+    documentStoreAbi = DocumentStoreFactory.abi;
+  }
+  const documentStoreContract = new Contract(
+    documentStoreAddress,
+    documentStoreAbi,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    signer
+  );
+  try {
+    const isV6 = ethers.isV6EthersProvider(signer.provider);
+    if (isV6) {
+      await documentStoreContract.issue.staticCall(documentHash);
+    } else {
+      await documentStoreContract.callStatic.issue(documentHash);
+    }
+  } catch (e) {
+    console.error("callStatic failed:", e);
+    throw new Error("Pre-check (callStatic) for issue failed");
+  }
+  const txOptions = await utils.getTxOptions(signer, chainId, maxFeePerGas, maxPriorityFeePerGas);
+  return await documentStoreContract.issue(documentHash, txOptions);
+}, "documentStoreIssue");
+
+exports.documentStoreIssue = documentStoreIssue;

package/dist/cjs/document-store/revoke-role.js

@@ -0,0 +1,67 @@
+'use strict';
+
+var core = require('../core');
+var supportInterfaceIds = require('./supportInterfaceIds');
+var ttDocumentStoreAbi = require('./tt-document-store-abi');
+var ethers = require('../utils/ethers');
+var documentStore = require('@trustvc/document-store');
+var utils = require('../token-registry-functions/utils');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const documentStoreRevokeRole = /* @__PURE__ */ __name(async (documentStoreAddress, role, account, signer, options = {}) => {
+  if (!documentStoreAddress) throw new Error("Document store address is required");
+  if (!signer.provider) throw new Error("Provider is required");
+  if (!role) throw new Error("Role is required");
+  if (!account) throw new Error("Account is required");
+  const { chainId, maxFeePerGas, maxPriorityFeePerGas, isTransferable } = options;
+  let isDocumentStore = !isTransferable;
+  let isTransferableDocumentStore = isTransferable;
+  let isTTDocumentStore = false;
+  if (isTransferable === void 0) {
+    [isDocumentStore, isTransferableDocumentStore] = await Promise.all([
+      core.checkSupportsInterface(
+        documentStoreAddress,
+        supportInterfaceIds.supportInterfaceIds.IDocumentStore,
+        signer.provider
+      ),
+      core.checkSupportsInterface(
+        documentStoreAddress,
+        supportInterfaceIds.supportInterfaceIds.ITransferableDocumentStore,
+        signer.provider
+      )
+    ]);
+    if (!isDocumentStore && !isTransferableDocumentStore) {
+      isTTDocumentStore = true;
+    }
+  }
+  const Contract = ethers.getEthersContractFromProvider(signer.provider);
+  let documentStoreAbi;
+  if (isTTDocumentStore) {
+    documentStoreAbi = ttDocumentStoreAbi.TT_DOCUMENT_STORE_ABI;
+  } else {
+    const DocumentStoreFactory = isTransferableDocumentStore ? documentStore.TransferableDocumentStore__factory : documentStore.DocumentStore__factory;
+    documentStoreAbi = DocumentStoreFactory.abi;
+  }
+  const documentStoreContract = new Contract(
+    documentStoreAddress,
+    documentStoreAbi,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    signer
+  );
+  try {
+    const isV6 = ethers.isV6EthersProvider(signer.provider);
+    if (isV6) {
+      await documentStoreContract.revokeRole.staticCall(role, account);
+    } else {
+      await documentStoreContract.callStatic.revokeRole(role, account);
+    }
+  } catch (e) {
+    console.error("callStatic failed:", e);
+    throw new Error("Pre-check (callStatic) for revoke-role failed");
+  }
+  const txOptions = await utils.getTxOptions(signer, chainId, maxFeePerGas, maxPriorityFeePerGas);
+  return await documentStoreContract.revokeRole(role, account, txOptions);
+}, "documentStoreRevokeRole");
+
+exports.documentStoreRevokeRole = documentStoreRevokeRole;

package/dist/cjs/document-store/revoke.js

@@ -0,0 +1,66 @@
+'use strict';
+
+var documentStore = require('@trustvc/document-store');
+var ethers = require('../utils/ethers');
+var utils = require('../token-registry-functions/utils');
+var core = require('../core');
+var supportInterfaceIds = require('./supportInterfaceIds');
+var ttDocumentStoreAbi = require('./tt-document-store-abi');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const documentStoreRevoke = /* @__PURE__ */ __name(async (documentStoreAddress, documentHash, signer, options = {}) => {
+  if (!documentStoreAddress) throw new Error("Document store address is required");
+  if (!signer.provider) throw new Error("Provider is required");
+  if (!documentHash) throw new Error("Document hash is required");
+  const { chainId, maxFeePerGas, maxPriorityFeePerGas, isTransferable } = options;
+  let isDocumentStore = !isTransferable;
+  let isTransferableDocumentStore = isTransferable;
+  let isTTDocumentStore = false;
+  if (isTransferable === void 0) {
+    [isDocumentStore, isTransferableDocumentStore] = await Promise.all([
+      core.checkSupportsInterface(
+        documentStoreAddress,
+        supportInterfaceIds.supportInterfaceIds.IDocumentStore,
+        signer.provider
+      ),
+      core.checkSupportsInterface(
+        documentStoreAddress,
+        supportInterfaceIds.supportInterfaceIds.ITransferableDocumentStore,
+        signer.provider
+      )
+    ]);
+    if (!isDocumentStore && !isTransferableDocumentStore) {
+      isTTDocumentStore = true;
+    }
+  }
+  const Contract = ethers.getEthersContractFromProvider(signer.provider);
+  let documentStoreAbi;
+  if (isTTDocumentStore) {
+    documentStoreAbi = ttDocumentStoreAbi.TT_DOCUMENT_STORE_ABI;
+  } else {
+    const DocumentStoreFactory = isTransferableDocumentStore ? documentStore.TransferableDocumentStore__factory : documentStore.DocumentStore__factory;
+    documentStoreAbi = DocumentStoreFactory.abi;
+  }
+  const documentStoreContract = new Contract(
+    documentStoreAddress,
+    documentStoreAbi,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    signer
+  );
+  try {
+    const isV6 = ethers.isV6EthersProvider(signer.provider);
+    if (isV6) {
+      await documentStoreContract.revoke.staticCall(documentHash);
+    } else {
+      await documentStoreContract.callStatic.revoke(documentHash);
+    }
+  } catch (e) {
+    console.error("callStatic failed:", e);
+    throw new Error("Pre-check (callStatic) for revoke failed");
+  }
+  const txOptions = await utils.getTxOptions(signer, chainId, maxFeePerGas, maxPriorityFeePerGas);
+  return await documentStoreContract.revoke(documentHash, txOptions);
+}, "documentStoreRevoke");
+
+exports.documentStoreRevoke = documentStoreRevoke;

package/dist/cjs/document-store/supportInterfaceIds.js

@@ -0,0 +1,22 @@
+'use strict';
+
+var tokenRegistryV5 = require('@tradetrust-tt/token-registry-v5');
+var contractInterfaces = require('./contract-interfaces');
+
+const { computeInterfaceId } = tokenRegistryV5.utils;
+const supportInterfaceIds = {
+  /**
+   * IDocumentStore interface ID
+   * Functions: isActive, isIssued, isRevoked, name, revoke
+   * Computed: 0xb9391097
+   */
+  IDocumentStore: computeInterfaceId(contractInterfaces.contractInterfaces.DocumentStore),
+  /**
+   * ITransferableDocumentStore interface ID
+   * Functions: isActive, isIssued, isRevoked, issue, name, revoke
+   * Computed: 0xc2cb4227
+   */
+  ITransferableDocumentStore: computeInterfaceId(contractInterfaces.contractInterfaces.TransferableDocumentStore)
+};
+
+exports.supportInterfaceIds = supportInterfaceIds;