@0xpolygonid/js-sdk 1.32.3 → 1.32.4

package/dist/node/cjs/index.cjs

@@ -242,7 +242,10 @@ __export(index_exports, {
   isEthereumIdentity: () => isEthereumIdentity,
   isGenesisState: () => isGenesisState,
   isGenesisStateId: () => isGenesisStateId,
+  isIdentityDoesNotExistError: () => isIdentityDoesNotExistError,
   isIssuerGenesis: () => isIssuerGenesis,
+  isRootDoesNotExistError: () => isRootDoesNotExistError,
+  isStateDoesNotExistError: () => isStateDoesNotExistError,
   isValidOperation: () => isValidOperation,
   jsonLDMerklizer: () => jsonLDMerklizer,
   keyPath: () => keyPath,
@@ -1055,7 +1058,12 @@ var VerifiableConstants = Object.freeze({
     CONTEXT_TYPE_IS_EMPTY: "ctxType is empty",
     // ErrStateNotFound issuer state is genesis state.
     IDENTITY_DOES_NOT_EXIST: "Identity does not exist",
+    IDENTITY_DOES_NOT_EXIST_CUSTOM_ERROR: "IdentityDoesNotExist",
     NO_AUTH_CRED_FOUND: "no auth credentials found",
+    STATE_DOES_NOT_EXIST: "State does not exist",
+    STATE_DOES_NOT_EXIST_CUSTOM_ERROR: "StateDoesNotExist",
+    ROOT_DOES_NOT_EXIST: "Root does not exist",
+    ROOT_DOES_NOT_EXIST_CUSTOM_ERROR: "RootDoesNotExist",
     // identity wallet
     ID_WALLET_NO_CREDENTIAL_SATISFIED_QUERY: "no credential satisfied query",
     ID_WALLET_SIGNER_IS_REQUIRED: "Ethereum signer is required to create Ethereum identities in order to transit state",
@@ -4946,10 +4954,258 @@ var InMemoryDataSource = class {
   }
 };
 
+// node_modules/quick-lru/index.js
+var QuickLRU = class extends Map {
+  #size = 0;
+  #cache = /* @__PURE__ */ new Map();
+  #oldCache = /* @__PURE__ */ new Map();
+  #maxSize;
+  #maxAge;
+  #onEviction;
+  constructor(options = {}) {
+    super();
+    if (!(options.maxSize && options.maxSize > 0)) {
+      throw new TypeError("`maxSize` must be a number greater than 0");
+    }
+    if (typeof options.maxAge === "number" && options.maxAge === 0) {
+      throw new TypeError("`maxAge` must be a number greater than 0");
+    }
+    this.#maxSize = options.maxSize;
+    this.#maxAge = options.maxAge || Number.POSITIVE_INFINITY;
+    this.#onEviction = options.onEviction;
+  }
+  // For tests.
+  get __oldCache() {
+    return this.#oldCache;
+  }
+  #emitEvictions(cache) {
+    if (typeof this.#onEviction !== "function") {
+      return;
+    }
+    for (const [key, item] of cache) {
+      this.#onEviction(key, item.value);
+    }
+  }
+  #deleteIfExpired(key, item) {
+    if (typeof item.expiry === "number" && item.expiry <= Date.now()) {
+      if (typeof this.#onEviction === "function") {
+        this.#onEviction(key, item.value);
+      }
+      return this.delete(key);
+    }
+    return false;
+  }
+  #getOrDeleteIfExpired(key, item) {
+    const deleted = this.#deleteIfExpired(key, item);
+    if (deleted === false) {
+      return item.value;
+    }
+  }
+  #getItemValue(key, item) {
+    return item.expiry ? this.#getOrDeleteIfExpired(key, item) : item.value;
+  }
+  #peek(key, cache) {
+    const item = cache.get(key);
+    return this.#getItemValue(key, item);
+  }
+  #set(key, value) {
+    this.#cache.set(key, value);
+    this.#size++;
+    if (this.#size >= this.#maxSize) {
+      this.#size = 0;
+      this.#emitEvictions(this.#oldCache);
+      this.#oldCache = this.#cache;
+      this.#cache = /* @__PURE__ */ new Map();
+    }
+  }
+  #moveToRecent(key, item) {
+    this.#oldCache.delete(key);
+    this.#set(key, item);
+  }
+  *#entriesAscending() {
+    for (const item of this.#oldCache) {
+      const [key, value] = item;
+      if (!this.#cache.has(key)) {
+        const deleted = this.#deleteIfExpired(key, value);
+        if (deleted === false) {
+          yield item;
+        }
+      }
+    }
+    for (const item of this.#cache) {
+      const [key, value] = item;
+      const deleted = this.#deleteIfExpired(key, value);
+      if (deleted === false) {
+        yield item;
+      }
+    }
+  }
+  get(key) {
+    if (this.#cache.has(key)) {
+      const item = this.#cache.get(key);
+      return this.#getItemValue(key, item);
+    }
+    if (this.#oldCache.has(key)) {
+      const item = this.#oldCache.get(key);
+      if (this.#deleteIfExpired(key, item) === false) {
+        this.#moveToRecent(key, item);
+        return item.value;
+      }
+    }
+  }
+  set(key, value, { maxAge = this.#maxAge } = {}) {
+    const expiry = typeof maxAge === "number" && maxAge !== Number.POSITIVE_INFINITY ? Date.now() + maxAge : void 0;
+    if (this.#cache.has(key)) {
+      this.#cache.set(key, {
+        value,
+        expiry
+      });
+    } else {
+      this.#set(key, { value, expiry });
+    }
+    return this;
+  }
+  has(key) {
+    if (this.#cache.has(key)) {
+      return !this.#deleteIfExpired(key, this.#cache.get(key));
+    }
+    if (this.#oldCache.has(key)) {
+      return !this.#deleteIfExpired(key, this.#oldCache.get(key));
+    }
+    return false;
+  }
+  peek(key) {
+    if (this.#cache.has(key)) {
+      return this.#peek(key, this.#cache);
+    }
+    if (this.#oldCache.has(key)) {
+      return this.#peek(key, this.#oldCache);
+    }
+  }
+  delete(key) {
+    const deleted = this.#cache.delete(key);
+    if (deleted) {
+      this.#size--;
+    }
+    return this.#oldCache.delete(key) || deleted;
+  }
+  clear() {
+    this.#cache.clear();
+    this.#oldCache.clear();
+    this.#size = 0;
+  }
+  resize(newSize) {
+    if (!(newSize && newSize > 0)) {
+      throw new TypeError("`maxSize` must be a number greater than 0");
+    }
+    const items = [...this.#entriesAscending()];
+    const removeCount = items.length - newSize;
+    if (removeCount < 0) {
+      this.#cache = new Map(items);
+      this.#oldCache = /* @__PURE__ */ new Map();
+      this.#size = items.length;
+    } else {
+      if (removeCount > 0) {
+        this.#emitEvictions(items.slice(0, removeCount));
+      }
+      this.#oldCache = new Map(items.slice(removeCount));
+      this.#cache = /* @__PURE__ */ new Map();
+      this.#size = 0;
+    }
+    this.#maxSize = newSize;
+  }
+  *keys() {
+    for (const [key] of this) {
+      yield key;
+    }
+  }
+  *values() {
+    for (const [, value] of this) {
+      yield value;
+    }
+  }
+  *[Symbol.iterator]() {
+    for (const item of this.#cache) {
+      const [key, value] = item;
+      const deleted = this.#deleteIfExpired(key, value);
+      if (deleted === false) {
+        yield [key, value.value];
+      }
+    }
+    for (const item of this.#oldCache) {
+      const [key, value] = item;
+      if (!this.#cache.has(key)) {
+        const deleted = this.#deleteIfExpired(key, value);
+        if (deleted === false) {
+          yield [key, value.value];
+        }
+      }
+    }
+  }
+  *entriesDescending() {
+    let items = [...this.#cache];
+    for (let i = items.length - 1; i >= 0; --i) {
+      const item = items[i];
+      const [key, value] = item;
+      const deleted = this.#deleteIfExpired(key, value);
+      if (deleted === false) {
+        yield [key, value.value];
+      }
+    }
+    items = [...this.#oldCache];
+    for (let i = items.length - 1; i >= 0; --i) {
+      const item = items[i];
+      const [key, value] = item;
+      if (!this.#cache.has(key)) {
+        const deleted = this.#deleteIfExpired(key, value);
+        if (deleted === false) {
+          yield [key, value.value];
+        }
+      }
+    }
+  }
+  *entriesAscending() {
+    for (const [key, value] of this.#entriesAscending()) {
+      yield [key, value.value];
+    }
+  }
+  get size() {
+    if (!this.#size) {
+      return this.#oldCache.size;
+    }
+    let oldCacheSize = 0;
+    for (const key of this.#oldCache.keys()) {
+      if (!this.#cache.has(key)) {
+        oldCacheSize++;
+      }
+    }
+    return Math.min(this.#size + oldCacheSize, this.#maxSize);
+  }
+  get maxSize() {
+    return this.#maxSize;
+  }
+  entries() {
+    return this.entriesAscending();
+  }
+  forEach(callbackFunction, thisArgument = this) {
+    for (const [key, value] of this.entriesAscending()) {
+      callbackFunction.call(thisArgument, value, key, this);
+    }
+  }
+  get [Symbol.toStringTag]() {
+    return "QuickLRU";
+  }
+  toString() {
+    return `QuickLRU(${this.size}/${this.maxSize})`;
+  }
+  [Symbol.for("nodejs.util.inspect.custom")]() {
+    return this.toString();
+  }
+};
+
 // src/storage/memory/cache-lru.ts
-var import_quick_lru = __toESM(require("quick-lru"), 1);
 function createInMemoryCache(params) {
-  const cache = new import_quick_lru.default({ maxSize: params.maxSize, maxAge: params.ttl });
+  const cache = new QuickLRU({ maxSize: params.maxSize, maxAge: params.ttl });
   return {
     get: async (key) => {
       return cache.get(key);
@@ -6503,6 +6759,31 @@ var OnChainRevocationStorage = class _OnChainRevocationStorage {
 // src/credentials/status/on-chain-revocation.ts
 var import_js_iden3_core20 = require("@iden3/js-iden3-core");
 var import_js_merkletree17 = require("@iden3/js-merkletree");
+
+// src/storage/blockchain/errors.ts
+function isErrorWithArgs(error) {
+  return typeof error === "object" && error !== null && "errorArgs" in error && Array.isArray(error.errorArgs);
+}
+function extractErrorMessage(error) {
+  const errorArgs = isErrorWithArgs(error) ? error.errorArgs[0] : void 0;
+  const errMsg = errorArgs || (error instanceof Error ? error.message : "");
+  return errMsg;
+}
+function isError(error, errorMsg) {
+  const errMsg = extractErrorMessage(error);
+  return errMsg.includes(errorMsg);
+}
+function isIdentityDoesNotExistError(error) {
+  return isError(error, VerifiableConstants.ERRORS.IDENTITY_DOES_NOT_EXIST) || isError(error, VerifiableConstants.ERRORS.IDENTITY_DOES_NOT_EXIST_CUSTOM_ERROR);
+}
+function isStateDoesNotExistError(error) {
+  return isError(error, VerifiableConstants.ERRORS.STATE_DOES_NOT_EXIST) || isError(error, VerifiableConstants.ERRORS.STATE_DOES_NOT_EXIST_CUSTOM_ERROR);
+}
+function isRootDoesNotExistError(error) {
+  return isError(error, VerifiableConstants.ERRORS.ROOT_DOES_NOT_EXIST) || isError(error, VerifiableConstants.ERRORS.ROOT_DOES_NOT_EXIST_CUSTOM_ERROR);
+}
+
+// src/credentials/status/on-chain-revocation.ts
 var OnChainResolver = class {
   /**
    *
@@ -6550,8 +6831,7 @@ var OnChainResolver = class {
       }
       latestIssuerState = latestStateInfo.state;
     } catch (e) {
-      const errMsg = e?.reason ?? e.message ?? e;
-      if (!errMsg.includes(VerifiableConstants.ERRORS.IDENTITY_DOES_NOT_EXIST)) {
+      if (!isIdentityDoesNotExistError(e)) {
         throw e;
       }
       if (!stateHex) {
@@ -6759,8 +7039,7 @@ var RHSResolver = class {
       }
       latestState = latestStateInfo.state;
     } catch (e) {
-      const errMsg = e?.reason ?? e.message ?? e;
-      if (!errMsg.includes(VerifiableConstants.ERRORS.IDENTITY_DOES_NOT_EXIST)) {
+      if (!isIdentityDoesNotExistError(e)) {
         throw e;
       }
       const stateHex = this.extractState(credentialStatus.id);
@@ -13267,9 +13546,7 @@ var PubSignalsVerifier = class {
     try {
       contractState = await this._stateStorage.getStateInfoByIdAndState(idBigInt, state);
     } catch (e) {
-      const stateNotExistErr = (e?.errorArgs ?? [])[0];
-      const errMsg = stateNotExistErr || e.message;
-      if (errMsg.includes("State does not exist")) {
+      if (isStateDoesNotExistError(e)) {
         if (isGenesis) {
           return {
             latest: true,
@@ -13302,7 +13579,7 @@ var PubSignalsVerifier = class {
     try {
       globalStateInfo = await this._stateStorage.getGISTRootInfo(state, id);
     } catch (e) {
-      if (e.errorArgs[0] === "Root does not exist") {
+      if (isRootDoesNotExistError(e)) {
         throw new Error("GIST root does not exist in the smart contract");
       }
       throw e;
@@ -14673,7 +14950,10 @@ var jsonLDMerklizer = __toESM(require("@iden3/js-jsonld-merklization"), 1);
   isEthereumIdentity,
   isGenesisState,
   isGenesisStateId,
+  isIdentityDoesNotExistError,
   isIssuerGenesis,
+  isRootDoesNotExistError,
+  isStateDoesNotExistError,
   isValidOperation,
   jsonLDMerklizer,
   keyPath,