intents-1click-rule-engine 1.0.3 → 1.0.5

package/dist/index.js

@@ -1,4 +1,448 @@
-export * from "./src/matcher";
-export * from "./src/token-registry";
-export * from "./src/validator";
-export * from "./src/rule-engine";
+// src/matcher.ts
+class RuleMatcher {
+  rules;
+  defaultFee;
+  tokenRegistry;
+  constructor(config, tokenRegistry) {
+    this.defaultFee = config.default_fee;
+    this.rules = this.sortRulesByPriority(config.rules);
+    this.tokenRegistry = tokenRegistry;
+  }
+  sortRulesByPriority(rules) {
+    return [...rules].sort((a, b) => {
+      const priorityA = a.priority ?? 100;
+      const priorityB = b.priority ?? 100;
+      return priorityB - priorityA;
+    });
+  }
+  matchesSinglePattern(pattern, value) {
+    if (pattern === "*")
+      return true;
+    if (pattern.startsWith("!")) {
+      return value !== pattern.slice(1);
+    }
+    return pattern === value;
+  }
+  matchesValue(pattern, value) {
+    if (Array.isArray(pattern)) {
+      return pattern.some((p) => this.matchesSinglePattern(p, value));
+    }
+    return this.matchesSinglePattern(pattern, value);
+  }
+  matchesToken(matcher, token) {
+    const matchedBy = {};
+    if (matcher.assetId) {
+      if (!this.matchesValue(matcher.assetId, token.assetId)) {
+        return null;
+      }
+      matchedBy.assetId = true;
+    }
+    if (matcher.blockchain) {
+      if (!this.matchesValue(matcher.blockchain, token.blockchain)) {
+        return null;
+      }
+      matchedBy.blockchain = true;
+    }
+    if (matcher.symbol) {
+      if (!this.matchesValue(matcher.symbol, token.symbol)) {
+        return null;
+      }
+      matchedBy.symbol = true;
+    }
+    return { token, matchedBy };
+  }
+  parseDate(dateStr, fieldName) {
+    const timestamp = new Date(dateStr).getTime();
+    if (Number.isNaN(timestamp)) {
+      throw new Error(`Invalid ${fieldName}: "${dateStr}" is not a valid date string`);
+    }
+    return timestamp;
+  }
+  isRuleValidNow(rule) {
+    const now = Date.now();
+    if (rule.valid_from) {
+      const from = this.parseDate(rule.valid_from, "valid_from");
+      if (now < from)
+        return false;
+    }
+    if (rule.valid_until) {
+      const until = this.parseDate(rule.valid_until, "valid_until");
+      if (now > until)
+        return false;
+    }
+    return true;
+  }
+  match(request) {
+    const originToken = this.tokenRegistry.getToken(request.originAsset);
+    const destinationToken = this.tokenRegistry.getToken(request.destinationAsset);
+    if (!originToken || !destinationToken) {
+      return {
+        matched: false,
+        fee: this.defaultFee
+      };
+    }
+    for (const rule of this.rules) {
+      if (!rule.enabled)
+        continue;
+      if (!this.isRuleValidNow(rule))
+        continue;
+      const inMatchInfo = this.matchesToken(rule.match.in, originToken);
+      const outMatchInfo = this.matchesToken(rule.match.out, destinationToken);
+      if (inMatchInfo && outMatchInfo) {
+        return {
+          matched: true,
+          rule,
+          fee: rule.fee,
+          matchDetails: {
+            originToken,
+            destinationToken,
+            in: inMatchInfo,
+            out: outMatchInfo
+          }
+        };
+      }
+    }
+    return {
+      matched: false,
+      fee: this.defaultFee,
+      matchDetails: { originToken, destinationToken }
+    };
+  }
+}
+// src/token-registry.ts
+function isValidTokenResponse(token) {
+  if (typeof token !== "object" || token === null)
+    return false;
+  const t = token;
+  return typeof t.assetId === "string" && typeof t.blockchain === "string" && typeof t.symbol === "string" && typeof t.decimals === "number";
+}
+
+class CachedTokenRegistry {
+  config;
+  cache = new Map;
+  lastFetchTime = 0;
+  refreshPromise = null;
+  constructor(config) {
+    this.config = config;
+  }
+  isCacheValid() {
+    return Date.now() - this.lastFetchTime < this.config.cacheTtlMs;
+  }
+  async refresh() {
+    if (this.refreshPromise) {
+      return this.refreshPromise;
+    }
+    this.refreshPromise = this.doRefresh();
+    try {
+      await this.refreshPromise;
+    } finally {
+      this.refreshPromise = null;
+    }
+  }
+  async doRefresh() {
+    const response = await fetch(this.config.url);
+    if (!response.ok) {
+      throw new Error(`Failed to fetch tokens: ${response.status} ${response.statusText}`);
+    }
+    const data = await response.json();
+    if (!Array.isArray(data)) {
+      throw new Error(`Invalid token registry response: expected array, got ${typeof data}`);
+    }
+    const newCache = new Map;
+    const invalidTokens = [];
+    for (let i = 0;i < data.length; i++) {
+      const token = data[i];
+      if (!isValidTokenResponse(token)) {
+        invalidTokens.push(i);
+        continue;
+      }
+      newCache.set(token.assetId, {
+        assetId: token.assetId,
+        blockchain: token.blockchain,
+        symbol: token.symbol,
+        decimals: token.decimals
+      });
+    }
+    if (invalidTokens.length > 0 && newCache.size === 0) {
+      throw new Error(`Invalid token registry response: all ${data.length} tokens failed validation`);
+    }
+    this.cache = newCache;
+    this.lastFetchTime = Date.now();
+  }
+  async ensureFresh() {
+    if (!this.isCacheValid()) {
+      await this.refresh();
+    }
+  }
+  getToken(assetId) {
+    return this.cache.get(assetId);
+  }
+  getAllTokens() {
+    return Array.from(this.cache.values());
+  }
+  get size() {
+    return this.cache.size;
+  }
+}
+// src/validator.ts
+var NEAR_ACCOUNT_REGEX = /^(?:[a-z\d]+[-_])*[a-z\d]+(?:\.[a-z\d]+[-_]*[a-z\d]+)*$/;
+var NEAR_IMPLICIT_ACCOUNT_REGEX = /^[a-f0-9]{64}$/;
+var MAX_BPS = 1e4;
+function isValidNearAccount(account) {
+  if (account.length < 2 || account.length > 64)
+    return false;
+  return NEAR_ACCOUNT_REGEX.test(account) || NEAR_IMPLICIT_ACCOUNT_REGEX.test(account);
+}
+function isValidDateString(dateStr) {
+  const timestamp = new Date(dateStr).getTime();
+  return !Number.isNaN(timestamp);
+}
+function validateSingleFee(fee, path) {
+  const errors = [];
+  if (fee.type !== "bps") {
+    errors.push({ path: `${path}.type`, message: "fee.type must be 'bps'" });
+  }
+  if (typeof fee.bps !== "number" || fee.bps < 0) {
+    errors.push({ path: `${path}.bps`, message: "fee.bps must be a non-negative number" });
+  } else if (fee.bps > MAX_BPS) {
+    errors.push({ path: `${path}.bps`, message: `fee.bps exceeds maximum of ${MAX_BPS} (100%)` });
+  }
+  if (!fee.recipient || typeof fee.recipient !== "string") {
+    errors.push({ path: `${path}.recipient`, message: "fee.recipient is required and must be a string" });
+  } else if (!isValidNearAccount(fee.recipient)) {
+    errors.push({ path: `${path}.recipient`, message: "fee.recipient must be a valid NEAR account" });
+  }
+  return errors;
+}
+function validateFee(fee, path) {
+  const errors = [];
+  if (Array.isArray(fee)) {
+    if (fee.length === 0) {
+      errors.push({ path, message: "fee array must not be empty" });
+      return errors;
+    }
+    for (let i = 0;i < fee.length; i++) {
+      errors.push(...validateSingleFee(fee[i], `${path}[${i}]`));
+    }
+  } else if (fee && typeof fee === "object") {
+    errors.push(...validateSingleFee(fee, path));
+  } else {
+    errors.push({ path, message: "fee is required" });
+  }
+  return errors;
+}
+function isNonEmptyStringOrArray(value) {
+  if (typeof value === "string")
+    return value.length > 0;
+  if (Array.isArray(value))
+    return value.length > 0 && value.every((v) => typeof v === "string" && v.length > 0);
+  return false;
+}
+function validateTokenMatcher(matcher, path) {
+  const errors = [];
+  if (Array.isArray(matcher.blockchain) && matcher.blockchain.length === 0) {
+    errors.push({ path: `${path}.blockchain`, message: "blockchain array must not be empty" });
+  }
+  if (Array.isArray(matcher.symbol) && matcher.symbol.length === 0) {
+    errors.push({ path: `${path}.symbol`, message: "symbol array must not be empty" });
+  }
+  if (Array.isArray(matcher.assetId) && matcher.assetId.length === 0) {
+    errors.push({ path: `${path}.assetId`, message: "assetId array must not be empty" });
+  }
+  if (Array.isArray(matcher.blockchain) && matcher.blockchain.some((v) => v === "")) {
+    errors.push({ path: `${path}.blockchain`, message: "blockchain array must not contain empty strings" });
+  }
+  if (Array.isArray(matcher.symbol) && matcher.symbol.some((v) => v === "")) {
+    errors.push({ path: `${path}.symbol`, message: "symbol array must not contain empty strings" });
+  }
+  if (Array.isArray(matcher.assetId) && matcher.assetId.some((v) => v === "")) {
+    errors.push({ path: `${path}.assetId`, message: "assetId array must not contain empty strings" });
+  }
+  const hasIdentifier = isNonEmptyStringOrArray(matcher.blockchain) || isNonEmptyStringOrArray(matcher.symbol) || isNonEmptyStringOrArray(matcher.assetId);
+  if (!hasIdentifier) {
+    errors.push({
+      path,
+      message: "At least one of blockchain, symbol, or assetId must be defined"
+    });
+  }
+  return errors;
+}
+function validateRule(rule, index) {
+  const errors = [];
+  const path = `rules[${index}]`;
+  if (!rule.id || typeof rule.id !== "string") {
+    errors.push({ path: `${path}.id`, message: "id is required and must be a string" });
+  }
+  if (typeof rule.enabled !== "boolean") {
+    errors.push({ path: `${path}.enabled`, message: "enabled is required and must be a boolean" });
+  }
+  if (rule.priority !== undefined && (typeof rule.priority !== "number" || rule.priority < 0)) {
+    errors.push({ path: `${path}.priority`, message: "priority must be a non-negative number" });
+  }
+  if (!rule.match) {
+    errors.push({ path: `${path}.match`, message: "match is required" });
+  } else {
+    if (!rule.match.in) {
+      errors.push({ path: `${path}.match.in`, message: "match.in is required" });
+    } else {
+      errors.push(...validateTokenMatcher(rule.match.in, `${path}.match.in`));
+    }
+    if (!rule.match.out) {
+      errors.push({ path: `${path}.match.out`, message: "match.out is required" });
+    } else {
+      errors.push(...validateTokenMatcher(rule.match.out, `${path}.match.out`));
+    }
+  }
+  if (!rule.fee) {
+    errors.push({ path: `${path}.fee`, message: "fee is required" });
+  } else {
+    errors.push(...validateFee(rule.fee, `${path}.fee`));
+  }
+  if (rule.valid_from !== undefined) {
+    if (typeof rule.valid_from !== "string") {
+      errors.push({ path: `${path}.valid_from`, message: "valid_from must be a string" });
+    } else if (!isValidDateString(rule.valid_from)) {
+      errors.push({ path: `${path}.valid_from`, message: `valid_from "${rule.valid_from}" is not a valid date string` });
+    }
+  }
+  if (rule.valid_until !== undefined) {
+    if (typeof rule.valid_until !== "string") {
+      errors.push({ path: `${path}.valid_until`, message: "valid_until must be a string" });
+    } else if (!isValidDateString(rule.valid_until)) {
+      errors.push({ path: `${path}.valid_until`, message: `valid_until "${rule.valid_until}" is not a valid date string` });
+    }
+  }
+  return errors;
+}
+function validateConfig(config) {
+  const errors = [];
+  if (!config.version || typeof config.version !== "string") {
+    errors.push({ path: "version", message: "version is required and must be a string" });
+  }
+  if (!config.default_fee) {
+    errors.push({ path: "default_fee", message: "default_fee is required" });
+  } else {
+    errors.push(...validateFee(config.default_fee, "default_fee"));
+  }
+  if (!Array.isArray(config.rules)) {
+    errors.push({ path: "rules", message: "rules must be an array" });
+  } else {
+    const ruleIds = new Set;
+    for (let i = 0;i < config.rules.length; i++) {
+      const rule = config.rules[i];
+      errors.push(...validateRule(rule, i));
+      if (rule.id) {
+        if (ruleIds.has(rule.id)) {
+          errors.push({ path: `rules[${i}].id`, message: `Duplicate rule id: ${rule.id}` });
+        }
+        ruleIds.add(rule.id);
+      }
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+// src/rule-engine.ts
+var DEFAULT_TOKEN_REGISTRY_URL = "https://1click.chaindefuser.com/v0/tokens";
+var DEFAULT_CACHE_TTL_MS = 3600000;
+var BPS_DIVISOR = 10000n;
+var MAX_BPS2 = 1e4;
+function getTotalBps(fee) {
+  if (Array.isArray(fee)) {
+    return fee.reduce((sum, f) => sum + f.bps, 0);
+  }
+  return fee.bps;
+}
+function parseAmount(amount) {
+  if (typeof amount === "bigint") {
+    return amount;
+  }
+  if (typeof amount !== "string") {
+    throw new Error(`Invalid amount: expected string or bigint, got ${typeof amount}`);
+  }
+  if (amount.trim() === "") {
+    throw new Error("Invalid amount: empty string");
+  }
+  if (!/^-?\d+$/.test(amount)) {
+    throw new Error(`Invalid amount: "${amount}" is not a valid integer string`);
+  }
+  const result = BigInt(amount);
+  if (result < 0n) {
+    throw new Error(`Invalid amount: "${amount}" must be non-negative`);
+  }
+  return result;
+}
+function validateBps(bps) {
+  if (typeof bps !== "number" || !Number.isFinite(bps)) {
+    throw new Error(`Invalid bps: expected a finite number, got ${bps}`);
+  }
+  if (!Number.isInteger(bps)) {
+    throw new Error(`Invalid bps: ${bps} must be an integer`);
+  }
+  if (bps < 0) {
+    throw new Error(`Invalid bps: ${bps} must be non-negative`);
+  }
+  if (bps > MAX_BPS2) {
+    throw new Error(`Invalid bps: ${bps} exceeds maximum of ${MAX_BPS2} (100%)`);
+  }
+}
+function calculateFee(amount, bps) {
+  const amountBigInt = parseAmount(amount);
+  validateBps(bps);
+  const fee = amountBigInt * BigInt(bps) / BPS_DIVISOR;
+  return fee.toString();
+}
+function calculateAmountAfterFee(amount, bps) {
+  const amountBigInt = parseAmount(amount);
+  validateBps(bps);
+  const fee = BigInt(calculateFee(amountBigInt, bps));
+  return (amountBigInt - fee).toString();
+}
+
+class RuleEngine {
+  matcher;
+  tokenRegistry;
+  feeConfig;
+  constructor(feeConfig, options) {
+    const validation = validateConfig(feeConfig);
+    if (!validation.valid) {
+      throw new Error(`Invalid fee config: ${validation.errors.map((e) => `${e.path}: ${e.message}`).join(", ")}`);
+    }
+    this.feeConfig = feeConfig;
+    this.tokenRegistry = new CachedTokenRegistry({
+      url: options?.tokenRegistryUrl ?? DEFAULT_TOKEN_REGISTRY_URL,
+      cacheTtlMs: options?.tokenRegistryCacheTtlMs ?? DEFAULT_CACHE_TTL_MS
+    });
+    this.matcher = new RuleMatcher(this.feeConfig, this.tokenRegistry);
+  }
+  async initialize() {
+    await this.tokenRegistry.refresh();
+  }
+  async ensureReady() {
+    await this.tokenRegistry.ensureFresh();
+  }
+  match(request) {
+    return this.matcher.match(request);
+  }
+  async matchWithRefresh(request) {
+    await this.ensureReady();
+    return this.match(request);
+  }
+  getTokenRegistrySize() {
+    return this.tokenRegistry.size;
+  }
+  getFeeConfig() {
+    return this.feeConfig;
+  }
+}
+export {
+  validateConfig,
+  getTotalBps,
+  calculateFee,
+  calculateAmountAfterFee,
+  RuleMatcher,
+  RuleEngine,
+  CachedTokenRegistry
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "intents-1click-rule-engine",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "description": "Fee configuration rule engine for NEAR Intents 1Click API",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -9,14 +9,15 @@
   "exports": {
     ".": {
       "types": "./dist/index.d.ts",
-      "import": "./dist/index.js"
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
     }
   },
   "files": [
     "dist"
   ],
   "scripts": {
-    "build": "tsc -p tsconfig.build.json",
+    "build": "bun build index.ts --outdir dist --target node && bun tsc -p tsconfig.build.json --emitDeclarationOnly",
     "prepublishOnly": "bun run build",
     "test": "bun test",
     "typecheck": "tsc --noEmit"

package/dist/src/matcher.js

@@ -1,110 +0,0 @@
-export class RuleMatcher {
-    rules;
-    defaultFee;
-    tokenRegistry;
-    constructor(config, tokenRegistry) {
-        this.defaultFee = config.default_fee;
-        this.rules = this.sortRulesByPriority(config.rules);
-        this.tokenRegistry = tokenRegistry;
-    }
-    sortRulesByPriority(rules) {
-        return [...rules].sort((a, b) => {
-            const priorityA = a.priority ?? 100;
-            const priorityB = b.priority ?? 100;
-            return priorityB - priorityA;
-        });
-    }
-    matchesSinglePattern(pattern, value) {
-        if (pattern === "*")
-            return true;
-        if (pattern.startsWith("!")) {
-            return value !== pattern.slice(1);
-        }
-        return pattern === value;
-    }
-    matchesValue(pattern, value) {
-        if (Array.isArray(pattern)) {
-            return pattern.some((p) => this.matchesSinglePattern(p, value));
-        }
-        return this.matchesSinglePattern(pattern, value);
-    }
-    matchesToken(matcher, token) {
-        const matchedBy = {};
-        if (matcher.assetId) {
-            if (!this.matchesValue(matcher.assetId, token.assetId)) {
-                return null;
-            }
-            matchedBy.assetId = true;
-        }
-        if (matcher.blockchain) {
-            if (!this.matchesValue(matcher.blockchain, token.blockchain)) {
-                return null;
-            }
-            matchedBy.blockchain = true;
-        }
-        if (matcher.symbol) {
-            if (!this.matchesValue(matcher.symbol, token.symbol)) {
-                return null;
-            }
-            matchedBy.symbol = true;
-        }
-        return { token, matchedBy };
-    }
-    parseDate(dateStr, fieldName) {
-        const timestamp = new Date(dateStr).getTime();
-        if (Number.isNaN(timestamp)) {
-            throw new Error(`Invalid ${fieldName}: "${dateStr}" is not a valid date string`);
-        }
-        return timestamp;
-    }
-    isRuleValidNow(rule) {
-        const now = Date.now();
-        if (rule.valid_from) {
-            const from = this.parseDate(rule.valid_from, "valid_from");
-            if (now < from)
-                return false;
-        }
-        if (rule.valid_until) {
-            const until = this.parseDate(rule.valid_until, "valid_until");
-            if (now > until)
-                return false;
-        }
-        return true;
-    }
-    match(request) {
-        const originToken = this.tokenRegistry.getToken(request.originAsset);
-        const destinationToken = this.tokenRegistry.getToken(request.destinationAsset);
-        if (!originToken || !destinationToken) {
-            return {
-                matched: false,
-                fee: this.defaultFee,
-            };
-        }
-        for (const rule of this.rules) {
-            if (!rule.enabled)
-                continue;
-            if (!this.isRuleValidNow(rule))
-                continue;
-            const inMatchInfo = this.matchesToken(rule.match.in, originToken);
-            const outMatchInfo = this.matchesToken(rule.match.out, destinationToken);
-            if (inMatchInfo && outMatchInfo) {
-                return {
-                    matched: true,
-                    rule,
-                    fee: rule.fee,
-                    matchDetails: {
-                        originToken,
-                        destinationToken,
-                        in: inMatchInfo,
-                        out: outMatchInfo,
-                    },
-                };
-            }
-        }
-        return {
-            matched: false,
-            fee: this.defaultFee,
-            matchDetails: { originToken, destinationToken },
-        };
-    }
-}

package/dist/src/rule-engine.js

@@ -1,94 +0,0 @@
-import { RuleMatcher } from "./matcher";
-import { CachedTokenRegistry } from "./token-registry";
-import { validateConfig } from "./validator";
-const DEFAULT_TOKEN_REGISTRY_URL = "https://1click.chaindefuser.com/v0/tokens";
-const DEFAULT_CACHE_TTL_MS = 3600000; // 1 hour
-const BPS_DIVISOR = 10000n;
-const MAX_BPS = 10000; // 100% fee cap
-export function getTotalBps(fee) {
-    if (Array.isArray(fee)) {
-        return fee.reduce((sum, f) => sum + f.bps, 0);
-    }
-    return fee.bps;
-}
-function parseAmount(amount) {
-    if (typeof amount === "bigint") {
-        return amount;
-    }
-    if (typeof amount !== "string") {
-        throw new Error(`Invalid amount: expected string or bigint, got ${typeof amount}`);
-    }
-    if (amount.trim() === "") {
-        throw new Error("Invalid amount: empty string");
-    }
-    if (!/^-?\d+$/.test(amount)) {
-        throw new Error(`Invalid amount: "${amount}" is not a valid integer string`);
-    }
-    const result = BigInt(amount);
-    if (result < 0n) {
-        throw new Error(`Invalid amount: "${amount}" must be non-negative`);
-    }
-    return result;
-}
-function validateBps(bps) {
-    if (typeof bps !== "number" || !Number.isFinite(bps)) {
-        throw new Error(`Invalid bps: expected a finite number, got ${bps}`);
-    }
-    if (!Number.isInteger(bps)) {
-        throw new Error(`Invalid bps: ${bps} must be an integer`);
-    }
-    if (bps < 0) {
-        throw new Error(`Invalid bps: ${bps} must be non-negative`);
-    }
-    if (bps > MAX_BPS) {
-        throw new Error(`Invalid bps: ${bps} exceeds maximum of ${MAX_BPS} (100%)`);
-    }
-}
-export function calculateFee(amount, bps) {
-    const amountBigInt = parseAmount(amount);
-    validateBps(bps);
-    const fee = (amountBigInt * BigInt(bps)) / BPS_DIVISOR;
-    return fee.toString();
-}
-export function calculateAmountAfterFee(amount, bps) {
-    const amountBigInt = parseAmount(amount);
-    validateBps(bps);
-    const fee = BigInt(calculateFee(amountBigInt, bps));
-    return (amountBigInt - fee).toString();
-}
-export class RuleEngine {
-    matcher;
-    tokenRegistry;
-    feeConfig;
-    constructor(feeConfig, options) {
-        const validation = validateConfig(feeConfig);
-        if (!validation.valid) {
-            throw new Error(`Invalid fee config: ${validation.errors.map((e) => `${e.path}: ${e.message}`).join(", ")}`);
-        }
-        this.feeConfig = feeConfig;
-        this.tokenRegistry = new CachedTokenRegistry({
-            url: options?.tokenRegistryUrl ?? DEFAULT_TOKEN_REGISTRY_URL,
-            cacheTtlMs: options?.tokenRegistryCacheTtlMs ?? DEFAULT_CACHE_TTL_MS,
-        });
-        this.matcher = new RuleMatcher(this.feeConfig, this.tokenRegistry);
-    }
-    async initialize() {
-        await this.tokenRegistry.refresh();
-    }
-    async ensureReady() {
-        await this.tokenRegistry.ensureFresh();
-    }
-    match(request) {
-        return this.matcher.match(request);
-    }
-    async matchWithRefresh(request) {
-        await this.ensureReady();
-        return this.match(request);
-    }
-    getTokenRegistrySize() {
-        return this.tokenRegistry.size;
-    }
-    getFeeConfig() {
-        return this.feeConfig;
-    }
-}

package/dist/src/token-registry.js

@@ -1,78 +0,0 @@
-function isValidTokenResponse(token) {
-    if (typeof token !== "object" || token === null)
-        return false;
-    const t = token;
-    return (typeof t.assetId === "string" &&
-        typeof t.blockchain === "string" &&
-        typeof t.symbol === "string" &&
-        typeof t.decimals === "number");
-}
-export class CachedTokenRegistry {
-    config;
-    cache = new Map();
-    lastFetchTime = 0;
-    refreshPromise = null;
-    constructor(config) {
-        this.config = config;
-    }
-    isCacheValid() {
-        return Date.now() - this.lastFetchTime < this.config.cacheTtlMs;
-    }
-    async refresh() {
-        // If a refresh is already in progress, return the existing promise
-        if (this.refreshPromise) {
-            return this.refreshPromise;
-        }
-        this.refreshPromise = this.doRefresh();
-        try {
-            await this.refreshPromise;
-        }
-        finally {
-            this.refreshPromise = null;
-        }
-    }
-    async doRefresh() {
-        const response = await fetch(this.config.url);
-        if (!response.ok) {
-            throw new Error(`Failed to fetch tokens: ${response.status} ${response.statusText}`);
-        }
-        const data = await response.json();
-        if (!Array.isArray(data)) {
-            throw new Error(`Invalid token registry response: expected array, got ${typeof data}`);
-        }
-        const newCache = new Map();
-        const invalidTokens = [];
-        for (let i = 0; i < data.length; i++) {
-            const token = data[i];
-            if (!isValidTokenResponse(token)) {
-                invalidTokens.push(i);
-                continue;
-            }
-            newCache.set(token.assetId, {
-                assetId: token.assetId,
-                blockchain: token.blockchain,
-                symbol: token.symbol,
-                decimals: token.decimals,
-            });
-        }
-        if (invalidTokens.length > 0 && newCache.size === 0) {
-            throw new Error(`Invalid token registry response: all ${data.length} tokens failed validation`);
-        }
-        this.cache = newCache;
-        this.lastFetchTime = Date.now();
-    }
-    async ensureFresh() {
-        if (!this.isCacheValid()) {
-            await this.refresh();
-        }
-    }
-    getToken(assetId) {
-        return this.cache.get(assetId);
-    }
-    getAllTokens() {
-        return Array.from(this.cache.values());
-    }
-    get size() {
-        return this.cache.size;
-    }
-}

package/dist/src/types.js

@@ -1 +0,0 @@
-export {};

package/dist/src/validator.js

@@ -1,175 +0,0 @@
-const NEAR_ACCOUNT_REGEX = /^(?:[a-z\d]+[-_])*[a-z\d]+(?:\.[a-z\d]+[-_]*[a-z\d]+)*$/;
-const NEAR_IMPLICIT_ACCOUNT_REGEX = /^[a-f0-9]{64}$/;
-const MAX_BPS = 10000; // 100% fee cap
-function isValidNearAccount(account) {
-    if (account.length < 2 || account.length > 64)
-        return false;
-    return NEAR_ACCOUNT_REGEX.test(account) || NEAR_IMPLICIT_ACCOUNT_REGEX.test(account);
-}
-function isValidDateString(dateStr) {
-    const timestamp = new Date(dateStr).getTime();
-    return !Number.isNaN(timestamp);
-}
-function validateSingleFee(fee, path) {
-    const errors = [];
-    if (fee.type !== "bps") {
-        errors.push({ path: `${path}.type`, message: "fee.type must be 'bps'" });
-    }
-    if (typeof fee.bps !== "number" || fee.bps < 0) {
-        errors.push({ path: `${path}.bps`, message: "fee.bps must be a non-negative number" });
-    }
-    else if (fee.bps > MAX_BPS) {
-        errors.push({ path: `${path}.bps`, message: `fee.bps exceeds maximum of ${MAX_BPS} (100%)` });
-    }
-    if (!fee.recipient || typeof fee.recipient !== "string") {
-        errors.push({ path: `${path}.recipient`, message: "fee.recipient is required and must be a string" });
-    }
-    else if (!isValidNearAccount(fee.recipient)) {
-        errors.push({ path: `${path}.recipient`, message: "fee.recipient must be a valid NEAR account" });
-    }
-    return errors;
-}
-function validateFee(fee, path) {
-    const errors = [];
-    if (Array.isArray(fee)) {
-        if (fee.length === 0) {
-            errors.push({ path, message: "fee array must not be empty" });
-            return errors;
-        }
-        for (let i = 0; i < fee.length; i++) {
-            errors.push(...validateSingleFee(fee[i], `${path}[${i}]`));
-        }
-    }
-    else if (fee && typeof fee === "object") {
-        errors.push(...validateSingleFee(fee, path));
-    }
-    else {
-        errors.push({ path, message: "fee is required" });
-    }
-    return errors;
-}
-function isNonEmptyStringOrArray(value) {
-    if (typeof value === "string")
-        return value.length > 0;
-    if (Array.isArray(value))
-        return value.length > 0 && value.every((v) => typeof v === "string" && v.length > 0);
-    return false;
-}
-function validateTokenMatcher(matcher, path) {
-    const errors = [];
-    // Check for empty arrays
-    if (Array.isArray(matcher.blockchain) && matcher.blockchain.length === 0) {
-        errors.push({ path: `${path}.blockchain`, message: "blockchain array must not be empty" });
-    }
-    if (Array.isArray(matcher.symbol) && matcher.symbol.length === 0) {
-        errors.push({ path: `${path}.symbol`, message: "symbol array must not be empty" });
-    }
-    if (Array.isArray(matcher.assetId) && matcher.assetId.length === 0) {
-        errors.push({ path: `${path}.assetId`, message: "assetId array must not be empty" });
-    }
-    // Check for empty strings in arrays
-    if (Array.isArray(matcher.blockchain) && matcher.blockchain.some((v) => v === "")) {
-        errors.push({ path: `${path}.blockchain`, message: "blockchain array must not contain empty strings" });
-    }
-    if (Array.isArray(matcher.symbol) && matcher.symbol.some((v) => v === "")) {
-        errors.push({ path: `${path}.symbol`, message: "symbol array must not contain empty strings" });
-    }
-    if (Array.isArray(matcher.assetId) && matcher.assetId.some((v) => v === "")) {
-        errors.push({ path: `${path}.assetId`, message: "assetId array must not contain empty strings" });
-    }
-    const hasIdentifier = isNonEmptyStringOrArray(matcher.blockchain) ||
-        isNonEmptyStringOrArray(matcher.symbol) ||
-        isNonEmptyStringOrArray(matcher.assetId);
-    if (!hasIdentifier) {
-        errors.push({
-            path,
-            message: "At least one of blockchain, symbol, or assetId must be defined",
-        });
-    }
-    return errors;
-}
-function validateRule(rule, index) {
-    const errors = [];
-    const path = `rules[${index}]`;
-    if (!rule.id || typeof rule.id !== "string") {
-        errors.push({ path: `${path}.id`, message: "id is required and must be a string" });
-    }
-    if (typeof rule.enabled !== "boolean") {
-        errors.push({ path: `${path}.enabled`, message: "enabled is required and must be a boolean" });
-    }
-    if (rule.priority !== undefined && (typeof rule.priority !== "number" || rule.priority < 0)) {
-        errors.push({ path: `${path}.priority`, message: "priority must be a non-negative number" });
-    }
-    if (!rule.match) {
-        errors.push({ path: `${path}.match`, message: "match is required" });
-    }
-    else {
-        if (!rule.match.in) {
-            errors.push({ path: `${path}.match.in`, message: "match.in is required" });
-        }
-        else {
-            errors.push(...validateTokenMatcher(rule.match.in, `${path}.match.in`));
-        }
-        if (!rule.match.out) {
-            errors.push({ path: `${path}.match.out`, message: "match.out is required" });
-        }
-        else {
-            errors.push(...validateTokenMatcher(rule.match.out, `${path}.match.out`));
-        }
-    }
-    if (!rule.fee) {
-        errors.push({ path: `${path}.fee`, message: "fee is required" });
-    }
-    else {
-        errors.push(...validateFee(rule.fee, `${path}.fee`));
-    }
-    if (rule.valid_from !== undefined) {
-        if (typeof rule.valid_from !== "string") {
-            errors.push({ path: `${path}.valid_from`, message: "valid_from must be a string" });
-        }
-        else if (!isValidDateString(rule.valid_from)) {
-            errors.push({ path: `${path}.valid_from`, message: `valid_from "${rule.valid_from}" is not a valid date string` });
-        }
-    }
-    if (rule.valid_until !== undefined) {
-        if (typeof rule.valid_until !== "string") {
-            errors.push({ path: `${path}.valid_until`, message: "valid_until must be a string" });
-        }
-        else if (!isValidDateString(rule.valid_until)) {
-            errors.push({ path: `${path}.valid_until`, message: `valid_until "${rule.valid_until}" is not a valid date string` });
-        }
-    }
-    return errors;
-}
-export function validateConfig(config) {
-    const errors = [];
-    if (!config.version || typeof config.version !== "string") {
-        errors.push({ path: "version", message: "version is required and must be a string" });
-    }
-    if (!config.default_fee) {
-        errors.push({ path: "default_fee", message: "default_fee is required" });
-    }
-    else {
-        errors.push(...validateFee(config.default_fee, "default_fee"));
-    }
-    if (!Array.isArray(config.rules)) {
-        errors.push({ path: "rules", message: "rules must be an array" });
-    }
-    else {
-        const ruleIds = new Set();
-        for (let i = 0; i < config.rules.length; i++) {
-            const rule = config.rules[i];
-            errors.push(...validateRule(rule, i));
-            if (rule.id) {
-                if (ruleIds.has(rule.id)) {
-                    errors.push({ path: `rules[${i}].id`, message: `Duplicate rule id: ${rule.id}` });
-                }
-                ruleIds.add(rule.id);
-            }
-        }
-    }
-    return {
-        valid: errors.length === 0,
-        errors,
-    };
-}