@trustvc/trustvc 2.9.0 → 2.10.0

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

@@ -21,18 +21,12 @@ const getRoleString = /* @__PURE__ */ __name(async (documentStoreAddress, role,
     // 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");
+  if (typeof documentStore[role] !== "function") {
+    throw new Error(`Invalid role: ${role}`);
   }
+  return await documentStore[role]();
 }, "getRoleString");
-const rolesList = ["admin", "issuer", "revoker"];
+const rolesList = ["DEFAULT_ADMIN_ROLE", "ISSUER_ROLE", "REVOKER_ROLE"];
 
 exports.getRoleString = getRoleString;
 exports.rolesList = rolesList;

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

@@ -6,6 +6,7 @@ var revokeRole = require('./revoke-role');
 var grantRole = require('./grant-role');
 var transferOwnership = require('./transferOwnership');
 var documentStore$1 = require('../deploy/document-store');
+var documentStoreRoles = require('./document-store-roles');
 var supportInterfaceIds = require('./supportInterfaceIds');
 var documentStore = require('@trustvc/document-store');
 
@@ -35,6 +36,10 @@ Object.defineProperty(exports, "deployDocumentStore", {
   enumerable: true,
   get: function () { return documentStore$1.deployDocumentStore; }
 });
+Object.defineProperty(exports, "getRoleString", {
+  enumerable: true,
+  get: function () { return documentStoreRoles.getRoleString; }
+});
 Object.defineProperty(exports, "supportInterfaceIds", {
   enumerable: true,
   get: function () { return supportInterfaceIds.supportInterfaceIds; }

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

@@ -3,6 +3,11 @@
 var revokeRole = require('./revoke-role');
 var grantRole = require('./grant-role');
 var documentStoreRoles = require('./document-store-roles');
+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 __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
@@ -11,29 +16,72 @@ const documentStoreTransferOwnership = /* @__PURE__ */ __name(async (documentSto
   if (!signer.provider) throw new Error("Provider is required");
   if (!account) throw new Error("Account is required");
   const ownerAddress = await signer.getAddress();
-  const roleString = await documentStoreRoles.getRoleString(documentStoreAddress, "admin", {
+  const roleString = await documentStoreRoles.getRoleString(documentStoreAddress, "DEFAULT_ADMIN_ROLE", {
     provider: signer.provider
   });
-  const grantTransaction = grantRole.documentStoreGrantRole(
+  const Contract = ethers.getEthersContractFromProvider(signer.provider);
+  const isDocumentStore = await core.checkSupportsInterface(
+    documentStoreAddress,
+    supportInterfaceIds.supportInterfaceIds.IDocumentStore,
+    signer.provider
+  );
+  const isTransferableDocumentStore = await core.checkSupportsInterface(
+    documentStoreAddress,
+    supportInterfaceIds.supportInterfaceIds.ITransferableDocumentStore,
+    signer.provider
+  );
+  let documentStoreAbi;
+  if (isDocumentStore || isTransferableDocumentStore) {
+    const DocumentStoreFactory = isTransferableDocumentStore ? documentStore.TransferableDocumentStore__factory : documentStore.DocumentStore__factory;
+    documentStoreAbi = DocumentStoreFactory.abi;
+  } else {
+    documentStoreAbi = ttDocumentStoreAbi.TT_DOCUMENT_STORE_ABI;
+  }
+  const documentStoreContract = new Contract(
+    documentStoreAddress,
+    documentStoreAbi,
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    signer
+  );
+  const isV6 = ethers.isV6EthersProvider(signer.provider);
+  try {
+    if (isV6) {
+      await documentStoreContract.grantRole.staticCall(roleString, account);
+    } else {
+      await documentStoreContract.callStatic.grantRole(roleString, account);
+    }
+  } catch (e) {
+    console.error("callStatic failed:", e);
+    throw new Error("Pre-check (callStatic) for grant-role failed");
+  }
+  try {
+    if (isV6) {
+      await documentStoreContract.revokeRole.staticCall(roleString, ownerAddress);
+    } else {
+      await documentStoreContract.callStatic.revokeRole(roleString, ownerAddress);
+    }
+  } catch (e) {
+    console.error("callStatic failed:", e);
+    throw new Error("Pre-check (callStatic) for revoke-role failed");
+  }
+  const grantTransaction = await grantRole.documentStoreGrantRole(
     documentStoreAddress,
     roleString,
     account,
     signer,
     options
   );
-  const grantTransactionResult = await grantTransaction;
-  if (!grantTransactionResult) {
+  if (!grantTransaction) {
     throw new Error("Grant transaction failed, not proceeding with revoke transaction");
   }
-  const revokeTransaction = revokeRole.documentStoreRevokeRole(
+  const revokeTransaction = await revokeRole.documentStoreRevokeRole(
     documentStoreAddress,
     roleString,
     ownerAddress,
     signer,
     options
   );
-  const revokeTransactionResult = await revokeTransaction;
-  if (!revokeTransactionResult) {
+  if (!revokeTransaction) {
     throw new Error("Revoke transaction failed");
   }
   return { grantTransaction, revokeTransaction };

package/dist/cjs/index.js

@@ -110,6 +110,14 @@ Object.defineProperty(exports, "documentStoreRevokeRole", {
   enumerable: true,
   get: function () { return documentStore.documentStoreRevokeRole; }
 });
+Object.defineProperty(exports, "documentStoreTransferOwnership", {
+  enumerable: true,
+  get: function () { return documentStore.documentStoreTransferOwnership; }
+});
+Object.defineProperty(exports, "getRoleString", {
+  enumerable: true,
+  get: function () { return documentStore.getRoleString; }
+});
 Object.keys(tokenRegistryFunctions).forEach(function (k) {
   if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
     enumerable: true,

package/dist/cjs/open-attestation/decrypt.js

@@ -0,0 +1,34 @@
+'use strict';
+
+var forge = require('node-forge');
+var utils = require('./utils');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var forge__default = /*#__PURE__*/_interopDefault(forge);
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const decryptString = /* @__PURE__ */ __name(({ cipherText, tag, iv, key, type }) => {
+  if (type !== utils.ENCRYPTION_PARAMETERS.version) {
+    throw new Error(`Expecting version ${utils.ENCRYPTION_PARAMETERS.version} but got ${type}`);
+  }
+  const keyBytestring = forge__default.default.util.hexToBytes(key);
+  const cipherTextBytestring = forge__default.default.util.decode64(cipherText);
+  const ivBytestring = forge__default.default.util.decode64(iv);
+  const tagBytestring = forge__default.default.util.decode64(tag);
+  const decipher = forge__default.default.cipher.createDecipher("AES-GCM", keyBytestring);
+  decipher.start({
+    iv: ivBytestring,
+    tagLength: utils.ENCRYPTION_PARAMETERS.tagLength,
+    tag: forge__default.default.util.createBuffer(tagBytestring, "raw")
+  });
+  decipher.update(forge__default.default.util.createBuffer(cipherTextBytestring, "raw"));
+  const success = decipher.finish();
+  if (!success) {
+    throw new Error("Error decrypting message");
+  }
+  return utils.decodeDocument(decipher.output.data);
+}, "decryptString");
+
+exports.decryptString = decryptString;

package/dist/cjs/open-attestation/encrypt.js

@@ -0,0 +1,47 @@
+'use strict';
+
+var forge = require('node-forge');
+var utils = require('./utils');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var forge__default = /*#__PURE__*/_interopDefault(forge);
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const generateIv = /* @__PURE__ */ __name((ivLengthInBits = utils.ENCRYPTION_PARAMETERS.ivLength) => {
+  const iv = forge__default.default.random.getBytesSync(ivLengthInBits / 8);
+  return forge__default.default.util.encode64(iv);
+}, "generateIv");
+const makeCipher = /* @__PURE__ */ __name((encryptionKey = utils.generateEncryptionKey()) => {
+  const iv = generateIv();
+  const cipher = forge__default.default.cipher.createCipher(
+    utils.ENCRYPTION_PARAMETERS.algorithm,
+    forge__default.default.util.hexToBytes(encryptionKey)
+  );
+  cipher.start({
+    iv: forge__default.default.util.decode64(iv),
+    tagLength: utils.ENCRYPTION_PARAMETERS.tagLength
+  });
+  return { cipher, encryptionKey, iv };
+}, "makeCipher");
+const encryptString = /* @__PURE__ */ __name((document, key) => {
+  if (typeof document !== "string") {
+    throw new Error("encryptString only accepts strings");
+  }
+  const { cipher, encryptionKey, iv } = makeCipher(key);
+  const buffer = forge__default.default.util.createBuffer(utils.encodeDocument(document));
+  cipher.update(buffer);
+  cipher.finish();
+  const encryptedMessage = forge__default.default.util.encode64(cipher.output.data);
+  const tag = forge__default.default.util.encode64(cipher.mode.tag.data);
+  return {
+    cipherText: encryptedMessage,
+    iv,
+    tag,
+    key: encryptionKey,
+    type: utils.ENCRYPTION_PARAMETERS.version
+  };
+}, "encryptString");
+
+exports.encryptString = encryptString;

package/dist/cjs/open-attestation/index.js

@@ -5,36 +5,46 @@ var types = require('./types');
 var utils = require('./utils');
 var verify = require('./verify');
 var wrap = require('./wrap');
+var encrypt = require('./encrypt');
+var decrypt = require('./decrypt');
 
 
 
+Object.defineProperty(exports, "encryptString", {
+  enumerable: true,
+  get: function () { return encrypt.encryptString; }
+});
+Object.defineProperty(exports, "decryptString", {
+  enumerable: true,
+  get: function () { return decrypt.decryptString; }
+});
 Object.keys(sign).forEach(function (k) {
-	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-		enumerable: true,
-		get: function () { return sign[k]; }
-	});
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return sign[k]; }
+  });
 });
 Object.keys(types).forEach(function (k) {
-	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-		enumerable: true,
-		get: function () { return types[k]; }
-	});
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return types[k]; }
+  });
 });
 Object.keys(utils).forEach(function (k) {
-	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-		enumerable: true,
-		get: function () { return utils[k]; }
-	});
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return utils[k]; }
+  });
 });
 Object.keys(verify).forEach(function (k) {
-	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-		enumerable: true,
-		get: function () { return verify[k]; }
-	});
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return verify[k]; }
+  });
 });
 Object.keys(wrap).forEach(function (k) {
-	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-		enumerable: true,
-		get: function () { return wrap[k]; }
-	});
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return wrap[k]; }
+  });
 });

package/dist/cjs/open-attestation/utils.js

@@ -1,7 +1,46 @@
 'use strict';
 
+var forge = require('node-forge');
 var tradetrust = require('@tradetrust-tt/tradetrust');
 
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var forge__default = /*#__PURE__*/_interopDefault(forge);
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const ENCRYPTION_PARAMETERS = Object.freeze({
+  algorithm: "AES-GCM",
+  keyLength: 256,
+  // Key length in bits
+  ivLength: 96,
+  // IV length in bits: NIST suggests 12 bytes
+  tagLength: 128,
+  // GCM authentication tag length in bits, see link above for explanation
+  version: "OPEN-ATTESTATION-TYPE-1"
+  // Type 1 using the above params without compression
+});
+const generateEncryptionKey = /* @__PURE__ */ __name((keyLengthInBits = ENCRYPTION_PARAMETERS.keyLength) => {
+  if (!Number.isInteger(keyLengthInBits) || ![128, 192, 256].includes(keyLengthInBits)) {
+    throw new Error("keyLengthInBits must be one of 128, 192, or 256");
+  }
+  const encryptionKey = forge__default.default.random.getBytesSync(keyLengthInBits / 8);
+  return forge__default.default.util.bytesToHex(encryptionKey);
+}, "generateEncryptionKey");
+const encodeDocument = /* @__PURE__ */ __name((document) => {
+  const bytes = forge__default.default.util.encodeUtf8(document);
+  const standard = forge__default.default.util.encode64(bytes);
+  const s = standard.replace(/\+/g, "-").replace(/\//g, "_");
+  const trim = s.endsWith("==") ? 2 : s.endsWith("=") ? 1 : 0;
+  return trim ? s.slice(0, -trim) : s;
+}, "encodeDocument");
+const decodeDocument = /* @__PURE__ */ __name((encoded) => {
+  let normalized = encoded.replace(/-/g, "+").replace(/_/g, "/");
+  const pad = normalized.length % 4;
+  if (pad) normalized += "=".repeat(4 - pad);
+  const decoded = forge__default.default.util.decode64(normalized);
+  return forge__default.default.util.decodeUtf8(decoded);
+}, "decodeDocument");
 const {
   isTransferableAsset,
   isDocumentRevokable,
@@ -42,7 +81,11 @@ Object.defineProperty(exports, "validateSchema", {
   enumerable: true,
   get: function () { return tradetrust.validateSchema; }
 });
+exports.ENCRYPTION_PARAMETERS = ENCRYPTION_PARAMETERS;
+exports.decodeDocument = decodeDocument;
 exports.diagnose = diagnose;
+exports.encodeDocument = encodeDocument;
+exports.generateEncryptionKey = generateEncryptionKey;
 exports.getAssetId = getAssetId;
 exports.getDocumentData = getDocumentData;
 exports.getIssuerAddress = getIssuerAddress;