@trustvc/trustvc 2.4.2 → 2.5.1

package/dist/cjs/token-registry-functions/utils.js

@@ -1,14 +1,14 @@
 'use strict';
 
 var ethers = require('../utils/ethers');
-var tradetrustUtils = require('@tradetrust-tt/tradetrust-utils');
+var utils = require('../utils');
 
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
 const getTxOptions = /* @__PURE__ */ __name(async (signer, chainId, maxFeePerGas, maxPriorityFeePerGas) => {
   if (!maxFeePerGas || !maxPriorityFeePerGas) {
     chainId = chainId ?? await getChainIdSafe(signer);
-    const gasStation = tradetrustUtils.SUPPORTED_CHAINS[chainId]?.gasStation;
+    const gasStation = utils.SUPPORTED_CHAINS[chainId]?.gasStation;
     if (gasStation) {
       const gasFees = await gasStation();
       maxFeePerGas = gasFees?.maxFeePerGas ?? 0;

package/dist/cjs/utils/analytics/analytics.js

@@ -0,0 +1,45 @@
+'use strict';
+
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const validateGtag = /* @__PURE__ */ __name(() => {
+  const isInit = typeof gtag === "function";
+  if (!isInit) console.warn("gtag is not initialised");
+  return isInit;
+}, "validateGtag");
+const validatePageViewEvent = /* @__PURE__ */ __name((gaEvent2) => {
+  const { action } = gaEvent2;
+  if (!action) console.error("Action is required");
+  if (action && typeof action !== "string") console.error("Action must be a string");
+}, "validatePageViewEvent");
+const gaPageView = /* @__PURE__ */ __name((gaEvent2, gaId) => {
+  if (!validateGtag()) return;
+  validatePageViewEvent(gaEvent2);
+  const { action } = gaEvent2;
+  gtag("event", action, {
+    send_to: gaId
+  });
+}, "gaPageView");
+const validateGaEvent = /* @__PURE__ */ __name((gaEvent2) => {
+  const { action, category, label, value } = gaEvent2;
+  if (!category) console.error("Category is required");
+  if (!action) console.error("Action is required");
+  if (label && typeof label !== "string") console.error("Label must be a string");
+  if (value && typeof value !== "number") console.error("Value must be a number");
+}, "validateGaEvent");
+const gaEvent = /* @__PURE__ */ __name((gaEvent2) => {
+  if (!validateGtag()) return;
+  validateGaEvent(gaEvent2);
+  const { action, category, label, value } = gaEvent2;
+  gtag("event", action, {
+    event_category: category,
+    event_label: label,
+    value
+  });
+}, "gaEvent");
+
+exports.gaEvent = gaEvent;
+exports.gaPageView = gaPageView;
+exports.validateGaEvent = validateGaEvent;
+exports.validateGtag = validateGtag;
+exports.validatePageViewEvent = validatePageViewEvent;

package/dist/cjs/utils/analytics/index.js

@@ -0,0 +1,12 @@
+'use strict';
+
+var analytics = require('./analytics');
+
+
+
+Object.keys(analytics).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return analytics[k]; }
+	});
+});

package/dist/cjs/utils/errorMessages/VerificationErrorMessages.js

@@ -0,0 +1,105 @@
+'use strict';
+
+const TYPES = {
+  REVOKED: "REVOKED",
+  SUSPENDED: "SUSPENDED",
+  ISSUED: "ISSUED",
+  HASH: "HASH",
+  IDENTITY: "IDENTITY",
+  INVALID: "INVALID",
+  ADDRESS_INVALID: "ADDRESS_INVALID",
+  NETWORK_INVALID: "NETWORK_INVALID",
+  NETWORK_MISMATCH_MAINNET: "NETWORK_MISMATCH_MAINNET",
+  NETWORK_MISMATCH_TESTNET: "NETWORK_MISMATCH_TESTNET",
+  CONTRACT_NOT_FOUND: "CONTRACT_NOT_FOUND",
+  INVALID_ARGUMENT: "INVALID_ARGUMENT",
+  SERVER_ERROR: "SERVER_ERROR",
+  ETHERS_UNHANDLED_ERROR: "ETHERS_UNHANDLED_ERROR",
+  CLIENT_NETWORK_ERROR: "CLIENT_NETWORK_ERROR",
+  VERIFICATION_ERROR: "VERIFICATION_ERROR"
+};
+const MESSAGES = {
+  [TYPES.REVOKED]: {
+    failureTitle: "Document revoked",
+    successTitle: "Document has not been revoked",
+    failureMessage: "This document has been revoked by the issuing authority. Please contact them for more details."
+  },
+  [TYPES.SUSPENDED]: {
+    failureTitle: "Document suspended",
+    successTitle: "Document has not been suspended",
+    failureMessage: "This document has been suspended by the issuing authority. Please contact them for more details."
+  },
+  [TYPES.ISSUED]: {
+    failureTitle: "Document not issued",
+    successTitle: "Document has been issued",
+    failureMessage: "This document cannot be found. Please contact your issuing authority for help or issue the document before trying again."
+  },
+  [TYPES.HASH]: {
+    failureTitle: "Document has been tampered with",
+    successTitle: "Document has not been tampered with",
+    failureMessage: "The contents of this document are inaccurate and have been tampered with."
+  },
+  [TYPES.IDENTITY]: {
+    failureTitle: "Document issuer identity is invalid",
+    successTitle: "Document issuer has been identified",
+    failureMessage: "This document was issued by an invalid issuer."
+  },
+  [TYPES.INVALID]: {
+    failureTitle: "Document is invalid",
+    successTitle: "",
+    failureMessage: "This document is not valid. Please upload a valid document."
+  },
+  [TYPES.ADDRESS_INVALID]: {
+    failureTitle: "Document store or Token registry address is invalid",
+    successTitle: "",
+    failureMessage: "Please inform the issuer of this document that they have misconfigured their Document store or Token registry address."
+  },
+  [TYPES.NETWORK_INVALID]: {
+    failureTitle: "Document's network field is invalid",
+    successTitle: "",
+    failureMessage: "This document has an invalid network field. Please contact your issuing authority for help or re-issue the document with a valid network field before trying again."
+  },
+  [TYPES.NETWORK_MISMATCH_MAINNET]: {
+    failureTitle: "Document network mismatch on mainnet",
+    successTitle: "",
+    failureMessage: "This document was issued on the testnet, but you are currently using the mainnet environment. Please switch to the testnet environment to view this document correctly, or contact the issuing authority if you believe this is incorrect."
+  },
+  [TYPES.NETWORK_MISMATCH_TESTNET]: {
+    failureTitle: "Document network mismatch on testnet",
+    successTitle: "",
+    failureMessage: "This document was issued on the mainnet, but you are currently using the testnet environment. Please switch to the mainnet environment to view this document correctly, or contact the issuing authority if you believe this is incorrect."
+  },
+  [TYPES.CONTRACT_NOT_FOUND]: {
+    failureTitle: "Document store or Token registry address cannot be found",
+    successTitle: "",
+    failureMessage: "Please inform the issuer of this document that they have misconfigured their Document store or Token registry address."
+  },
+  [TYPES.INVALID_ARGUMENT]: {
+    failureTitle: "Document's merkle root is invalid",
+    successTitle: "",
+    failureMessage: "Please inform the issuer of this document that the merkle root is invalid, or it may have been tampered with."
+  },
+  [TYPES.SERVER_ERROR]: {
+    failureTitle: "Unable to connect to the blockchain network",
+    successTitle: "",
+    failureMessage: "We are unable to connect to the blockchain network, please try again later. If this issue persists, contact us using the feedback link below."
+  },
+  [TYPES.ETHERS_UNHANDLED_ERROR]: {
+    failureTitle: "Whoops! It's not you, it's us",
+    successTitle: "",
+    failureMessage: "We encountered an internal error and cannot determine the cause, please try again later. If this issue persists, contact us using the feedback link below."
+  },
+  [TYPES.CLIENT_NETWORK_ERROR]: {
+    failureTitle: "Whoops! There seems to be an error verifying the document",
+    successTitle: "",
+    failureMessage: "Please check your network and try again"
+  },
+  [TYPES.VERIFICATION_ERROR]: {
+    failureTitle: "Document Verification Failed",
+    successTitle: "",
+    failureMessage: "The document could not be verified at the moment. Please try again."
+  }
+};
+
+exports.MESSAGES = MESSAGES;
+exports.TYPES = TYPES;

package/dist/cjs/utils/errorMessages/index.js

@@ -1,9 +1,29 @@
 'use strict';
 
-var tradetrustUtils = require('@tradetrust-tt/tradetrust-utils');
+var CONSTANTS = require('./VerificationErrorMessages');
 var types = require('./types');
 
-const errorMessages = tradetrustUtils.CONSTANTS;
+function _interopNamespace(e) {
+  if (e && e.__esModule) return e;
+  var n = Object.create(null);
+  if (e) {
+    Object.keys(e).forEach(function (k) {
+      if (k !== 'default') {
+        var d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: function () { return e[k]; }
+        });
+      }
+    });
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+
+var CONSTANTS__namespace = /*#__PURE__*/_interopNamespace(CONSTANTS);
+
+const errorMessages = CONSTANTS__namespace;
 
 exports.errorMessages = errorMessages;
 Object.keys(types).forEach(function (k) {

package/dist/cjs/utils/fragment/index.js

@@ -1,11 +1,50 @@
 'use strict';
 
-var tradetrustUtils = require('@tradetrust-tt/tradetrust-utils');
 var ttVerify = require('@tradetrust-tt/tt-verify');
 var w3cCredentialStatus = require('../../verify/fragments/document-status/w3cCredentialStatus');
+var VerificationErrorMessages = require('../errorMessages/VerificationErrorMessages');
+var errorMessages = require('../errorMessages');
 
 var __defProp = Object.defineProperty;
 var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const certificateRevokedOnDidIdentified = /* @__PURE__ */ __name((fragments) => {
+  const didSignedDocumentStatusFragment = ttVerify.utils.getOpenAttestationDidSignedDocumentStatusFragment(fragments);
+  return didSignedDocumentStatusFragment?.reason?.code === ttVerify.OpenAttestationEthereumDocumentStoreStatusCode.DOCUMENT_REVOKED;
+}, "certificateRevokedOnDidIdentified");
+const interpretFragments = /* @__PURE__ */ __name((fragments) => {
+  const hashValid = ttVerify.isValid(fragments, ["DOCUMENT_INTEGRITY"]);
+  const issuedValid = ttVerify.isValid(fragments, ["DOCUMENT_STATUS"]);
+  const identityValid = ttVerify.isValid(fragments, ["ISSUER_IDENTITY"]);
+  return { hashValid, issuedValid, identityValid };
+}, "interpretFragments");
+const OAErrorMessageHandling = /* @__PURE__ */ __name((fragments) => {
+  const { hashValid, issuedValid, identityValid } = interpretFragments(fragments);
+  const errors = [];
+  if (ttVerify.utils.isDocumentStoreAddressOrTokenRegistryAddressInvalid(fragments)) {
+    return [VerificationErrorMessages.TYPES.ADDRESS_INVALID];
+  }
+  if (ttVerify.utils.contractNotFound(fragments)) {
+    return [VerificationErrorMessages.TYPES.CONTRACT_NOT_FOUND];
+  }
+  if (ttVerify.utils.serverError(fragments)) {
+    return [VerificationErrorMessages.TYPES.SERVER_ERROR];
+  }
+  if (!hashValid) errors.push(VerificationErrorMessages.TYPES.HASH);
+  if (!identityValid) errors.push(VerificationErrorMessages.TYPES.IDENTITY);
+  if (!issuedValid) {
+    if (ttVerify.utils.certificateRevoked(fragments) || certificateRevokedOnDidIdentified(fragments))
+      errors.push(VerificationErrorMessages.TYPES.REVOKED);
+    else if (ttVerify.utils.invalidArgument(fragments)) {
+      errors.push(VerificationErrorMessages.TYPES.INVALID_ARGUMENT);
+    } else if (ttVerify.utils.certificateNotIssued(fragments)) errors.push(VerificationErrorMessages.TYPES.ISSUED);
+    else if (!hashValid && !identityValid) {
+      return [VerificationErrorMessages.TYPES.INVALID];
+    } else {
+      return [VerificationErrorMessages.TYPES.ETHERS_UNHANDLED_ERROR];
+    }
+  }
+  return errors;
+}, "OAErrorMessageHandling");
 const getW3CCredentialStatusFragment = ttVerify.utils.getFragmentByName(
   "W3CCredentialStatus"
 );
@@ -18,7 +57,7 @@ const w3cCredentialStatusSuspended = /* @__PURE__ */ __name((fragments) => {
   return issuedFragment?.reason?.code === w3cCredentialStatus.W3CCredentialStatusCode.DOCUMENT_SUSPENDED || issuedFragment?.reason?.code === w3cCredentialStatus.W3CCredentialStatusCode.DOCUMENT_REVOKED_AND_SUSPENDED;
 }, "w3cCredentialStatusSuspended");
 const errorMessageHandling = /* @__PURE__ */ __name((fragments) => {
-  const { hashValid, issuedValid, identityValid } = tradetrustUtils.interpretFragments(fragments);
+  const { hashValid, issuedValid, identityValid } = interpretFragments(fragments);
   const errors = [];
   const isW3cFragments = fragments.some(
     (f) => f.name.startsWith("W3C") || f.name === "TransferableRecords"
@@ -26,29 +65,27 @@ const errorMessageHandling = /* @__PURE__ */ __name((fragments) => {
   if (isW3cFragments) {
     switch (true) {
       case w3cCredentialStatusRevoked(fragments):
-        errors.push(tradetrustUtils.CONSTANTS.TYPES.REVOKED);
+        errors.push(errorMessages.errorMessages.TYPES.REVOKED);
         break;
       case w3cCredentialStatusSuspended(fragments):
-        errors.push(tradetrustUtils.CONSTANTS.TYPES.SUSPENDED);
+        errors.push(errorMessages.errorMessages.TYPES.SUSPENDED);
         break;
       case !hashValid:
-        errors.push(tradetrustUtils.CONSTANTS.TYPES.HASH);
+        errors.push(errorMessages.errorMessages.TYPES.HASH);
         break;
       case !identityValid:
-        errors.push(tradetrustUtils.CONSTANTS.TYPES.IDENTITY);
+        errors.push(errorMessages.errorMessages.TYPES.IDENTITY);
         break;
       case !issuedValid:
-        errors.push(tradetrustUtils.CONSTANTS.TYPES.INVALID);
+        errors.push(errorMessages.errorMessages.TYPES.INVALID);
         break;
     }
     return errors;
-  } else return tradetrustUtils.errorMessageHandling(fragments);
+  } else return OAErrorMessageHandling(fragments);
 }, "errorMessageHandling");
 
-Object.defineProperty(exports, "interpretFragments", {
-  enumerable: true,
-  get: function () { return tradetrustUtils.interpretFragments; }
-});
+exports.OAErrorMessageHandling = OAErrorMessageHandling;
 exports.errorMessageHandling = errorMessageHandling;
+exports.interpretFragments = interpretFragments;
 exports.w3cCredentialStatusRevoked = w3cCredentialStatusRevoked;
 exports.w3cCredentialStatusSuspended = w3cCredentialStatusSuspended;

package/dist/cjs/utils/gasStation/index.js

@@ -1,18 +1,70 @@
 'use strict';
 
-var tradetrustUtils = require('@tradetrust-tt/tradetrust-utils');
+var ethers = require('ethers');
+var fetch = require('node-fetch');
 
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
 
+var fetch__default = /*#__PURE__*/_interopDefault(fetch);
 
-Object.defineProperty(exports, "calculateMaxFee", {
-  enumerable: true,
-  get: function () { return tradetrustUtils.calculateMaxFee; }
-});
-Object.defineProperty(exports, "gasStation", {
-  enumerable: true,
-  get: function () { return tradetrustUtils.gasStation; }
-});
-Object.defineProperty(exports, "scaleBigNumber", {
-  enumerable: true,
-  get: function () { return tradetrustUtils.scaleBigNumber; }
-});
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+const gasStation = /* @__PURE__ */ __name((gasStationUrl) => async () => {
+  try {
+    if (!gasStationUrl) return void 0;
+    const res = await fetch__default.default(gasStationUrl);
+    const data = await res.json();
+    return {
+      maxPriorityFeePerGas: safeParseUnits(data.standard.maxPriorityFee.toString(), 9),
+      maxFeePerGas: safeParseUnits(data.standard.maxFee.toString(), 9)
+    };
+  } catch {
+    throw new Error("Failed to fetch gas station");
+  }
+}, "gasStation");
+const safeParseUnits = /* @__PURE__ */ __name((_value, decimals) => {
+  const value = String(_value);
+  if (!value.match(/^[0-9.]+$/)) {
+    throw new Error(`invalid gwei value: ${_value}`);
+  }
+  const comps = value.split(".");
+  if (comps.length === 1) {
+    comps.push("");
+  }
+  if (comps.length !== 2) {
+    throw new Error(`invalid gwei value: ${_value}`);
+  }
+  while (comps[1].length < decimals) {
+    comps[1] += "0";
+  }
+  if (comps[1].length > 9 && !comps[1].substring(9).match(/^0+$/)) {
+    comps[1] = ethers.BigNumber.from(comps[1].substring(0, 9)).add(ethers.BigNumber.from(1)).toString();
+  }
+  return ethers.ethers.utils.parseUnits(`${comps[0]}.${comps[1]}`, decimals);
+}, "safeParseUnits");
+const scaleBigNumber = /* @__PURE__ */ __name((wei, multiplier, precision = 2) => {
+  if (wei === null || typeof wei === "undefined") {
+    throw new Error("Wei not specified");
+  }
+  const padding = Math.pow(10, precision);
+  const newMultiplier = Math.round(padding * multiplier);
+  const newWei = wei.mul(newMultiplier).div(padding);
+  return newWei;
+}, "scaleBigNumber");
+const calculateMaxFee = /* @__PURE__ */ __name((maxFee, priorityFee, scale) => {
+  if (maxFee === null || typeof maxFee === "undefined") {
+    throw new Error("Max Fee not specified");
+  }
+  if (priorityFee === null || typeof priorityFee === "undefined") {
+    throw new Error("Priority Fee not specified");
+  }
+  if (scale === 1) {
+    return maxFee;
+  }
+  const priorityFeeChange = scaleBigNumber(priorityFee, scale).sub(priorityFee);
+  return maxFee.add(priorityFeeChange);
+}, "calculateMaxFee");
+
+exports.calculateMaxFee = calculateMaxFee;
+exports.gasStation = gasStation;
+exports.scaleBigNumber = scaleBigNumber;

package/dist/cjs/utils/index.js

@@ -8,6 +8,7 @@ var errorMessages = require('./errorMessages');
 var documents = require('./documents');
 var gasStation = require('./gasStation');
 var awsKmsSigner = require('./aws-kms-signer');
+var analytics = require('./analytics');
 
 
 
@@ -59,3 +60,9 @@ Object.keys(awsKmsSigner).forEach(function (k) {
 		get: function () { return awsKmsSigner[k]; }
 	});
 });
+Object.keys(analytics).forEach(function (k) {
+	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
+		enumerable: true,
+		get: function () { return analytics[k]; }
+	});
+});

package/dist/cjs/utils/network/index.js

@@ -1,12 +1,18 @@
 'use strict';
 
-var network = require('@tradetrust-tt/tradetrust-utils/constants/network');
+const networks = [
+  "local",
+  "mainnet",
+  "matic",
+  "maticmum",
+  "amoy",
+  "sepolia",
+  "xdc",
+  "xdcapothem",
+  "stabilitytestnet",
+  "stability",
+  "astron",
+  "astrontestnet"
+];
 
-
-
-Object.keys(network).forEach(function (k) {
-	if (k !== 'default' && !Object.prototype.hasOwnProperty.call(exports, k)) Object.defineProperty(exports, k, {
-		enumerable: true,
-		get: function () { return network[k]; }
-	});
-});
+exports.networks = networks;

package/dist/cjs/utils/static/icons.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const iconEthereum = "data:image/octet-stream;base64,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";
+const iconPolygon = "data:image/octet-stream;base64,UklGRuIDAABXRUJQVlA4WAoAAAAgAAAAGwAAGwAASUNDUJACAAAAAAKQbGNtcwQwAABtbnRyUkdCIFhZWiAAAAAAAAAAAAAAAABhY3NwQVBQTAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA9tYAAQAAAADTLWxjbXMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAtkZXNjAAABCAAAADhjcHJ0AAABQAAAAE53dHB0AAABkAAAABRjaGFkAAABpAAAACxyWFlaAAAB0AAAABRiWFlaAAAB5AAAABRnWFlaAAAB+AAAABRyVFJDAAACDAAAACBnVFJDAAACLAAAACBiVFJDAAACTAAAACBjaHJtAAACbAAAACRtbHVjAAAAAAAAAAEAAAAMZW5VUwAAABwAAAAcAHMAUgBHAEIAIABiAHUAaQBsAHQALQBpAG4AAG1sdWMAAAAAAAAAAQAAAAxlblVTAAAAMgAAABwATgBvACAAYwBvAHAAeQByAGkAZwBoAHQALAAgAHUAcwBlACAAZgByAGUAZQBsAHkAAAAAWFlaIAAAAAAAAPbWAAEAAAAA0y1zZjMyAAAAAAABDEoAAAXj///zKgAAB5sAAP2H///7ov///aMAAAPYAADAlFhZWiAAAAAAAABvlAAAOO4AAAOQWFlaIAAAAAAAACSdAAAPgwAAtr5YWVogAAAAAAAAYqUAALeQAAAY3nBhcmEAAAAAAAMAAAACZmYAAPKnAAANWQAAE9AAAApbcGFyYQAAAAAAAwAAAAJmZgAA8qcAAA1ZAAAT0AAACltwYXJhAAAAAAADAAAAAmZmAADypwAADVkAABPQAAAKW2Nocm0AAAAAAAMAAAAAo9cAAFR7AABMzQAAmZoAACZmAAAPXFZQOCAsAQAA0AYAnQEqHAAcAD51NJZIJKKiISgIAJAOiWwAnTKEdJbM1CAbylWADni89c4WxZmtFIZBTwVdNi7B/6pMFDSAAP6cndoPasLV/veLzZaSG+2mxKD2fk7/4J3+Z2GPkSYUHZlR0TsNSACB4Ufuttmf2MK9zqJ2TOLvtgN/ffP+c4jf/0JYocrS5HDSjZJ/5w4r7MaPkV5xVL/WKStL3v+f+1/gjVXkgGLN3OFVZlH5GcDKHsuZkryL3BvMdAEjCnkCyYaqZt/X/N4v03hkpt3+vLxOeIYNT3f4r0xR/2pbc/6PPyM+r+pgJDlri+mHxIk9+PsxEW8gi2xTCt42Moyy5KMqf8G9R8HkT4goyfBzf1NC02SSSxrt+Xli8+Ro//H/SzA0fbjp5Dn8gAAA";
+const iconXDC = "data:image/octet-stream;base64,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";
+const iconStability = "data:image/png;base64,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";
+const iconAstron = "data:image/png;base64,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";
+
+exports.iconAstron = iconAstron;
+exports.iconEthereum = iconEthereum;
+exports.iconPolygon = iconPolygon;
+exports.iconStability = iconStability;
+exports.iconXDC = iconXDC;