@zeroad.network/token 0.13.12 → 0.14.0

package/dist/index.d.cts

@@ -1,43 +1,65 @@
-import { F as FEATURES, P as PROTOCOL_VERSION, S as SERVER_HEADERS } from './browser-BiNZ2c6t.cjs';
-export { C as CLIENT_HEADERS, a as CURRENT_PROTOCOL_VERSION, W as WelcomeHeader, Z as ZEROAD_NETWORK_PUBLIC_KEY, d as decodeServerHeader, e as encodeServerHeader } from './browser-BiNZ2c6t.cjs';
+import { F as FEATURE, P as PROTOCOL_VERSION, S as SERVER_HEADER } from './browser-Bl2JEJGW.cjs';
+export { C as CLIENT_HEADER, a as CURRENT_PROTOCOL_VERSION, W as WelcomeHeader, Z as ZEROAD_NETWORK_PUBLIC_KEY, d as decodeServerHeader, e as encodeServerHeader } from './browser-Bl2JEJGW.cjs';
 
 type LogLevel = "error" | "warn" | "info" | "debug";
 declare function setLogLevel(level: LogLevel): void;
+type LogTransport = (level: LogLevel, ...args: unknown[]) => void;
+declare function setLogTransport(fn: LogTransport): void;
 
-type FEATURE_ACTIONS = "HIDE_ADVERTISEMENTS" | "HIDE_COOKIE_CONSENT_SCREEN" | "HIDE_MARKETING_DIALOGS" | "DISABLE_NON_FUNCTIONAL_TRACKING" | "DISABLE_CONTENT_PAYWALL" | "ENABLE_SUBSCRIPTION_ACCESS";
+type FEATURE_ACTION = "HIDE_ADVERTISEMENTS" | "HIDE_COOKIE_CONSENT_SCREEN" | "HIDE_MARKETING_DIALOGS" | "DISABLE_NON_FUNCTIONAL_TRACKING" | "DISABLE_CONTENT_PAYWALL" | "ENABLE_SUBSCRIPTION_ACCESS";
 type ClientHeaderValue = string | string[] | undefined;
-type TokenContext = Record<FEATURE_ACTIONS, boolean>;
+type TokenContext = Record<FEATURE_ACTION, boolean>;
 type ParseClientTokenOptions = {
     clientId: string;
-    features: FEATURES[];
+    features: FEATURE[];
     publicKey?: string;
+    bypassCache?: boolean;
 };
-declare function parseClientToken(headerValue: ClientHeaderValue, options: ParseClientTokenOptions): TokenContext;
+declare function parseClientToken(headerValue: ClientHeaderValue, options: ParseClientTokenOptions): Promise<TokenContext>;
 type DecodedClientHeader = {
     version: PROTOCOL_VERSION;
     expiresAt: Date;
     flags: number;
     clientId?: string;
 };
-declare function decodeClientHeader(headerValue: string | null | undefined, publicKey: string): DecodedClientHeader | undefined;
+declare function decodeClientHeader(headerValue: string | null | undefined, publicKey: string): Promise<DecodedClientHeader | undefined>;
 type EncodeData = {
     version: PROTOCOL_VERSION;
     expiresAt: Date;
-    features: FEATURES[];
+    features: FEATURE[];
     clientId?: string;
 };
-declare function encodeClientHeader(data: EncodeData, privateKey: string): string;
+declare function encodeClientHeader(data: EncodeData, privateKey: string): Promise<string>;
+
+interface CacheConfig {
+    enabled: boolean;
+    maxSize: number;
+    ttl: number;
+}
+declare let cacheConfig: CacheConfig;
+declare function configureCaching(config: Partial<CacheConfig>): void;
+declare function getCacheConfig(): Readonly<CacheConfig>;
+interface CacheEntry {
+    data: DecodedClientHeader | undefined;
+    effectiveExpiry: number;
+    accessCount: number;
+    timestamp: number;
+}
+declare const headerCache: Map<string, CacheEntry>;
+declare function trimCache(): void;
+declare function cleanExpiredEntries(now: number): void;
 
 type SiteOptions = {
     clientId: string;
-    features: FEATURES[];
+    features: FEATURE[];
+    cacheConfig?: CacheConfig;
 };
 declare function Site(options: SiteOptions): {
-    parseClientToken: (headerValue: ClientHeaderValue) => TokenContext;
+    parseClientToken: (headerValue: ClientHeaderValue) => Promise<TokenContext>;
     CLIENT_HEADER_NAME: string;
-    SERVER_HEADER_NAME: SERVER_HEADERS;
+    SERVER_HEADER_NAME: SERVER_HEADER;
     SERVER_HEADER_VALUE: string;
 };
 
-export { FEATURES, PROTOCOL_VERSION, SERVER_HEADERS, Site, decodeClientHeader, encodeClientHeader, parseClientToken, setLogLevel };
-export type { ClientHeaderValue, DecodedClientHeader, FEATURE_ACTIONS, ParseClientTokenOptions, TokenContext };
+export { FEATURE, PROTOCOL_VERSION, SERVER_HEADER, Site, cacheConfig, cleanExpiredEntries, configureCaching, decodeClientHeader, encodeClientHeader, getCacheConfig, headerCache, parseClientToken, setLogLevel, setLogTransport, trimCache };
+export type { CacheConfig, ClientHeaderValue, DecodedClientHeader, FEATURE_ACTION, ParseClientTokenOptions, TokenContext };

package/dist/index.d.mts

@@ -1,43 +1,65 @@
-import { F as FEATURES, P as PROTOCOL_VERSION, S as SERVER_HEADERS } from './browser-BiNZ2c6t.mjs';
-export { C as CLIENT_HEADERS, a as CURRENT_PROTOCOL_VERSION, W as WelcomeHeader, Z as ZEROAD_NETWORK_PUBLIC_KEY, d as decodeServerHeader, e as encodeServerHeader } from './browser-BiNZ2c6t.mjs';
+import { F as FEATURE, P as PROTOCOL_VERSION, S as SERVER_HEADER } from './browser-Bl2JEJGW.mjs';
+export { C as CLIENT_HEADER, a as CURRENT_PROTOCOL_VERSION, W as WelcomeHeader, Z as ZEROAD_NETWORK_PUBLIC_KEY, d as decodeServerHeader, e as encodeServerHeader } from './browser-Bl2JEJGW.mjs';
 
 type LogLevel = "error" | "warn" | "info" | "debug";
 declare function setLogLevel(level: LogLevel): void;
+type LogTransport = (level: LogLevel, ...args: unknown[]) => void;
+declare function setLogTransport(fn: LogTransport): void;
 
-type FEATURE_ACTIONS = "HIDE_ADVERTISEMENTS" | "HIDE_COOKIE_CONSENT_SCREEN" | "HIDE_MARKETING_DIALOGS" | "DISABLE_NON_FUNCTIONAL_TRACKING" | "DISABLE_CONTENT_PAYWALL" | "ENABLE_SUBSCRIPTION_ACCESS";
+type FEATURE_ACTION = "HIDE_ADVERTISEMENTS" | "HIDE_COOKIE_CONSENT_SCREEN" | "HIDE_MARKETING_DIALOGS" | "DISABLE_NON_FUNCTIONAL_TRACKING" | "DISABLE_CONTENT_PAYWALL" | "ENABLE_SUBSCRIPTION_ACCESS";
 type ClientHeaderValue = string | string[] | undefined;
-type TokenContext = Record<FEATURE_ACTIONS, boolean>;
+type TokenContext = Record<FEATURE_ACTION, boolean>;
 type ParseClientTokenOptions = {
     clientId: string;
-    features: FEATURES[];
+    features: FEATURE[];
     publicKey?: string;
+    bypassCache?: boolean;
 };
-declare function parseClientToken(headerValue: ClientHeaderValue, options: ParseClientTokenOptions): TokenContext;
+declare function parseClientToken(headerValue: ClientHeaderValue, options: ParseClientTokenOptions): Promise<TokenContext>;
 type DecodedClientHeader = {
     version: PROTOCOL_VERSION;
     expiresAt: Date;
     flags: number;
     clientId?: string;
 };
-declare function decodeClientHeader(headerValue: string | null | undefined, publicKey: string): DecodedClientHeader | undefined;
+declare function decodeClientHeader(headerValue: string | null | undefined, publicKey: string): Promise<DecodedClientHeader | undefined>;
 type EncodeData = {
     version: PROTOCOL_VERSION;
     expiresAt: Date;
-    features: FEATURES[];
+    features: FEATURE[];
     clientId?: string;
 };
-declare function encodeClientHeader(data: EncodeData, privateKey: string): string;
+declare function encodeClientHeader(data: EncodeData, privateKey: string): Promise<string>;
+
+interface CacheConfig {
+    enabled: boolean;
+    maxSize: number;
+    ttl: number;
+}
+declare let cacheConfig: CacheConfig;
+declare function configureCaching(config: Partial<CacheConfig>): void;
+declare function getCacheConfig(): Readonly<CacheConfig>;
+interface CacheEntry {
+    data: DecodedClientHeader | undefined;
+    effectiveExpiry: number;
+    accessCount: number;
+    timestamp: number;
+}
+declare const headerCache: Map<string, CacheEntry>;
+declare function trimCache(): void;
+declare function cleanExpiredEntries(now: number): void;
 
 type SiteOptions = {
     clientId: string;
-    features: FEATURES[];
+    features: FEATURE[];
+    cacheConfig?: CacheConfig;
 };
 declare function Site(options: SiteOptions): {
-    parseClientToken: (headerValue: ClientHeaderValue) => TokenContext;
+    parseClientToken: (headerValue: ClientHeaderValue) => Promise<TokenContext>;
     CLIENT_HEADER_NAME: string;
-    SERVER_HEADER_NAME: SERVER_HEADERS;
+    SERVER_HEADER_NAME: SERVER_HEADER;
     SERVER_HEADER_VALUE: string;
 };
 
-export { FEATURES, PROTOCOL_VERSION, SERVER_HEADERS, Site, decodeClientHeader, encodeClientHeader, parseClientToken, setLogLevel };
-export type { ClientHeaderValue, DecodedClientHeader, FEATURE_ACTIONS, ParseClientTokenOptions, TokenContext };
+export { FEATURE, PROTOCOL_VERSION, SERVER_HEADER, Site, cacheConfig, cleanExpiredEntries, configureCaching, decodeClientHeader, encodeClientHeader, getCacheConfig, headerCache, parseClientToken, setLogLevel, setLogTransport, trimCache };
+export type { CacheConfig, ClientHeaderValue, DecodedClientHeader, FEATURE_ACTION, ParseClientTokenOptions, TokenContext };

package/dist/index.mjs

@@ -1,16 +1,73 @@
-import { F as FEATURES, 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_HEADERS, C as CLIENT_HEADERS } from './browser--AdrX2EX.mjs';
-export { b as CURRENT_PROTOCOL_VERSION, d as decodeServerHeader, a as setLogLevel } from './browser--AdrX2EX.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 FEATURES_TO_ACTIONS = {
-  [FEATURES.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"
-  ],
-  [FEATURES.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(FEATURES_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,20 +243,18 @@ 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_HEADERS.HELLO.toLowerCase(),
-    SERVER_HEADER_NAME: SERVER_HEADERS.WELCOME,
+    CLIENT_HEADER_NAME: CLIENT_HEADER.HELLO.toLowerCase(),
+    SERVER_HEADER_NAME: SERVER_HEADER.WELCOME,
     SERVER_HEADER_VALUE: serverHeaderValue
   };
 }
 
-export { CLIENT_HEADERS, FEATURES, PROTOCOL_VERSION, SERVER_HEADERS, 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.12",
+  "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,13 +69,13 @@
   "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": {},
   "devDependencies": {
     "@types/bun": "^1.3.4",
-    "@types/node": "^24.10.2",
+    "@types/node": "^25.0.1",
     "pkgroll": "^2.21.4",
     "prettier": "^3.7.4",
     "typescript": "^5.9.3"