@zeroad.network/token 0.13.13 → 0.14.0

package/dist/index.mjs

@@ -1,16 +1,73 @@
-import { F as FEATURE, Z as ZEROAD_NETWORK_PUBLIC_KEY, h as hasFlag, f as fromBase64, P as PROTOCOL_VERSION, l as log, s as setFlags, t as toBase64, e as encodeServerHeader, S as SERVER_HEADER, C as CLIENT_HEADER } from './browser-DiH4sEBn.mjs';
-export { b as CURRENT_PROTOCOL_VERSION, d as decodeServerHeader, a as setLogLevel } from './browser-DiH4sEBn.mjs';
+import { l as log, F as FEATURE, Z as ZEROAD_NETWORK_PUBLIC_KEY, f as fromBase64, P as PROTOCOL_VERSION, s as setFlags, t as toBase64, e as encodeServerHeader, S as SERVER_HEADER, C as CLIENT_HEADER } from './browser-VjxLaeuu.mjs';
+export { c as CURRENT_PROTOCOL_VERSION, d as decodeServerHeader, a as setLogLevel, b as setLogTransport } from './browser-VjxLaeuu.mjs';
 import { Buffer } from 'node:buffer';
 import { verify as verify$1, randomBytes, sign as sign$1, createPublicKey, createPrivateKey } from 'node:crypto';
 
+const DEFAULT_CACHE_CONFIG = {
+  enabled: true,
+  maxSize: 100,
+  ttl: 5e3
+  // 5 seconds
+};
+let cacheConfig = { ...DEFAULT_CACHE_CONFIG };
+function configureCaching(config) {
+  if (config.ttl !== void 0 && config.ttl < 0) {
+    throw new Error("Cache TTL must be >= 0");
+  }
+  if (config.maxSize !== void 0 && config.maxSize < 1) {
+    throw new Error("Cache maxSize must be >= 1");
+  }
+  cacheConfig = { ...cacheConfig, ...config };
+  if (!cacheConfig.enabled) {
+    headerCache.clear();
+  }
+  trimCache();
+  log("debug", "Cache configuration updated", cacheConfig);
+}
+function getCacheConfig() {
+  return { ...cacheConfig };
+}
+const headerCache = /* @__PURE__ */ new Map();
+function trimCache() {
+  if (headerCache.size <= cacheConfig.maxSize) return;
+  const entriesToRemove = headerCache.size - cacheConfig.maxSize;
+  const entries = Array.from(headerCache.entries());
+  entries.sort((a, b) => {
+    if (a[1].accessCount !== b[1].accessCount) {
+      return a[1].accessCount - b[1].accessCount;
+    }
+    return a[1].timestamp - b[1].timestamp;
+  });
+  for (let i = 0; i < entriesToRemove; i++) {
+    headerCache.delete(entries[i][0]);
+  }
+}
+function cleanExpiredEntries(now) {
+  for (const [key, entry] of headerCache.entries()) {
+    if (entry.effectiveExpiry <= now) {
+      headerCache.delete(key);
+    }
+  }
+}
+
 const keyCache = /* @__PURE__ */ new Map();
 function sign(data, privateKey) {
   const key = importPrivateKey(privateKey);
-  return sign$1(null, Buffer.from(data), key);
+  return new Promise((resolve, reject) => {
+    sign$1(null, Buffer.from(data), key, (err, result) => {
+      if (err) reject(err);
+      else resolve(result);
+    });
+  });
 }
 function verify(data, signature, publicKey) {
   const key = importPublicKey(publicKey);
-  return verify$1(null, Buffer.from(data), key, Buffer.from(signature));
+  return new Promise((resolve, reject) => {
+    verify$1(null, Buffer.from(data), key, Buffer.from(signature), (err, result) => {
+      if (err) reject(err);
+      else resolve(result);
+    });
+  });
 }
 const nonce = (size) => new Uint8Array(randomBytes(size));
 function importPrivateKey(privateKeyBase64) {
@@ -37,55 +94,132 @@ function importPublicKey(publicKeyBase64) {
 const VERSION_BYTES = 1;
 const NONCE_BYTES = 4;
 const SEPARATOR = ".";
-const FEATURE_TO_ACTIONS = {
-  [FEATURE.CLEAN_WEB]: [
+const UINT32_BYTES = 4;
+const FEATURE_TO_ACTIONS = Object.freeze({
+  [FEATURE.CLEAN_WEB]: Object.freeze([
     "HIDE_ADVERTISEMENTS",
     "HIDE_COOKIE_CONSENT_SCREEN",
     "HIDE_MARKETING_DIALOGS",
     "DISABLE_NON_FUNCTIONAL_TRACKING"
-  ],
-  [FEATURE.ONE_PASS]: ["DISABLE_CONTENT_PAYWALL", "ENABLE_SUBSCRIPTION_ACCESS"]
-};
-function parseClientToken(headerValue, options) {
+  ]),
+  [FEATURE.ONE_PASS]: Object.freeze([
+    "DISABLE_CONTENT_PAYWALL",
+    "ENABLE_SUBSCRIPTION_ACCESS"
+  ])
+});
+const FEATURE_NUMBERS = Object.freeze([FEATURE.CLEAN_WEB, FEATURE.ONE_PASS]);
+const EMPTY_CONTEXT = Object.freeze({
+  HIDE_ADVERTISEMENTS: false,
+  HIDE_COOKIE_CONSENT_SCREEN: false,
+  HIDE_MARKETING_DIALOGS: false,
+  DISABLE_NON_FUNCTIONAL_TRACKING: false,
+  DISABLE_CONTENT_PAYWALL: false,
+  ENABLE_SUBSCRIPTION_ACCESS: false
+});
+function createEmptyContext() {
+  return EMPTY_CONTEXT;
+}
+async function parseClientToken(headerValue, options) {
+  if (!headerValue || Array.isArray(headerValue) && !headerValue.length) {
+    return createEmptyContext();
+  }
   const headerValueAsString = Array.isArray(headerValue) ? headerValue[0] : headerValue;
-  const data = decodeClientHeader(headerValueAsString, options.publicKey || ZEROAD_NETWORK_PUBLIC_KEY);
+  const now = Date.now();
+  if (cacheConfig.enabled && !options.bypassCache) {
+    const cached = headerCache.get(headerValueAsString);
+    if (cached && cached.effectiveExpiry > now) {
+      cached.accessCount++;
+      return buildContext(cached.data, options, now);
+    } else if (cached) {
+      headerCache.delete(headerValueAsString);
+    }
+  }
+  const data = await decodeClientHeader(headerValueAsString, options.publicKey || ZEROAD_NETWORK_PUBLIC_KEY);
+  if (cacheConfig.enabled && !options.bypassCache) {
+    const cacheTTLExpiry = now + cacheConfig.ttl;
+    const tokenExpiry = data?.expiresAt.getTime() ?? 0;
+    const effectiveExpiry = tokenExpiry > 0 ? Math.min(cacheTTLExpiry, tokenExpiry) : cacheTTLExpiry;
+    headerCache.set(headerValueAsString, {
+      data,
+      timestamp: now,
+      accessCount: 1,
+      effectiveExpiry
+    });
+    if (headerCache.size > 0 && headerCache.size % 100 === 0) {
+      cleanExpiredEntries(now);
+    }
+    trimCache();
+  }
+  return buildContext(data, options, now);
+}
+function buildContext(data, options, now) {
   let flags = 0;
-  if (data && data.expiresAt.getTime() >= Date.now()) flags = data.flags;
-  if (flags && data?.clientId && data.clientId !== options.clientId) flags = 0;
-  const context = /* @__PURE__ */ new Map();
-  for (const [feature, actionNames] of Object.entries(FEATURE_TO_ACTIONS)) {
-    const decision = options.features.includes(Number(feature)) && hasFlag(Number(feature), flags);
-    for (const actionName of actionNames) {
-      context.set(actionName, decision);
+  if (data && data.expiresAt.getTime() >= now) {
+    if (!data.clientId || data.clientId === options.clientId) {
+      flags = data.flags;
     }
   }
-  return Object.fromEntries(context);
+  if (!flags) {
+    return createEmptyContext();
+  }
+  const featuresSet = options.features.length <= 2 ? options.features : new Set(options.features);
+  const context = {};
+  for (let i = 0; i < FEATURE_NUMBERS.length; i++) {
+    const feature = FEATURE_NUMBERS[i];
+    const actionNames = FEATURE_TO_ACTIONS[feature];
+    const isEnabled = (Array.isArray(featuresSet) ? featuresSet.includes(feature) : featuresSet.has(feature)) && (flags & feature) !== 0;
+    const len = actionNames.length;
+    if (len > 0) context[actionNames[0]] = isEnabled;
+    if (len > 1) context[actionNames[1]] = isEnabled;
+    if (len > 2) context[actionNames[2]] = isEnabled;
+    if (len > 3) context[actionNames[3]] = isEnabled;
+  }
+  return context;
 }
-function decodeClientHeader(headerValue, publicKey) {
-  if (!headerValue?.length) return;
+async function decodeClientHeader(headerValue, publicKey) {
+  if (!headerValue?.length) return void 0;
   try {
-    const [data, signature] = headerValue.split(SEPARATOR);
+    const separatorIndex = headerValue.indexOf(SEPARATOR);
+    if (separatorIndex === -1) {
+      throw new Error("Invalid header format: missing separator");
+    }
+    const data = headerValue.substring(0, separatorIndex);
+    const signature = headerValue.substring(separatorIndex + 1);
     const dataBytes = fromBase64(data);
     const signatureBytes = fromBase64(signature);
-    if (!verify(dataBytes.buffer, signatureBytes.buffer, publicKey)) {
+    if (!await verify(dataBytes.buffer, signatureBytes.buffer, publicKey)) {
       throw new Error("Forged header value is provided");
     }
     const version = dataBytes[0];
-    let clientId;
     if (version === PROTOCOL_VERSION.V_1) {
-      const expiresAt = as32BitNumber(dataBytes, VERSION_BYTES + NONCE_BYTES);
-      const flags = as32BitNumber(dataBytes, VERSION_BYTES + NONCE_BYTES + Uint32Array.BYTES_PER_ELEMENT);
-      const expectedByteLength = VERSION_BYTES + NONCE_BYTES + Uint32Array.BYTES_PER_ELEMENT * 2;
-      if (dataBytes.byteLength > expectedByteLength) {
-        clientId = new TextDecoder().decode(dataBytes.subarray(expectedByteLength));
+      const expectedMinLength = VERSION_BYTES + NONCE_BYTES + UINT32_BYTES * 2;
+      if (dataBytes.byteLength < expectedMinLength) {
+        throw new Error("Invalid data length");
       }
-      return { version, expiresAt: new Date(expiresAt * 1e3), flags, ...clientId && { clientId } };
+      const view = new DataView(dataBytes.buffer, dataBytes.byteOffset, dataBytes.byteLength);
+      const expiresAtOffset = VERSION_BYTES + NONCE_BYTES;
+      const flagsOffset = expiresAtOffset + UINT32_BYTES;
+      const expiresAt = view.getUint32(expiresAtOffset, true);
+      const flags = view.getUint32(flagsOffset, true);
+      let clientId;
+      if (dataBytes.byteLength > expectedMinLength) {
+        const clientIdBytes = dataBytes.subarray(expectedMinLength);
+        clientId = new TextDecoder().decode(clientIdBytes);
+      }
+      return {
+        version,
+        expiresAt: new Date(expiresAt * 1e3),
+        flags,
+        ...clientId && { clientId }
+      };
     }
+    throw new Error(`Unsupported protocol version: ${version}`);
   } catch (err) {
     log("warn", "Could not decode client header value", { reason: err?.message });
+    return void 0;
   }
 }
-function encodeClientHeader(data, privateKey) {
+async function encodeClientHeader(data, privateKey) {
   const payload = mergeByteArrays([
     new Uint8Array([data.version]),
     new Uint8Array(nonce(NONCE_BYTES)),
@@ -93,7 +227,7 @@ function encodeClientHeader(data, privateKey) {
     new Uint32Array([setFlags(data.features)]),
     ...data.clientId?.length ? [new Uint8Array(new TextEncoder().encode(data.clientId))] : []
   ]);
-  return [toBase64(payload), toBase64(new Uint8Array(sign(payload.buffer, privateKey)))].join(SEPARATOR);
+  return [toBase64(payload), toBase64(new Uint8Array(await sign(payload.buffer, privateKey)))].join(SEPARATOR);
 }
 function mergeByteArrays(arrays) {
   const totalLength = arrays.reduce((sum, a) => sum + a.byteLength, 0);
@@ -109,14 +243,12 @@ function mergeByteArrays(arrays) {
   }
   return data;
 }
-function as32BitNumber(byteArray, begin) {
-  const bytes = byteArray.subarray(begin, begin + Uint32Array.BYTES_PER_ELEMENT);
-  const view = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength);
-  return view.getUint32(0, true);
-}
 
 function Site(options) {
   const serverHeaderValue = encodeServerHeader(options.clientId, options.features);
+  if (options.cacheConfig) {
+    configureCaching(options.cacheConfig);
+  }
   return {
     parseClientToken: (headerValue) => parseClientToken(headerValue, { clientId: options.clientId, features: options.features }),
     CLIENT_HEADER_NAME: CLIENT_HEADER.HELLO.toLowerCase(),
@@ -125,4 +257,4 @@ function Site(options) {
   };
 }
 
-export { CLIENT_HEADER, FEATURE, PROTOCOL_VERSION, SERVER_HEADER, Site, ZEROAD_NETWORK_PUBLIC_KEY, decodeClientHeader, encodeClientHeader, encodeServerHeader, parseClientToken };
+export { CLIENT_HEADER, FEATURE, PROTOCOL_VERSION, SERVER_HEADER, Site, ZEROAD_NETWORK_PUBLIC_KEY, cacheConfig, cleanExpiredEntries, configureCaching, decodeClientHeader, encodeClientHeader, encodeServerHeader, getCacheConfig, headerCache, parseClientToken, trimCache };

package/package.json

@@ -1,10 +1,9 @@
 {
   "name": "@zeroad.network/token",
-  "version": "0.13.13",
+  "version": "0.14.0",
   "license": "Apache-2.0",
   "repository": "github:laurynas-karvelis/zeroad-token-typescript",
   "homepage": "https://zeroad.network",
-  "private": false,
   "author": {
     "name": "Laurynas Karvelis <Explosive Brains Ltd>",
     "email": "hello@zeroad.network",
@@ -70,7 +69,7 @@
   "scripts": {
     "keys:generate": "bun run ./src/tools/cli.ts",
     "prettier": "prettier . --write",
-    "build": "pkgroll --target=node18",
+    "build": "pkgroll --target=esnext --target=node18",
     "test": "bun test ./src"
   },
   "dependencies": {},