@trustvc/trustvc 2.9.1 → 2.11.0

package/dist/cjs/index.js

@@ -3,6 +3,7 @@
 var tokenRegistryV4 = require('./token-registry-v4');
 var tokenRegistryV5 = require('./token-registry-v5');
 var documentStore = require('./document-store');
+var transaction = require('./transaction');
 var tokenRegistryFunctions = require('./token-registry-functions');
 var core = require('./core');
 var openAttestation = require('./open-attestation');
@@ -118,6 +119,16 @@ Object.defineProperty(exports, "getRoleString", {
   enumerable: true,
   get: function () { return documentStore.getRoleString; }
 });
+Object.defineProperty(exports, "cancelTransaction", {
+  enumerable: true,
+  get: function () { return transaction.cancelTransaction; }
+});
+Object.keys(transaction).forEach(function (k) {
+  if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+    enumerable: true,
+    get: function () { return transaction[k]; }
+  });
+});
 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;

package/dist/cjs/transaction/cancel.js

@@ -0,0 +1,57 @@
+'use strict';
+
+var ethers = require('ethers');
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const GAS_PRICE_SCALE_WHEN_FROM_HASH = 2;
+const cancelTransaction = /* @__PURE__ */ __name(async (signer, options) => {
+  if (!signer.provider) {
+    throw new Error("Provider is required on signer");
+  }
+  const { nonce, gasPrice, transactionHash } = options;
+  let transactionNonce = nonce;
+  let transactionGasPrice = gasPrice;
+  if (transactionHash) {
+    if (typeof signer.provider.getTransaction !== "function") {
+      throw new Error("Provider does not support getTransaction");
+    }
+    const tx = await signer.provider.getTransaction(transactionHash);
+    if (!tx) {
+      throw new Error(`Transaction not found: ${transactionHash}`);
+    }
+    const txNonce = tx.nonce;
+    const txGasPrice = tx.gasPrice;
+    if (txGasPrice == null) {
+      throw new Error(
+        "Transaction uses EIP-1559 (no gasPrice). Cancel by providing --nonce and --gas-price explicitly."
+      );
+    }
+    transactionNonce = String(txNonce);
+    const scaled = typeof txGasPrice === "bigint" ? txGasPrice * BigInt(GAS_PRICE_SCALE_WHEN_FROM_HASH) : ethers.BigNumber.from(txGasPrice).mul(GAS_PRICE_SCALE_WHEN_FROM_HASH);
+    transactionGasPrice = String(scaled);
+  }
+  if (!transactionNonce || !transactionGasPrice) {
+    throw new Error(
+      "Provide either (--nonce and --gas-price) or --transaction-hash to cancel the pending transaction"
+    );
+  }
+  const address = await signer.getAddress();
+  if (!/^\d+$/.test(transactionNonce)) {
+    throw new Error("Invalid nonce: expected a non-negative integer");
+  }
+  if (!/^\d+$/.test(transactionGasPrice) || transactionGasPrice === "0") {
+    throw new Error("Invalid gasPrice: expected a positive integer string in wei");
+  }
+  const nonceNum = Number(transactionNonce);
+  const txResponse = await signer.sendTransaction({
+    to: address,
+    value: 0,
+    nonce: nonceNum,
+    gasPrice: transactionGasPrice,
+    gasLimit: 21e3
+  });
+  return txResponse.hash;
+}, "cancelTransaction");
+
+exports.cancelTransaction = cancelTransaction;

package/dist/cjs/transaction/index.js

@@ -0,0 +1,10 @@
+'use strict';
+
+var cancel = require('./cancel');
+
+
+
+Object.defineProperty(exports, "cancelTransaction", {
+  enumerable: true,
+  get: function () { return cancel.cancelTransaction; }
+});