@lukso/transaction-decoder 1.0.1-dev.0f1bea5

package/dist/server.js

@@ -0,0 +1,644 @@
+import {
+  fetchMultipleAddresses
+} from "./chunk-GGBHTWJL.js";
+import {
+  __name,
+  collectDataKeys,
+  createDebug,
+  decodeTransaction,
+  needsEnhancement,
+  pluginRegistry
+} from "./chunk-XVHJWV5U.js";
+
+// src/server/addressResolver.ts
+var ServerAddressResolver = class {
+  constructor(graphqlEndpoint, chain, caches) {
+    this.graphqlEndpoint = graphqlEndpoint;
+    this.chain = chain;
+    this.caches = caches;
+    this.cacheAdapter = {
+      get: /* @__PURE__ */ __name((key) => this.caches.getAddress(key), "get"),
+      set: /* @__PURE__ */ __name((key, value) => this.caches.setAddress(key, value), "set"),
+      has: /* @__PURE__ */ __name((key) => this.caches.hasAddress(key), "has"),
+      getMany: /* @__PURE__ */ __name((keys) => this.caches.getAddresses(keys), "getMany")
+    };
+  }
+  static {
+    __name(this, "ServerAddressResolver");
+  }
+  cacheAdapter;
+  /**
+   * Resolve addresses, using cache when possible
+   */
+  async resolveAddresses(addresses) {
+    return fetchMultipleAddresses(
+      addresses,
+      this.graphqlEndpoint,
+      this.cacheAdapter
+    );
+  }
+  /**
+   * Resolve addresses with timeout
+   */
+  async resolveAddressesWithTimeout(addresses, timeoutMs) {
+    return Promise.race([
+      this.resolveAddresses(addresses),
+      new Promise((resolve) => {
+        setTimeout(() => {
+          const results = this.caches.getAddresses(addresses);
+          resolve(results);
+        }, timeoutMs);
+      })
+    ]);
+  }
+  /**
+   * Warm the cache with specific addresses
+   */
+  async warmCache(addresses) {
+    await this.resolveAddresses(addresses);
+  }
+};
+
+// src/server/caches.ts
+import { LRUCache } from "lru-cache";
+var ServerDecoderCaches = class {
+  static {
+    __name(this, "ServerDecoderCaches");
+  }
+  // Level 1: Decoded transaction cache (keyed by transaction hash)
+  transactionCache;
+  transactionStats = { hits: 0, misses: 0 };
+  // Level 2: Address metadata cache (keyed by address or address:tokenId)
+  addressCache;
+  addressStats = { hits: 0, misses: 0 };
+  // Level 3: Contract ABI cache (keyed by address)
+  abiCache;
+  abiStats = { hits: 0, misses: 0 };
+  // Level 4: Schema decode cache (keyed by key:value)
+  schemaCache;
+  schemaStats = { hits: 0, misses: 0 };
+  constructor(options = {}) {
+    this.transactionCache = new LRUCache({
+      max: options.transactionCacheSize || 1e4,
+      ttl: 1e3 * 60 * 60,
+      // 1 hour TTL
+      updateAgeOnGet: true,
+      updateAgeOnHas: true
+    });
+    this.addressCache = new LRUCache({
+      max: options.addressCacheSize || 5e4,
+      ttl: 1e3 * 60 * 60 * 24,
+      // 24 hour TTL
+      updateAgeOnGet: true,
+      updateAgeOnHas: true
+    });
+    this.abiCache = new LRUCache({
+      max: options.abiCacheSize || 5e3,
+      ttl: 1e3 * 60 * 60 * 24 * 7,
+      // 7 day TTL (ABIs rarely change)
+      updateAgeOnGet: true,
+      updateAgeOnHas: true
+    });
+    this.schemaCache = new LRUCache({
+      max: options.schemaCacheSize || 1e4,
+      ttl: 1e3 * 60 * 60,
+      // 1 hour TTL
+      updateAgeOnGet: true,
+      updateAgeOnHas: true
+    });
+  }
+  /**
+   * Get cache key for a data key (address or address:tokenId)
+   */
+  getDataKeyCacheKey(key) {
+    return key.toLowerCase();
+  }
+  // Transaction cache methods
+  getTransaction(hash) {
+    const result = this.transactionCache.get(hash.toLowerCase());
+    if (result) {
+      this.transactionStats.hits++;
+      return { ...result, cached: true };
+    }
+    this.transactionStats.misses++;
+    return void 0;
+  }
+  setTransaction(hash, result) {
+    this.transactionCache.set(hash.toLowerCase(), result);
+  }
+  // Address cache methods
+  getAddress(key) {
+    const cacheKey = this.getDataKeyCacheKey(key);
+    const result = this.addressCache.get(cacheKey);
+    if (result) {
+      this.addressStats.hits++;
+      return result;
+    }
+    this.addressStats.misses++;
+    return void 0;
+  }
+  setAddress(key, data) {
+    const cacheKey = this.getDataKeyCacheKey(key);
+    this.addressCache.set(cacheKey, data);
+  }
+  hasAddress(key) {
+    return this.addressCache.has(this.getDataKeyCacheKey(key));
+  }
+  getAddresses(keys) {
+    const results = /* @__PURE__ */ new Map();
+    for (const key of keys) {
+      const data = this.getAddress(key);
+      if (data) {
+        results.set(key, data);
+      }
+    }
+    return results;
+  }
+  // ABI cache methods
+  getAbi(address) {
+    const result = this.abiCache.get(address.toLowerCase());
+    if (result) {
+      this.abiStats.hits++;
+      return result;
+    }
+    this.abiStats.misses++;
+    return void 0;
+  }
+  setAbi(address, abi) {
+    this.abiCache.set(address.toLowerCase(), abi);
+  }
+  hasAbi(address) {
+    return this.abiCache.has(address.toLowerCase());
+  }
+  // Schema cache methods
+  getSchema(key, value) {
+    const cacheKey = `${key}:${value}`;
+    const result = this.schemaCache.get(cacheKey);
+    if (result) {
+      this.schemaStats.hits++;
+      return result;
+    }
+    this.schemaStats.misses++;
+    return void 0;
+  }
+  setSchema(key, value, info) {
+    const cacheKey = `${key}:${value}`;
+    this.schemaCache.set(cacheKey, info);
+  }
+  // Cache management
+  clear() {
+    this.transactionCache.clear();
+    this.addressCache.clear();
+    this.abiCache.clear();
+    this.schemaCache.clear();
+    this.transactionStats = { hits: 0, misses: 0 };
+    this.addressStats = { hits: 0, misses: 0 };
+    this.abiStats = { hits: 0, misses: 0 };
+    this.schemaStats = { hits: 0, misses: 0 };
+  }
+  getStats() {
+    const calculateHitRate = /* @__PURE__ */ __name((stats) => {
+      const total = stats.hits + stats.misses;
+      return total > 0 ? stats.hits / total : 0;
+    }, "calculateHitRate");
+    return {
+      transactions: {
+        size: this.transactionCache.size,
+        maxSize: this.transactionCache.max,
+        hits: this.transactionStats.hits,
+        misses: this.transactionStats.misses,
+        hitRate: calculateHitRate(this.transactionStats)
+      },
+      addresses: {
+        size: this.addressCache.size,
+        maxSize: this.addressCache.max,
+        hits: this.addressStats.hits,
+        misses: this.addressStats.misses,
+        hitRate: calculateHitRate(this.addressStats)
+      },
+      abis: {
+        size: this.abiCache.size,
+        maxSize: this.abiCache.max,
+        hits: this.abiStats.hits,
+        misses: this.abiStats.misses,
+        hitRate: calculateHitRate(this.abiStats)
+      },
+      schemas: {
+        size: this.schemaCache.size,
+        maxSize: this.schemaCache.max,
+        hits: this.schemaStats.hits,
+        misses: this.schemaStats.misses,
+        hitRate: calculateHitRate(this.schemaStats)
+      }
+    };
+  }
+};
+
+// src/server/decodeTransactionSync.ts
+async function decodeTransactionSync(transaction, options, caches) {
+  const startTime = Date.now();
+  const { timeoutMs = 800, enableEnhancement = true, chain } = options;
+  if (transaction.hash) {
+    const cached = caches.getTransaction(transaction.hash);
+    if (cached) {
+      return cached;
+    }
+  }
+  try {
+    const phase1Start = Date.now();
+    const plugins = await pluginRegistry.getAll({ syncOnly: true });
+    const schemaPlugins = pluginRegistry.getAllSchema();
+    const immediateOptions = {
+      chain,
+      plugins,
+      schemaPlugins,
+      wrappers: [],
+      async: false
+    };
+    const immediateResult = await decodeTransaction(
+      transaction,
+      immediateOptions
+    );
+    if (!immediateResult) {
+      return {
+        ...createErrorResult(transaction),
+        phase: "immediate",
+        cached: false,
+        timeTaken: Date.now() - startTime
+      };
+    }
+    let currentResult = immediateResult;
+    let phase = "immediate";
+    if (immediateOptions.wrappers.length > 0) {
+      ;
+      currentResult.wrappers = immediateOptions.wrappers;
+    }
+    const addresses = collectDataKeys(currentResult);
+    currentResult.addresses = addresses;
+    const phase1Time = Date.now() - phase1Start;
+    if (enableEnhancement && phase1Time < timeoutMs * 0.6) {
+      if (!needsEnhancement(currentResult)) {
+        phase = "enhanced";
+      } else {
+        try {
+          const allPlugins = await pluginRegistry.getAll();
+          const enhancedOptions = {
+            chain,
+            plugins: allPlugins,
+            schemaPlugins,
+            wrappers: [],
+            async: true
+          };
+          const enhancedResult = await Promise.race([
+            decodeTransaction(transaction, enhancedOptions),
+            // Timeout for phase 2
+            new Promise(
+              (resolve) => setTimeout(() => resolve(null), timeoutMs * 0.6 - phase1Time)
+            )
+          ]);
+          if (enhancedResult) {
+            currentResult = enhancedResult;
+            phase = "enhanced";
+            const allWrappers = [
+              ...immediateOptions.wrappers || [],
+              ...enhancedOptions.wrappers || []
+            ].filter(
+              (w, i, arr) => (
+                // Deduplicate by checking if this is the first occurrence
+                arr.findIndex(
+                  (x) => JSON.stringify(x) === JSON.stringify(w)
+                ) === i
+              )
+            );
+            if (allWrappers.length > 0) {
+              ;
+              currentResult.wrappers = allWrappers;
+            }
+            currentResult.addresses = collectDataKeys(currentResult);
+          }
+        } catch (error) {
+          console.error("Enhancement failed:", error);
+        }
+      }
+    }
+    const result = {
+      ...currentResult,
+      phase,
+      cached: false,
+      timeTaken: Date.now() - startTime
+    };
+    if (transaction.hash) {
+      caches.setTransaction(transaction.hash, result);
+    }
+    return result;
+  } catch (error) {
+    console.error("Failed to decode transaction:", error);
+    return {
+      ...createErrorResult(transaction),
+      phase: "immediate",
+      cached: false,
+      timeTaken: Date.now() - startTime
+    };
+  }
+}
+__name(decodeTransactionSync, "decodeTransactionSync");
+function createErrorResult(transaction) {
+  return {
+    ...transaction,
+    isDecoded: false,
+    resultType: "error",
+    errorType: "UNKNOWN",
+    sig: "0x",
+    addresses: []
+  };
+}
+__name(createErrorResult, "createErrorResult");
+
+// src/server/decodeTransactionsBatch.ts
+async function decodeTransactionsBatch(transactions, options, caches) {
+  const startTime = Date.now();
+  const { timeoutMs = 800, enableEnhancement = true, chain } = options;
+  const results = transactions.map((tx) => {
+    if (tx.transactionHash) {
+      const cached = caches.getTransaction(tx.transactionHash);
+      if (cached) return cached;
+    }
+    return null;
+  });
+  const uncachedIndexes = [];
+  const uncachedTransactions = [];
+  results.forEach((result, index) => {
+    if (!result) {
+      uncachedIndexes.push(index);
+      uncachedTransactions.push(transactions[index]);
+    }
+  });
+  if (uncachedTransactions.length === 0) {
+    return {
+      results
+    };
+  }
+  try {
+    const syncPlugins = await pluginRegistry.getAll({ syncOnly: true });
+    const allPlugins = await pluginRegistry.getAll();
+    const schemaPlugins = pluginRegistry.getAllSchema();
+    const phase1Start = Date.now();
+    const immediateOptionsArray = uncachedTransactions.map(() => ({
+      chain,
+      plugins: syncPlugins,
+      schemaPlugins,
+      wrappers: [],
+      async: false
+    }));
+    const immediateResults = (await Promise.all(
+      uncachedTransactions.map(async (tx, i) => {
+        return await decodeTransaction(tx, immediateOptionsArray[i]);
+      })
+    )).filter(Boolean);
+    const newResults = immediateResults.map((result, i) => {
+      const data = result || createErrorResult2(uncachedTransactions[i]);
+      if (immediateOptionsArray[i].wrappers.length > 0) {
+        ;
+        data.wrappers = immediateOptionsArray[i].wrappers;
+      }
+      data.addresses = collectDataKeys(data);
+      data.timeTaken = Date.now() - startTime;
+      return data;
+    }).filter(Boolean);
+    const phase1Time = Date.now() - phase1Start;
+    if (enableEnhancement && phase1Time < timeoutMs * 0.6) {
+      try {
+        const enhancedOptionsArray = uncachedTransactions.map(() => ({
+          chain,
+          plugins: allPlugins,
+          schemaPlugins,
+          wrappers: [],
+          async: true
+        }));
+        const enhancePromises = uncachedTransactions.map((tx, i) => {
+          if (!immediateResults[i]) return null;
+          if (!needsEnhancement(immediateResults[i])) {
+            return null;
+          }
+          return decodeTransaction(tx, enhancedOptionsArray[i]);
+        });
+        const remainingTime = timeoutMs * 0.6 - phase1Time;
+        const enhancedResults = await Promise.all(enhancePromises);
+        enhancedResults.forEach((enhanced, i) => {
+          if (enhanced) {
+            const immediateWrappers = immediateOptionsArray[i].wrappers || [];
+            const enhancedWrappers = enhancedOptionsArray[i].wrappers || [];
+            const allWrappers = [
+              ...immediateWrappers,
+              ...enhancedWrappers
+            ].filter(
+              (w, idx, arr) => (
+                // Deduplicate by checking if this is the first occurrence
+                arr.findIndex(
+                  (x) => JSON.stringify(x) === JSON.stringify(w)
+                ) === idx
+              )
+            );
+            newResults[i] = enhanced;
+            if (allWrappers.length > 0) {
+              ;
+              newResults[i].wrappers = allWrappers;
+            }
+            newResults[i].addresses = collectDataKeys(enhanced);
+            newResults[i].phase = "enhanced";
+          } else if (immediateResults[i] && !needsEnhancement(immediateResults[i])) {
+            newResults[i].phase = "enhanced";
+          }
+        });
+      } catch (error) {
+        console.error("Batch enhancement failed:", error);
+      }
+    }
+    const totalTime = Date.now() - startTime;
+    newResults.forEach((result) => {
+      result.timeTaken = totalTime;
+    });
+    newResults.forEach((result, i) => {
+      const tx = uncachedTransactions[i];
+      if (tx.hash) {
+        caches.setTransaction(tx.hash, result);
+      }
+    });
+    uncachedIndexes.forEach((originalIndex, i) => {
+      results[originalIndex] = newResults[i];
+    });
+    return {
+      results
+    };
+  } catch (error) {
+    console.error("Batch decode failed:", error);
+    uncachedIndexes.forEach((originalIndex) => {
+      results[originalIndex] = {
+        ...createErrorResult2(transactions[originalIndex]),
+        phase: "immediate",
+        cached: false,
+        timeTaken: Date.now() - startTime
+      };
+    });
+    return {
+      results
+    };
+  }
+}
+__name(decodeTransactionsBatch, "decodeTransactionsBatch");
+function createErrorResult2(transaction) {
+  return {
+    ...transaction,
+    isDecoded: false,
+    resultType: "error",
+    errorType: "UNKNOWN",
+    sig: "0x",
+    addresses: []
+  };
+}
+__name(createErrorResult2, "createErrorResult");
+
+// src/server/finishDecoding.ts
+var debug = createDebug("decoder:finishDecoding");
+async function finishDecoding(transaction, options, caches) {
+  const startTime = Date.now();
+  const {
+    timeoutMs = 5e3,
+    // Give more time for finishing
+    chain
+  } = options;
+  try {
+    const txHash = transaction.hash || transaction.transactionHash;
+    if (txHash) {
+      const cached = caches.getTransaction(txHash);
+      if (cached && cached.enhancementAttempted) {
+        return {
+          ...cached,
+          cached: true,
+          timeTaken: 0
+        };
+      }
+    }
+    const allPlugins = await pluginRegistry.getAll();
+    const schemaPlugins = pluginRegistry.getAllSchema();
+    const enhancedOptions = {
+      chain,
+      plugins: allPlugins,
+      schemaPlugins,
+      wrappers: [],
+      async: true
+    };
+    const {
+      wrappers,
+      children: _children,
+      addresses: _addresses,
+      ...transactionWithoutWrappers
+    } = transaction;
+    const enhancedResult = await decodeTransaction(
+      transactionWithoutWrappers,
+      enhancedOptions
+    );
+    if (!enhancedResult) {
+      if (txHash) {
+        caches.setTransaction(txHash, {
+          ...transaction,
+          enhancementAttempted: true
+        });
+      }
+      return transaction;
+    }
+    const result = {
+      ...enhancedResult,
+      // Only add wrappers if there are any
+      ...(wrappers?.length || 0) > 0 ? { wrappers } : {},
+      cached: false,
+      timeTaken: Date.now() - startTime,
+      enhancementAttempted: true
+    };
+    if (txHash) {
+      caches.setTransaction(txHash, result);
+    }
+    return result;
+  } catch (error) {
+    console.error("Failed to finish decoding transaction:", error);
+    return {
+      ...createErrorResult3(transaction),
+      phase: "immediate",
+      cached: false,
+      timeTaken: Date.now() - startTime
+    };
+  }
+}
+__name(finishDecoding, "finishDecoding");
+function createErrorResult3(transaction) {
+  return {
+    ...transaction,
+    resultType: "error",
+    errorType: "UNKNOWN",
+    sig: "0x",
+    addresses: []
+  };
+}
+__name(createErrorResult3, "createErrorResult");
+
+// src/server/index.ts
+function createServerDecoder(config) {
+  const caches = new ServerDecoderCaches({
+    transactionCacheSize: config.transactionCacheSize,
+    addressCacheSize: config.addressCacheSize,
+    abiCacheSize: config.abiCacheSize,
+    schemaCacheSize: config.schemaCacheSize
+  });
+  const addressResolver = new ServerAddressResolver(
+    config.graphqlEndpoint,
+    config.defaultChain,
+    caches
+  );
+  return {
+    async decodeTransaction(transaction, options) {
+      const opts = {
+        chain: config.defaultChain,
+        timeoutMs: config.defaultTimeout,
+        ...options
+      };
+      return decodeTransactionSync(transaction, opts, caches);
+    },
+    async decodeTransactionsBatch(transactions, options) {
+      const opts = {
+        chain: config.defaultChain,
+        timeoutMs: config.defaultTimeout,
+        ...options
+      };
+      return decodeTransactionsBatch(transactions, opts, caches);
+    },
+    async finishDecoding(transaction, options) {
+      const opts = {
+        chain: config.defaultChain,
+        timeoutMs: config.defaultTimeout,
+        ...options
+      };
+      return finishDecoding(transaction, opts, caches);
+    },
+    clearCaches() {
+      caches.clear();
+    },
+    getCacheStats() {
+      return caches.getStats();
+    },
+    async warmAddressCache(addresses) {
+      await addressResolver.warmCache(addresses);
+    },
+    async resolveAddresses(addresses, timeoutMs = 3e3) {
+      return addressResolver.resolveAddressesWithTimeout(addresses, timeoutMs);
+    }
+  };
+}
+__name(createServerDecoder, "createServerDecoder");
+export {
+  ServerAddressResolver,
+  ServerDecoderCaches,
+  createServerDecoder,
+  decodeTransactionSync,
+  decodeTransactionsBatch
+};
+//# sourceMappingURL=server.js.map