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

package/dist/chunk-XVHJWV5U.js

@@ -0,0 +1,4925 @@
+var __defProp = Object.defineProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+
+// src/decoder/utils.ts
+import {
+  AbiFunctionSignatureNotFoundError,
+  createPublicClient,
+  decodeAbiParameters,
+  http,
+  slice,
+  toFunctionSelector
+} from "viem";
+import { formatAbiItem } from "viem/utils";
+function customDecodeFunctionData(parameters, preferError) {
+  try {
+    const { abi: abi3, data } = parameters;
+    const signature = slice(data, 0, 4);
+    const description = abi3.find(
+      (x) => x.type === (preferError ? "error" : "function") && signature === toFunctionSelector(formatAbiItem(x))
+    ) || void 0;
+    if (!description)
+      throw new AbiFunctionSignatureNotFoundError(signature, {
+        docsPath: "/docs/contract/decodeFunctionData"
+      });
+    const args = "inputs" in description && description.inputs && description.inputs.length > 0 ? decodeAbiParameters(description.inputs, slice(data, 4)) : void 0;
+    const result = {
+      functionName: description.name,
+      sig: signature,
+      input: data
+    };
+    if (args) {
+      const { args: namedArgs } = createNamedArgs(args, description.inputs);
+      result.args = namedArgs;
+    }
+    return result;
+  } catch {
+  }
+}
+__name(customDecodeFunctionData, "customDecodeFunctionData");
+function createNamedArgs(args, inputs) {
+  const array = args.map((value, index) => {
+    return {
+      name: `args${index + 1}`,
+      ...inputs?.[index],
+      value
+    };
+  });
+  return { args: array };
+}
+__name(createNamedArgs, "createNamedArgs");
+function getArgByName(args, name) {
+  if (!args) return void 0;
+  const arg = args.find((arg2) => arg2.name === name);
+  return arg?.value;
+}
+__name(getArgByName, "getArgByName");
+function extractAddress(address) {
+  if (typeof address === "object") {
+    return address.address;
+  }
+  return address;
+}
+__name(extractAddress, "extractAddress");
+var clients = {};
+function getPublicClient(chain) {
+  const { id } = chain;
+  if (!id) {
+    throw new Error("Chain ID is required to create a public client");
+  }
+  if (!clients[id]) {
+    clients[id] = createPublicClient({
+      chain,
+      transport: http(),
+      batch: {
+        multicall: {
+          batchSize: 100
+        }
+      }
+    });
+  }
+  const result = clients[id];
+  if (!result) {
+    throw new Error(`Public client for chain ID ${id} not found`);
+  }
+  return result;
+}
+__name(getPublicClient, "getPublicClient");
+function isAsyncOperationEnabled(asyncOption, operation) {
+  if (typeof asyncOption === "boolean") {
+    return asyncOption;
+  }
+  if (asyncOption === void 0) {
+    return false;
+  }
+  return (asyncOption & operation) !== 0;
+}
+__name(isAsyncOperationEnabled, "isAsyncOperationEnabled");
+function needsEnhancementSingle(item) {
+  if ("sig" in item && item.sig === "0x") {
+    return false;
+  }
+  if (item.standard) {
+    return false;
+  }
+  return true;
+}
+__name(needsEnhancementSingle, "needsEnhancementSingle");
+function needsEnhancement(result) {
+  if (needsEnhancementSingle(result)) {
+    return true;
+  }
+  if ("children" in result && Array.isArray(result.children)) {
+    return result.children.some((child) => {
+      if (child.standard) {
+        return false;
+      }
+      if ("sig" in child && child.sig === "0x") {
+        return false;
+      }
+      return true;
+    });
+  }
+  return false;
+}
+__name(needsEnhancement, "needsEnhancement");
+
+// src/core/addressCollector.ts
+import { isHex, size } from "viem";
+function collectDataKeys(data, skipGqlTypes = true, existingKeys) {
+  const addresses = /* @__PURE__ */ new Set();
+  if (existingKeys) {
+    for (const key of existingKeys) {
+      if (typeof key === "string") {
+        addresses.add(key);
+      } else {
+        addresses.add(JSON.stringify(key));
+      }
+    }
+  }
+  function collectLSP8Tokens(obj) {
+    if (obj.standard !== "LSP8IdentifiableDigitalAsset" || !obj.to || !obj.args) {
+      return;
+    }
+    const contractAddress = obj.to;
+    const args = obj.args;
+    const tokenId = getArgByName(args, "tokenId");
+    if (tokenId && tokenId !== null && tokenId !== "0x") {
+      addresses.add(`${contractAddress}:${tokenId}`);
+    }
+    const tokenIds = getArgByName(args, "tokenIds");
+    if (Array.isArray(tokenIds)) {
+      for (const tokenId2 of tokenIds) {
+        if (tokenId2 && tokenId2 !== null && tokenId2 !== "0x") {
+          addresses.add(`${contractAddress}:${tokenId2}`);
+        }
+      }
+    }
+  }
+  __name(collectLSP8Tokens, "collectLSP8Tokens");
+  function collect(obj, parent, visited = /* @__PURE__ */ new WeakSet(), path = []) {
+    if (obj && typeof obj === "object" && visited.has(obj)) {
+      return;
+    }
+    if (obj && typeof obj === "object") {
+      visited.add(obj);
+    }
+    if (typeof obj === "string" && obj.startsWith("0x")) {
+      if (obj.includes(":")) {
+        const [addressPart, tokenIdPart] = obj.split(":");
+        if (addressPart.startsWith("0x") && tokenIdPart.startsWith("0x") && isHex(addressPart) && size(addressPart) === 20) {
+          addresses.add(obj);
+          return;
+        }
+      }
+      const isPaddedAddress = /^0x0*([a-fA-F0-9]{40})$/.test(obj);
+      if (isPaddedAddress || isHex(obj) && size(obj) === 20) {
+        if (parent && skipGqlTypes && "__gqltype" in parent) {
+          return;
+        }
+        const address = isPaddedAddress ? obj.replace(/^0x0*([a-fA-F0-9]{40})$/, "0x$1") : obj;
+        if (address.slice(2).split("").filter((c) => c === "0").length > 10) {
+          return;
+        }
+        addresses.add(address);
+      }
+      return;
+    }
+    if (!obj || typeof obj !== "object") return;
+    if (Array.isArray(obj)) {
+      for (let i = 0; i < obj.length; i++) {
+        collect(obj[i], parent, visited, [...path, `[${i}]`]);
+      }
+    } else {
+      const record = obj;
+      if ("standard" in record && "to" in record && "args" in record) {
+        collectLSP8Tokens(record);
+      }
+      for (const [key, value] of Object.entries(record)) {
+        collect(value, record, visited, [...path, key]);
+      }
+    }
+  }
+  __name(collect, "collect");
+  collect(data);
+  return Array.from(addresses);
+}
+__name(collectDataKeys, "collectDataKeys");
+
+// src/decoder/registry.ts
+var PluginRegistry = class {
+  static {
+    __name(this, "PluginRegistry");
+  }
+  plugins = /* @__PURE__ */ new Map();
+  schemaPlugins = /* @__PURE__ */ new Map();
+  /**
+   * Register a decoder plugin
+   * @param name - Unique plugin name
+   * @param plugin - Plugin instance
+   * @param options - Registration options
+   */
+  register(name, plugin, options) {
+    const {
+      override = false,
+      priority = 0,
+      required = false,
+      description,
+      version,
+      usesAsync = false
+    } = options || {};
+    const existing = this.plugins.get(name);
+    if (existing) {
+      if (existing.required) {
+        console.error(
+          `Plugin "${name}" is marked as required and cannot be overridden.`
+        );
+        return;
+      }
+      if (!override) {
+        console.warn(
+          `Plugin "${name}" is already registered. Use override: true to replace.`
+        );
+        return;
+      }
+    }
+    this.plugins.set(name, {
+      name,
+      plugin: Object.freeze(plugin),
+      priority,
+      required,
+      description,
+      version,
+      usesAsync
+    });
+  }
+  /**
+   * Register a schema plugin
+   * @param name - Unique plugin name
+   * @param plugin - Schema plugin instance
+   * @param options - Registration options
+   */
+  registerSchema(name, plugin, options) {
+    const {
+      override = false,
+      priority = 0,
+      required = false,
+      description,
+      version
+    } = options || {};
+    const existing = this.schemaPlugins.get(name);
+    if (existing) {
+      if (existing.required) {
+        console.error(
+          `Schema plugin "${name}" is marked as required and cannot be overridden.`
+        );
+        return;
+      }
+      if (!override) {
+        console.warn(
+          `Schema plugin "${name}" is already registered. Use override: true to replace.`
+        );
+        return;
+      }
+    }
+    this.schemaPlugins.set(name, {
+      name,
+      plugin: Object.freeze(plugin),
+      priority,
+      required,
+      description,
+      version
+    });
+  }
+  /**
+   * Unregister a plugin
+   */
+  unregister(name) {
+    return this.plugins.delete(name);
+  }
+  /**
+   * Get all registered decoder plugins (excluding overridden ones)
+   * @param options - Filter options
+   */
+  async getAll(options) {
+    const { excludeNames = [], syncOnly = false } = options || {};
+    const exclude = new Set(excludeNames);
+    let plugins = Array.from(this.plugins.values());
+    if (syncOnly) {
+      plugins = plugins.filter((meta) => !meta.usesAsync);
+    }
+    for (const name of exclude) {
+      const plugin = this.plugins.get(name);
+      if (plugin?.required) {
+        console.warn(
+          `Warning: Plugin "${name}" is required and cannot be excluded. It will run first.`
+        );
+      }
+    }
+    return plugins.sort((a, b) => (b.priority || 0) - (a.priority || 0)).map(({ plugin }) => plugin);
+  }
+  /**
+   * Get all schema plugins (excluding overridden ones)
+   * @param excludeNames - Plugin names to exclude
+   */
+  getAllSchema(excludeNames) {
+    const exclude = new Set(excludeNames || []);
+    const plugins = Array.from(this.schemaPlugins.values());
+    for (const name of exclude) {
+      const plugin = this.schemaPlugins.get(name);
+      if (plugin?.required) {
+        console.warn(
+          `Warning: Schema plugin "${name}" is required and cannot be excluded. It will run first.`
+        );
+      }
+    }
+    const required = plugins.filter((meta) => meta.required).sort((a, b) => (b.priority || 0) - (a.priority || 0));
+    const optional = plugins.filter((meta) => !meta.required && !exclude.has(meta.name)).sort((a, b) => (b.priority || 0) - (a.priority || 0));
+    return [...required, ...optional].map((meta) => meta.plugin);
+  }
+  /**
+   * Get a specific plugin by name
+   */
+  async get(name) {
+    const meta = this.plugins.get(name);
+    return meta?.plugin;
+  }
+  /**
+   * Get plugin metadata
+   */
+  getMetadata(name) {
+    return this.plugins.get(name);
+  }
+  /**
+   * Get schema plugin metadata
+   */
+  getSchemaMetadata(name) {
+    return this.schemaPlugins.get(name);
+  }
+  /**
+   * Check if a plugin is registered
+   */
+  has(name) {
+    return this.plugins.has(name);
+  }
+  /**
+   * Clear all plugins
+   */
+  clear() {
+    this.plugins.clear();
+    this.schemaPlugins.clear();
+  }
+  /**
+   * Get the number of registered plugins
+   */
+  get size() {
+    return this.plugins.size + this.schemaPlugins.size;
+  }
+  /**
+   * List all registered plugins with metadata
+   */
+  list() {
+    return {
+      plugins: Array.from(this.plugins.values()),
+      schemaPlugins: Array.from(this.schemaPlugins.values())
+    };
+  }
+};
+Object.freeze(PluginRegistry.prototype);
+Object.freeze(PluginRegistry);
+var pluginRegistry = new PluginRegistry();
+function registerPlugin(name, plugin, options) {
+  pluginRegistry.register(name, plugin, options);
+}
+__name(registerPlugin, "registerPlugin");
+function registerSchemaPlugin(name, plugin, options) {
+  pluginRegistry.registerSchema(name, plugin, options);
+}
+__name(registerSchemaPlugin, "registerSchemaPlugin");
+function createNamedSchemaPlugin(name, plugin) {
+  const namedPlugin = Object.assign(plugin, { name });
+  return namedPlugin;
+}
+__name(createNamedSchemaPlugin, "createNamedSchemaPlugin");
+function createNamedPlugin(name, plugin) {
+  return { ...plugin, name };
+}
+__name(createNamedPlugin, "createNamedPlugin");
+
+// ../../node_modules/.pnpm/@erc725+erc725.js@0.28.2_bufferutil@4.0.9_typescript@5.9.3_utf-8-validate@5.0.10_zod@4.1.13/node_modules/@erc725/erc725.js/schemas/LSP1UniversalReceiverDelegate.json
+var LSP1UniversalReceiverDelegate_default = [
+  {
+    name: "LSP1UniversalReceiverDelegate",
+    key: "0x0cfc51aec37c55a4d0b1a65c6255c4bf2fbdf6277f3cc0730c45b828b6db8b47",
+    keyType: "Singleton",
+    valueType: "address",
+    valueContent: "Address"
+  },
+  {
+    name: "LSP1UniversalReceiverDelegate:<bytes32>",
+    key: "0x0cfc51aec37c55a4d0b10000<bytes32>",
+    keyType: "Mapping",
+    valueType: "address",
+    valueContent: "Address"
+  }
+];
+
+// ../../node_modules/.pnpm/@erc725+erc725.js@0.28.2_bufferutil@4.0.9_typescript@5.9.3_utf-8-validate@5.0.10_zod@4.1.13/node_modules/@erc725/erc725.js/schemas/LSP3ProfileMetadata.json
+var LSP3ProfileMetadata_default = [
+  {
+    name: "SupportedStandards:LSP3Profile",
+    key: "0xeafec4d89fa9619884b600005ef83ad9559033e6e941db7d7c495acdce616347",
+    keyType: "Mapping",
+    valueType: "bytes4",
+    valueContent: "0x5ef83ad9"
+  },
+  {
+    name: "LSP3Profile",
+    key: "0x5ef83ad9559033e6e941db7d7c495acdce616347d28e90c7ce47cbfcfcad3bc5",
+    keyType: "Singleton",
+    valueType: "bytes",
+    valueContent: "VerifiableURI"
+  },
+  {
+    name: "LSP12IssuedAssets[]",
+    key: "0x7c8c3416d6cda87cd42c71ea1843df28ac4850354f988d55ee2eaa47b6dc05cd",
+    keyType: "Array",
+    valueType: "address",
+    valueContent: "Address"
+  },
+  {
+    name: "LSP12IssuedAssetsMap:<address>",
+    key: "0x74ac2555c10b9349e78f0000<address>",
+    keyType: "Mapping",
+    valueType: "(bytes4,uint128)",
+    valueContent: "(Bytes4,Number)"
+  },
+  {
+    name: "LSP5ReceivedAssets[]",
+    key: "0x6460ee3c0aac563ccbf76d6e1d07bada78e3a9514e6382b736ed3f478ab7b90b",
+    keyType: "Array",
+    valueType: "address",
+    valueContent: "Address"
+  },
+  {
+    name: "LSP5ReceivedAssetsMap:<address>",
+    key: "0x812c4334633eb816c80d0000<address>",
+    keyType: "Mapping",
+    valueType: "(bytes4,uint128)",
+    valueContent: "(Bytes4,Number)"
+  },
+  {
+    name: "LSP1UniversalReceiverDelegate",
+    key: "0x0cfc51aec37c55a4d0b1a65c6255c4bf2fbdf6277f3cc0730c45b828b6db8b47",
+    keyType: "Singleton",
+    valueType: "address",
+    valueContent: "Address"
+  },
+  {
+    name: "LSP1UniversalReceiverDelegate:<bytes32>",
+    key: "0x0cfc51aec37c55a4d0b10000<bytes32>",
+    keyType: "Mapping",
+    valueType: "address",
+    valueContent: "Address"
+  },
+  {
+    name: "LSP17Extension:<bytes4>",
+    key: "0xcee78b4094da860110960000<bytes4>",
+    keyType: "Mapping",
+    valueType: "address",
+    valueContent: "Address"
+  }
+];
+
+// ../../node_modules/.pnpm/@erc725+erc725.js@0.28.2_bufferutil@4.0.9_typescript@5.9.3_utf-8-validate@5.0.10_zod@4.1.13/node_modules/@erc725/erc725.js/schemas/LSP4DigitalAsset.json
+var LSP4DigitalAsset_default = [
+  {
+    name: "SupportedStandards:LSP4DigitalAsset",
+    key: "0xeafec4d89fa9619884b60000a4d96624a38f7ac2d8d9a604ecf07c12c77e480c",
+    keyType: "Mapping",
+    valueType: "bytes4",
+    valueContent: "0xa4d96624"
+  },
+  {
+    name: "LSP4TokenName",
+    key: "0xdeba1e292f8ba88238e10ab3c7f88bd4be4fac56cad5194b6ecceaf653468af1",
+    keyType: "Singleton",
+    valueType: "string",
+    valueContent: "String"
+  },
+  {
+    name: "LSP4TokenSymbol",
+    key: "0x2f0a68ab07768e01943a599e73362a0e17a63a72e94dd2e384d2c1d4db932756",
+    keyType: "Singleton",
+    valueType: "string",
+    valueContent: "String"
+  },
+  {
+    name: "LSP4TokenType",
+    key: "0xe0261fa95db2eb3b5439bd033cda66d56b96f92f243a8228fd87550ed7bdfdb3",
+    keyType: "Singleton",
+    valueType: "uint256",
+    valueContent: "Number"
+  },
+  {
+    name: "LSP4Metadata",
+    key: "0x9afb95cacc9f95858ec44aa8c3b685511002e30ae54415823f406128b85b238e",
+    keyType: "Singleton",
+    valueType: "bytes",
+    valueContent: "VerifiableURI"
+  },
+  {
+    name: "LSP4Creators[]",
+    key: "0x114bd03b3a46d48759680d81ebb2b414fda7d030a7105a851867accf1c2352e7",
+    keyType: "Array",
+    valueType: "address",
+    valueContent: "Address"
+  },
+  {
+    name: "LSP4CreatorsMap:<address>",
+    key: "0x6de85eaf5d982b4e5da00000<address>",
+    keyType: "Mapping",
+    valueType: "(bytes4,uint128)",
+    valueContent: "(Bytes4,Number)"
+  }
+];
+
+// ../../node_modules/.pnpm/@erc725+erc725.js@0.28.2_bufferutil@4.0.9_typescript@5.9.3_utf-8-validate@5.0.10_zod@4.1.13/node_modules/@erc725/erc725.js/schemas/LSP4DigitalAssetLegacy.json
+var LSP4DigitalAssetLegacy_default = [
+  {
+    name: "SupportedStandards:LSP4DigitalCertificate",
+    key: "0xeafec4d89fa9619884b6b89135626455000000000000000000000000abf0613c",
+    keyType: "Mapping",
+    valueContent: "0xabf0613c",
+    valueType: "bytes"
+  }
+];
+
+// ../../node_modules/.pnpm/@erc725+erc725.js@0.28.2_bufferutil@4.0.9_typescript@5.9.3_utf-8-validate@5.0.10_zod@4.1.13/node_modules/@erc725/erc725.js/schemas/LSP5ReceivedAssets.json
+var LSP5ReceivedAssets_default = [
+  {
+    name: "LSP5ReceivedAssets[]",
+    key: "0x6460ee3c0aac563ccbf76d6e1d07bada78e3a9514e6382b736ed3f478ab7b90b",
+    keyType: "Array",
+    valueType: "address",
+    valueContent: "Address"
+  },
+  {
+    name: "LSP5ReceivedAssetsMap:<address>",
+    key: "0x812c4334633eb816c80d0000<address>",
+    keyType: "Mapping",
+    valueType: "(bytes4,uint128)",
+    valueContent: "(Bytes4,Number)"
+  }
+];
+
+// ../../node_modules/.pnpm/@erc725+erc725.js@0.28.2_bufferutil@4.0.9_typescript@5.9.3_utf-8-validate@5.0.10_zod@4.1.13/node_modules/@erc725/erc725.js/schemas/LSP6KeyManager.json
+var LSP6KeyManager_default = [
+  {
+    name: "AddressPermissions[]",
+    key: "0xdf30dba06db6a30e65354d9a64c609861f089545ca58c6b4dbe31a5f338cb0e3",
+    keyType: "Array",
+    valueType: "address",
+    valueContent: "Address"
+  },
+  {
+    name: "AddressPermissions:Permissions:<address>",
+    key: "0x4b80742de2bf82acb3630000<address>",
+    keyType: "MappingWithGrouping",
+    valueType: "bytes32",
+    valueContent: "BitArray"
+  },
+  {
+    name: "AddressPermissions:AllowedCalls:<address>",
+    key: "0x4b80742de2bf393a64c70000<address>",
+    keyType: "MappingWithGrouping",
+    valueType: "(bytes4,address,bytes4,bytes4)[CompactBytesArray]",
+    valueContent: "(BitArray,Address,Bytes4,Bytes4)"
+  },
+  {
+    name: "AddressPermissions:AllowedERC725YDataKeys:<address>",
+    key: "0x4b80742de2bf866c29110000<address>",
+    keyType: "MappingWithGrouping",
+    valueType: "bytes[CompactBytesArray]",
+    valueContent: "Bytes"
+  }
+];
+
+// ../../node_modules/.pnpm/@erc725+erc725.js@0.28.2_bufferutil@4.0.9_typescript@5.9.3_utf-8-validate@5.0.10_zod@4.1.13/node_modules/@erc725/erc725.js/schemas/LSP8IdentifiableDigitalAsset.json
+var LSP8IdentifiableDigitalAsset_default = [
+  {
+    name: "LSP8TokenIdFormat",
+    key: "0xf675e9361af1c1664c1868cfa3eb97672d6b1a513aa5b81dec34c9ee330e818d",
+    keyType: "Singleton",
+    valueType: "uint256",
+    valueContent: "Number"
+  },
+  {
+    name: "LSP8TokenMetadataBaseURI",
+    key: "0x1a7628600c3bac7101f53697f48df381ddc36b9015e7d7c9c5633d1252aa2843",
+    keyType: "Singleton",
+    valueType: "bytes",
+    valueContent: "VerifiableURI"
+  },
+  {
+    name: "LSP8ReferenceContract",
+    key: "0x708e7b881795f2e6b6c2752108c177ec89248458de3bf69d0d43480b3e5034e6",
+    keyType: "Singleton",
+    valueType: "(address,bytes32)",
+    valueContent: "(Address,Bytes32)"
+  }
+];
+
+// ../../node_modules/.pnpm/@erc725+erc725.js@0.28.2_bufferutil@4.0.9_typescript@5.9.3_utf-8-validate@5.0.10_zod@4.1.13/node_modules/@erc725/erc725.js/schemas/LSP9Vault.json
+var LSP9Vault_default = [
+  {
+    name: "SupportedStandards:LSP9Vault",
+    key: "0xeafec4d89fa9619884b600007c0334a14085fefa8b51ae5a40895018882bdb90",
+    keyType: "Mapping",
+    valueType: "bytes4",
+    valueContent: "0x7c0334a1"
+  },
+  {
+    name: "LSP1UniversalReceiverDelegate",
+    key: "0x0cfc51aec37c55a4d0b1a65c6255c4bf2fbdf6277f3cc0730c45b828b6db8b47",
+    keyType: "Singleton",
+    valueType: "address",
+    valueContent: "Address"
+  },
+  {
+    name: "LSP1UniversalReceiverDelegate:<bytes32>",
+    key: "0x0cfc51aec37c55a4d0b10000<bytes32>",
+    keyType: "Mapping",
+    valueType: "address",
+    valueContent: "Address"
+  },
+  {
+    name: "LSP17Extension:<bytes4>",
+    key: "0xcee78b4094da860110960000<bytes4>",
+    keyType: "Mapping",
+    valueType: "address",
+    valueContent: "Address"
+  }
+];
+
+// ../../node_modules/.pnpm/@erc725+erc725.js@0.28.2_bufferutil@4.0.9_typescript@5.9.3_utf-8-validate@5.0.10_zod@4.1.13/node_modules/@erc725/erc725.js/schemas/LSP10ReceivedVaults.json
+var LSP10ReceivedVaults_default = [
+  {
+    name: "LSP10VaultsMap:<address>",
+    key: "0x192448c3c0f88c7f238c0000<address>",
+    keyType: "Mapping",
+    valueType: "(bytes4,uint128)",
+    valueContent: "(Bytes4,Number)"
+  },
+  {
+    name: "LSP10Vaults[]",
+    key: "0x55482936e01da86729a45d2b87a6b1d3bc582bea0ec00e38bdb340e3af6f9f06",
+    keyType: "Array",
+    valueType: "address",
+    valueContent: "Address"
+  }
+];
+
+// ../../node_modules/.pnpm/@erc725+erc725.js@0.28.2_bufferutil@4.0.9_typescript@5.9.3_utf-8-validate@5.0.10_zod@4.1.13/node_modules/@erc725/erc725.js/schemas/LSP12IssuedAssets.json
+var LSP12IssuedAssets_default = [
+  {
+    name: "LSP12IssuedAssets[]",
+    key: "0x7c8c3416d6cda87cd42c71ea1843df28ac4850354f988d55ee2eaa47b6dc05cd",
+    keyType: "Array",
+    valueType: "address",
+    valueContent: "Address"
+  },
+  {
+    name: "LSP12IssuedAssetsMap:<address>",
+    key: "0x74ac2555c10b9349e78f0000<address>",
+    keyType: "Mapping",
+    valueType: "(bytes4,uint128)",
+    valueContent: "(Bytes4,Number)"
+  }
+];
+
+// ../../node_modules/.pnpm/@erc725+erc725.js@0.28.2_bufferutil@4.0.9_typescript@5.9.3_utf-8-validate@5.0.10_zod@4.1.13/node_modules/@erc725/erc725.js/schemas/LSP17ContractExtension.json
+var LSP17ContractExtension_default = [
+  {
+    name: "LSP17Extension:<bytes4>",
+    key: "0xcee78b4094da860110960000<bytes4>",
+    keyType: "Mapping",
+    valueType: "address",
+    valueContent: "Address"
+  }
+];
+
+// src/decoder/constants.ts
+var IPFS_GATEWAY = "https://api.universalprofile.cloud/ipfs/";
+var FUNCTION_DICTIONARY_URL = "https://4bytesdictionary.universalprofile.cloud";
+var OPENCHAIN_DICTIONARY_URL = "https://api.openchain.xyz/signature-database/v1/lookup";
+var ARRAY_MAX = 1e3;
+var defaultSchema = [
+  ...LSP8IdentifiableDigitalAsset_default,
+  ...LSP4DigitalAsset_default,
+  ...LSP5ReceivedAssets_default,
+  ...LSP3ProfileMetadata_default,
+  ...LSP1UniversalReceiverDelegate_default,
+  ...LSP4DigitalAssetLegacy_default,
+  ...LSP6KeyManager_default,
+  ...LSP9Vault_default,
+  ...LSP10ReceivedVaults_default,
+  ...LSP12IssuedAssets_default,
+  ...LSP17ContractExtension_default,
+  {
+    name: "LSP28TheGrid",
+    key: "0x724141d9918ce69e6b8afcf53a91748466086ba2c74b94cab43c649ae2ac23ff",
+    keyType: "Singleton",
+    valueType: "bytes",
+    valueContent: "VerifiableURI"
+  }
+];
+
+// src/decoder/plugins/schemaDefault.ts
+import {
+  decodeData,
+  decodeMappingKey,
+  decodePermissions,
+  decodeValueContent,
+  isDynamicKeyName
+} from "@erc725/erc725.js";
+import { isHex as isHex2 } from "viem";
+
+// src/decoder/getDataFromExternalSources.ts
+import { isDataAuthentic, patchIPFSUrlsIfApplicable } from "@erc725/erc725.js";
+async function loadFile(_url, ipfsGateway) {
+  let url = _url;
+  if (url.startsWith("data:")) {
+    const base64Data = url.split(",")[1];
+    const binaryString = atob(base64Data);
+    const len = binaryString.length;
+    const bytes = new Uint8Array(len);
+    for (let i = 0; i < len; i++) {
+      bytes[i] = binaryString.charCodeAt(i);
+    }
+    return Promise.resolve(bytes.buffer);
+  }
+  if (url.startsWith("ipfs://")) {
+    const ipfsHash = url.replace("ipfs://", "");
+    url = `${ipfsGateway}${ipfsHash}`;
+  }
+  return fetch(url).then((response) => {
+    if (!response.ok) {
+      throw new Error("Network response was not ok");
+    }
+    return response.arrayBuffer();
+  }).catch(() => null);
+}
+__name(loadFile, "loadFile");
+var getDataFromExternalSources = /* @__PURE__ */ __name((schemas, dataFromChain, ipfsGateway, throwException = true) => {
+  const promises = dataFromChain.map(async (dataEntry) => {
+    const schemaElement = schemas.find((schema) => schema.key === dataEntry.key);
+    if (!schemaElement) {
+      return dataEntry;
+    }
+    if (!["jsonurl", "asseturl", "verifiableuri"].includes(
+      schemaElement.valueContent.toLowerCase()
+    )) {
+      return dataEntry;
+    }
+    const urlDataWithHash = dataEntry.value;
+    let url;
+    let src;
+    try {
+      if (typeof dataEntry.value === "string") {
+        throw new Error(
+          `Value is string instead of ${schemaElement.valueContent}`
+        );
+      }
+      if (!dataEntry.value) {
+        throw new Error(`${schemaElement.valueContent} empty`);
+      }
+      if (Array.isArray(dataEntry.value)) {
+        throw new Error(
+          `Value is Array instead of ${schemaElement.valueContent}`
+        );
+      }
+      url = urlDataWithHash.url;
+      ({ url: src } = patchIPFSUrlsIfApplicable(
+        urlDataWithHash,
+        ipfsGateway
+      ));
+      let length = "unknown";
+      if (!url.startsWith("data:") && /[=?/]$/.test(url)) {
+        return dataEntry;
+      }
+      const receivedData = /^data:|^ipfs:\/\/|\/ipfs\//.test(url) ? await loadFile(src, ipfsGateway).then(
+        (buffer) => buffer ? new Uint8Array(buffer) : Promise.reject(new Error("No Data"))
+      ) : await fetch(src).then(async (response) => {
+        if (!response.ok) {
+          throw new Error(response.statusText);
+        }
+        return response.arrayBuffer().then((buffer) => new Uint8Array(buffer));
+      });
+      length = receivedData.length.toString();
+      const captureHashes = {};
+      const captureErrors = [];
+      if (receivedData.length >= 2) {
+        try {
+          const capture = [];
+          capture.push(receivedData[0]);
+          if (receivedData.length > 3) {
+            capture.push(receivedData[receivedData.length - 3]);
+          }
+          if (receivedData.length > 2) {
+            capture.push(receivedData[receivedData.length - 2]);
+          }
+          if (receivedData.length > 1) {
+            capture.push(receivedData[receivedData.length - 1]);
+          }
+          const key = String.fromCharCode.apply(null, capture);
+          if (/^(\[.*\]|\{.*\})\s*$/s.test(key)) {
+            const json = new TextDecoder().decode(new Uint8Array(receivedData));
+            const value = JSON.parse(json);
+            if (isDataAuthentic(
+              value,
+              urlDataWithHash.verification,
+              captureErrors
+            )) {
+              return {
+                ...dataEntry,
+                value,
+                data: urlDataWithHash.verification?.data,
+                method: urlDataWithHash.verification?.method,
+                url,
+                src
+              };
+            }
+            captureHashes[captureErrors.pop() || ""] = urlDataWithHash.verification?.data || "";
+            if (isDataAuthentic(
+              receivedData,
+              urlDataWithHash.verification,
+              captureErrors
+            )) {
+              return {
+                ...dataEntry,
+                value,
+                data: urlDataWithHash.verification?.data,
+                method: urlDataWithHash.verification?.method,
+                url,
+                src
+              };
+            }
+            captureHashes[captureErrors.pop() || ""] = urlDataWithHash.verification?.data || "";
+            throw new Error(
+              `Data does not validate, ignored ${Object.entries(captureHashes).map(
+                ([expected, got]) => `calculated(${got}) != expected(${expected})`
+              ).join(", ")}`
+            );
+          }
+        } catch {
+        }
+      }
+      if (isDataAuthentic(
+        receivedData,
+        urlDataWithHash.verification,
+        captureErrors
+      )) {
+        return {
+          ...dataEntry,
+          value: receivedData,
+          data: urlDataWithHash.verification?.data,
+          method: urlDataWithHash.verification?.method,
+          url,
+          src
+        };
+      }
+      captureHashes[captureErrors.pop() || ""] = urlDataWithHash.verification?.data || "";
+      throw new Error(
+        `Data does not validate, ignored ${Object.entries(captureHashes).map(
+          ([expected, got]) => `calculated(${got}) != expected(${expected})`
+        ).join(", ")}`
+      );
+    } catch (error) {
+      const message = error.message;
+      if (throwException) {
+        throw error;
+      }
+      return {
+        ...dataEntry,
+        value: null,
+        error: message,
+        data: urlDataWithHash.verification?.data,
+        method: urlDataWithHash.verification?.method,
+        url,
+        src
+      };
+    }
+  });
+  return Promise.all(promises);
+}, "getDataFromExternalSources");
+
+// src/decoder/plugins/schemaDefault.ts
+var schemaDefaultPlugin = decodeKeyValuePlugin(defaultSchema);
+var schemaDefault_default = schemaDefaultPlugin;
+function decodeKeyValuePlugin(defaultSchema2, process2) {
+  const preProcess = /* @__PURE__ */ __name(async (key, value) => {
+    const schema = defaultSchema2.find((item) => {
+      if (key === item.key) {
+        return true;
+      }
+      const index = item.key.indexOf("<");
+      if (index !== -1) {
+        return key.slice(0, index) === item.key.slice(0, index);
+      }
+      return false;
+    }) || defaultSchema2.find((item) => {
+      if (key.slice(0, 34) === item.key.slice(0, 34)) {
+        return true;
+      }
+      return false;
+    });
+    if (schema) {
+      try {
+        const name = schema.name.replace(/[:\[\]]|<.*?>/g, "");
+        if (schema.keyType === "Array") {
+          if (schema.key === key) {
+            const hexString = value.slice(2);
+            const all = new Uint8Array(hexString.length / 2);
+            for (let i = 0; i < hexString.length; i += 2) {
+              all[i / 2] = Number.parseInt(hexString.substring(i, i + 2), 16);
+            }
+            const [{ start, end } = { start: 0, end: 0 }] = all.reduce(
+              (acc, byte, index_) => {
+                let isZero = byte === 0 || index_ === 0;
+                const last = acc.at(-1);
+                let index2 = index_;
+                if (!last || last.isZero !== isZero || index2 === all.length - 1) {
+                  if (index2 === all.length - 1) {
+                    index2 = all.length;
+                  } else if (index2 === 0) {
+                    isZero = true;
+                  }
+                  if (last) {
+                    last.end = index2;
+                    last.isZero = isZero;
+                  }
+                  if (isZero) {
+                    acc.push({
+                      isZero,
+                      start: index2,
+                      end: index2 === 0 ? index2 + 1 : index2
+                    });
+                  }
+                }
+                return acc;
+              },
+              []
+            );
+            const picked = Math.abs(end - all.length + 1) <= 4 ? all.length + 1 : Math.abs(end - all.length / 2 + 1) <= 4 ? all.length / 2 : end;
+            const segment = value.slice(0, picked * 2 + 2);
+            const length = BigInt(segment);
+            if (length > ARRAY_MAX) {
+              return {
+                ...schema,
+                type: "Error",
+                key,
+                value: "Array length too large"
+              };
+            }
+            return {
+              ...schema,
+              type: "ArrayLength",
+              pretty: name,
+              value: Number(length)
+            };
+          }
+          const index = BigInt(`0x${key.slice(34)}`);
+          if (index > ARRAY_MAX) {
+            return {
+              ...schema,
+              type: "Error",
+              key,
+              value: "Array index too large"
+            };
+          }
+          let data2 = value !== "0x" ? decodeValueContent(schema.valueContent, value) : void 0;
+          if (schema.valueContent.startsWith("0x")) {
+            data2 = data2 === schema.valueContent;
+          }
+          return {
+            ...schema,
+            type: "ArrayItem",
+            pretty: name,
+            dynamic: Number(index),
+            value: data2
+          };
+        }
+        let dynamicKeyParts = void 0;
+        if (isDynamicKeyName(schema.name)) {
+          dynamicKeyParts = decodeMappingKey(key, schema).map(
+            ({ value: value2 }) => isHex2(value2) ? value2.toLowerCase() : `${value2}`
+          );
+        }
+        let rawData = value !== "0x" ? decodeData(
+          [
+            dynamicKeyParts ? {
+              keyName: schema.name,
+              dynamicKeyParts,
+              value
+            } : { keyName: schema.name, value }
+          ],
+          defaultSchema2
+        ) : [{ value: void 0 }];
+        let data = rawData?.[0]?.value;
+        if (schema.name === "LSP8TokenMetadataBaseURI") {
+          const { url: _url } = data || {};
+          const url2 = _url?.replace(/\0*$/g, "");
+          if (!url2 && url2?.includes("\0")) {
+            return {
+              ...schema,
+              pretty: name,
+              type: "Error",
+              key,
+              value: "Invalid URL (contains \\0)"
+            };
+          }
+          return { ...schema, type: "Value", name, value: url2 };
+        }
+        if (data && typeof data === "object" && !Array.isArray(data)) {
+          const { url: _url } = data || {};
+          const url2 = _url?.replace(/\0*$/g, "");
+          if (!url2 || url2?.includes("\0")) {
+            const newURL2 = url2?.replace(/\0/g, "\\0");
+            const { error, data: data2, method: method2 } = rawData?.[0];
+            return {
+              ...schema,
+              pretty: name,
+              type: "Error",
+              key,
+              value: `${error ? `${error} ` : ""}Invalid URL (contains \\0 ${newURL2})`,
+              data: data2,
+              method: method2,
+              url: newURL2
+            };
+          }
+          const newURL = data.url.replace(
+            "https://2eff.lukso.dev/ipfs/",
+            "ipfs://"
+          );
+          if (newURL !== data.url) {
+            ;
+            data.url = newURL;
+          }
+          rawData = await getDataFromExternalSources(
+            defaultSchema2,
+            rawData,
+            IPFS_GATEWAY,
+            false
+          );
+          if (rawData?.[0]?.error) {
+            const { error, data: data2, method: method2, url: url3 } = rawData?.[0];
+            return {
+              ...schema,
+              type: "Error",
+              pretty: name,
+              value: error,
+              data: data2,
+              method: method2,
+              url: url3
+            };
+          }
+          data = rawData?.[0]?.value?.[schema.name] || rawData?.[0]?.value;
+        } else if (schema.valueContent.startsWith("0x")) {
+          data = data === schema.valueContent;
+        }
+        const {
+          data: _data,
+          method,
+          src,
+          url
+        } = rawData?.[0];
+        if (schema.name === "AddressPermissions:Permissions:<address>") {
+          let _value = data;
+          try {
+            const {
+              ERC4337_PERMISSION: _ignore1,
+              ALL_PERMISSIONS: _ignore2,
+              ...rest
+            } = decodePermissions(data);
+            if (Object.keys("rest").length === 1 && rest.ADDCONTROLLER) {
+              rest.ISRECOVERY = true;
+            }
+            _value = rest;
+          } catch {
+          }
+          return {
+            ...schema,
+            type: "Value",
+            pretty: name,
+            value: _value,
+            dynamic: dynamicKeyParts?.length === 1 ? dynamicKeyParts[0] : dynamicKeyParts,
+            data: _data,
+            method,
+            src,
+            url
+          };
+        }
+        return {
+          ...schema,
+          type: "Value",
+          pretty: name,
+          value: data,
+          dynamic: dynamicKeyParts?.length === 1 ? dynamicKeyParts[0] : dynamicKeyParts,
+          data: _data,
+          method,
+          src,
+          url
+        };
+      } catch (error) {
+        return { ...schema, type: "Error", key, value: error };
+      }
+    }
+    return { type: "Undecoded", name: void 0, key, value };
+  }, "preProcess");
+  return async (key, value) => {
+    try {
+      const result = await preProcess(key, value);
+      if (process2) {
+        return await process2(result);
+      }
+      return result;
+    } catch {
+    }
+    return void 0;
+  };
+}
+__name(decodeKeyValuePlugin, "decodeKeyValuePlugin");
+
+// src/decoder/plugins/standardPlugin.ts
+function createAggregationKey(pluginOptions, key) {
+  return `${pluginOptions.name || pluginOptions.decoderName || "unknown"}:${key}`;
+}
+__name(createAggregationKey, "createAggregationKey");
+function standardPlugin(abi3, pluginOptions, callbacks) {
+  const {
+    abiName,
+    decoderName = "unknown",
+    moduleHint,
+    required,
+    priority,
+    name,
+    usesAsync
+  } = pluginOptions;
+  const plugin = {
+    enhance: /* @__PURE__ */ __name(async (transaction, options) => {
+      if (callbacks.overrideEnhance) {
+        return await callbacks.overrideEnhance(
+          transaction,
+          pluginOptions,
+          options
+        );
+      }
+      const { preferError } = options;
+      const {
+        to: _to,
+        from: _from,
+        value: _value,
+        input,
+        blockNumber: _blockNumber
+        // logs,
+      } = transaction;
+      const to = _to || void 0;
+      const from = _from || void 0;
+      const value = _value ? BigInt(_value) : 0n;
+      const decoded = customDecodeFunctionData(
+        {
+          abi: abi3,
+          data: input || "0x"
+        },
+        preferError
+      );
+      if (!decoded) {
+        return;
+      }
+      const { functionName, sig, args } = decoded;
+      const output = {
+        isDecoded: true,
+        ...transaction,
+        resultType: "execute",
+        functionName,
+        sig,
+        input,
+        __decoder: decoderName,
+        standard: abiName || "unknown",
+        moduleHint,
+        args,
+        to,
+        from,
+        value
+      };
+      const enhanced = await callbacks.enhance(output, pluginOptions, options);
+      if (enhanced) {
+        return enhanced;
+      }
+      return;
+    }, "enhance"),
+    decodeEvent: /* @__PURE__ */ __name(async (log, options) => {
+      return callbacks.decodeEvent(log, options);
+    }, "decodeEvent"),
+    getAggregationKey: /* @__PURE__ */ __name(async (result, pluginOptions2, options) => {
+      if (!callbacks.getAggregationKey) {
+        return;
+      }
+      return callbacks.getAggregationKey(result, pluginOptions2, options);
+    }, "getAggregationKey"),
+    summarize: /* @__PURE__ */ __name(async (aggregationKey, result, pluginOptions2, options) => {
+      if (!callbacks.summarize) {
+        return;
+      }
+      return callbacks.summarize(aggregationKey, result, pluginOptions2, options);
+    }, "summarize")
+  };
+  if (name !== void 0) {
+    plugin.name = name;
+  }
+  if (required !== void 0) {
+    plugin.required = required;
+  }
+  if (priority !== void 0) {
+    plugin.priority = priority;
+  }
+  if (usesAsync !== void 0) {
+    plugin.usesAsync = usesAsync;
+  }
+  if (callbacks.aggregations !== void 0) {
+    plugin.aggregations = callbacks.aggregations;
+  }
+  const frozenPlugin = Object.freeze(plugin);
+  if (name) {
+    pluginRegistry.register(name, frozenPlugin, {
+      priority,
+      required,
+      usesAsync
+      // Include async flag for registration
+    });
+  }
+  return frozenPlugin;
+}
+__name(standardPlugin, "standardPlugin");
+function standardSchemaPlugin(schemas, pluginOptions, process2) {
+  const basePlugin = decodeKeyValuePlugin(schemas, process2);
+  const plugin = Object.assign(basePlugin, {
+    name: pluginOptions?.name,
+    required: pluginOptions?.required,
+    priority: pluginOptions?.priority ?? 50
+  });
+  return Object.freeze(plugin);
+}
+__name(standardSchemaPlugin, "standardSchemaPlugin");
+
+// src/utils/debug.ts
+var debugInstances = /* @__PURE__ */ new Map();
+function createDebug(namespace) {
+  const DEBUG = typeof process !== "undefined" && process.env?.DEBUG || "";
+  const isEnabled = /* @__PURE__ */ __name(() => {
+    if (!DEBUG) return false;
+    if (DEBUG === "*") return true;
+    const patterns = DEBUG.split(",").map((p) => p.trim());
+    for (const pattern of patterns) {
+      if (pattern === namespace) return true;
+      if (pattern.endsWith("*") && namespace.startsWith(pattern.slice(0, -1)))
+        return true;
+      if (pattern.startsWith("-")) {
+        const negPattern = pattern.slice(1);
+        if (negPattern === namespace) return false;
+        if (negPattern.endsWith("*") && namespace.startsWith(negPattern.slice(0, -1)))
+          return false;
+      }
+    }
+    return false;
+  }, "isEnabled");
+  debugInstances.set(namespace, isEnabled());
+  return (...args) => {
+    if (!debugInstances.get(namespace)) return;
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+    const prefix = `[${timestamp}] ${namespace}`;
+    console.log(prefix, ...args);
+  };
+}
+__name(createDebug, "createDebug");
+var debug_default = createDebug;
+
+// src/decoder/aggregation.ts
+function standardAggregation(config) {
+  return Object.freeze(config);
+}
+__name(standardAggregation, "standardAggregation");
+var debug = debug_default("decoder:aggregation");
+var PluginAggregationEngine = class {
+  static {
+    __name(this, "PluginAggregationEngine");
+  }
+  plugins = /* @__PURE__ */ new Map();
+  states = /* @__PURE__ */ new Map();
+  // plugin -> key -> state
+  /**
+   * Register a plugin with aggregations
+   */
+  registerPlugin(plugin) {
+    if (plugin.name && plugin.aggregations && plugin.aggregations.length > 0) {
+      debug(
+        `Registering plugin ${plugin.name} with ${plugin.aggregations.length} aggregations`
+      );
+      this.plugins.set(plugin.name, plugin);
+      this.states.set(plugin.name, /* @__PURE__ */ new Map());
+    }
+  }
+  /**
+   * Process a transaction through relevant aggregations
+   */
+  processTransaction(tx) {
+    if (!tx.aggregationKeys || tx.aggregationKeys.length === 0) return;
+    for (const fullKey of tx.aggregationKeys) {
+      const [pluginName, ...keyParts] = fullKey.split(":");
+      const aggregationKey = keyParts.join(":");
+      const plugin = this.plugins.get(pluginName);
+      if (!plugin || !plugin.aggregations) {
+        debug(`processTransaction: No plugin found for ${pluginName}`);
+        continue;
+      }
+      const pluginStates = this.states.get(pluginName);
+      if (!pluginStates) {
+        debug(`processTransaction: No states for plugin ${pluginName}`);
+        continue;
+      }
+      const agg = plugin.aggregations.find((a) => a.key === aggregationKey);
+      if (!agg) {
+        debug(
+          `processTransaction: No aggregation found for key ${aggregationKey} in plugin ${pluginName}`
+        );
+        continue;
+      }
+      const mapped = agg.map(tx);
+      if (mapped !== void 0) {
+        const currentState = pluginStates.get(aggregationKey);
+        if (!currentState) {
+          debug(
+            `processTransaction: First transaction for ${pluginName}:${aggregationKey}`
+          );
+          pluginStates.set(aggregationKey, {
+            data: mapped,
+            lastTransaction: tx
+          });
+        } else {
+          const newData = agg.reduce(currentState.data, mapped);
+          pluginStates.set(aggregationKey, {
+            data: newData,
+            lastTransaction: tx
+            // Always update to latest transaction
+          });
+        }
+      } else {
+        debug(
+          `processTransaction: map returned undefined for ${pluginName}:${aggregationKey}`
+        );
+      }
+    }
+  }
+  /**
+   * Process a batch of transactions
+   */
+  processBatch(txs) {
+    debug(`Processing batch of ${txs.length} transactions`);
+    let processedCount = 0;
+    for (const tx of txs) {
+      this.processTransaction(tx);
+      if (tx.aggregationKeys && tx.aggregationKeys.length > 0) {
+        processedCount++;
+      }
+    }
+    debug(`Processed ${processedCount} transactions with aggregationKeys`);
+  }
+  /**
+   * Get finalized result for a specific plugin and aggregation key
+   */
+  getResult(pluginName, key) {
+    const plugin = this.plugins.get(pluginName);
+    const pluginStates = this.states.get(pluginName);
+    if (!plugin || !pluginStates) return void 0;
+    const agg = plugin.aggregations?.find((a) => a.key === key);
+    const state = pluginStates.get(key);
+    if (!agg || state === void 0) return void 0;
+    const aggregationResult = agg.finalize(state.data);
+    return {
+      ...state.lastTransaction,
+      ...aggregationResult,
+      resultType: "aggregate"
+    };
+  }
+  /**
+   * Get all aggregation results
+   */
+  getAllResults() {
+    const results = [];
+    for (const [pluginName, plugin] of this.plugins) {
+      const pluginStates = this.states.get(pluginName);
+      if (!pluginStates) {
+        continue;
+      }
+      for (const agg of plugin.aggregations || []) {
+        const state = pluginStates.get(agg.key);
+        if (state !== void 0) {
+          results.push({
+            plugin: pluginName,
+            key: agg.key,
+            result: {
+              ...state.lastTransaction,
+              ...agg.finalize(state.data),
+              resultType: "aggregate"
+            }
+          });
+        }
+      }
+    }
+    return results;
+  }
+  /**
+   * Clear all aggregation states
+   */
+  clear() {
+    for (const states of this.states.values()) {
+      states.clear();
+    }
+  }
+  /**
+   * Clear states for a specific plugin
+   */
+  clearPlugin(pluginName) {
+    this.states.get(pluginName)?.clear();
+  }
+  /**
+   * Get current state (for persistence)
+   */
+  getStates() {
+    return new Map(this.states);
+  }
+  /**
+   * Restore states (from persistence)
+   */
+  restoreStates(states) {
+    for (const [pluginName, pluginStates] of states) {
+      this.states.set(pluginName, new Map(pluginStates));
+    }
+  }
+};
+
+// src/decoder/events.ts
+import {
+  AbiDecodingDataSizeTooSmallError,
+  AbiEventSignatureEmptyTopicsError,
+  AbiEventSignatureNotFoundError,
+  BaseError,
+  DecodeLogDataMismatch,
+  DecodeLogTopicsMismatch,
+  decodeAbiParameters as decodeAbiParameters2,
+  size as size2,
+  toEventSelector
+} from "viem";
+import { formatAbiItem as formatAbiItem2 } from "viem/utils";
+var docsPath = "/docs/contract/decodeEventLog";
+function decodeTopic({ param, value }) {
+  if (param.type === "string" || param.type === "bytes" || param.type === "tuple" || param.type.match(/^(.*)\[(\d+)?\]$/))
+    return value;
+  const decodedArg = decodeAbiParameters2([param], value) || [];
+  return decodedArg[0];
+}
+__name(decodeTopic, "decodeTopic");
+function customDecodeEventLog(parameters) {
+  const {
+    abi: abi3,
+    data,
+    strict: strict_,
+    topics
+  } = parameters;
+  const strict = strict_ ?? true;
+  const [signature, ...argTopics] = topics;
+  if (!signature) throw new AbiEventSignatureEmptyTopicsError({ docsPath });
+  const abiItem = (() => {
+    if (abi3.length === 1) return abi3[0];
+    return abi3.find(
+      (x) => x.type === "event" && signature === toEventSelector(formatAbiItem2(x))
+    );
+  })();
+  if (!(abiItem && "name" in abiItem) || abiItem.type !== "event")
+    throw new AbiEventSignatureNotFoundError(signature, { docsPath });
+  const { name, inputs } = abiItem;
+  const isUnnamed = inputs?.some((x) => !("name" in x && x.name));
+  let args = isUnnamed ? [] : {};
+  const indexedInputs = inputs.filter((x) => "indexed" in x && x.indexed);
+  for (let i = 0; i < indexedInputs.length; i++) {
+    const param = indexedInputs[i];
+    const topic = argTopics[i];
+    if (!topic)
+      throw new DecodeLogTopicsMismatch({
+        abiItem,
+        param
+      });
+    if (isUnnamed && Array.isArray(args)) {
+      args[i] = decodeTopic({ param, value: topic });
+    } else if (!isUnnamed && !Array.isArray(args)) {
+      args[param.name || i] = decodeTopic({ param, value: topic });
+    }
+  }
+  const nonIndexedInputs = inputs.filter((x) => !("indexed" in x && x.indexed));
+  if (nonIndexedInputs.length > 0) {
+    if (data && data !== "0x") {
+      try {
+        const decodedData = decodeAbiParameters2(nonIndexedInputs, data);
+        if (decodedData) {
+          if (isUnnamed && Array.isArray(args)) {
+            args = [...args, ...decodedData];
+          } else if (!isUnnamed && !Array.isArray(args)) {
+            for (let i = 0; i < nonIndexedInputs.length; i++) {
+              const name2 = nonIndexedInputs[i].name;
+              if (name2) {
+                args[name2] = decodedData[i];
+              }
+            }
+          }
+        }
+      } catch (err) {
+        if (strict) {
+          if (err instanceof AbiDecodingDataSizeTooSmallError || err.name === "PositionOutOfBoundsError")
+            throw new DecodeLogDataMismatch({
+              abiItem,
+              data,
+              params: nonIndexedInputs,
+              size: size2(data)
+            });
+          throw err;
+        }
+      }
+    } else if (strict) {
+      throw new DecodeLogDataMismatch({
+        abiItem,
+        data: "0x",
+        params: nonIndexedInputs,
+        size: 0
+      });
+    }
+  }
+  const { args: namedArgs } = createNamedArgs(
+    Array.isArray(args) ? args : Object.values(args),
+    inputs
+  );
+  return {
+    eventName: name,
+    args: namedArgs
+  };
+}
+__name(customDecodeEventLog, "customDecodeEventLog");
+function decodeEvent(chain, abi3, log) {
+  const { data: _data, address, ...rest } = log;
+  let lastError;
+  try {
+    const result = customDecodeEventLog({
+      abi: abi3,
+      data: _data,
+      topics: log.topics || []
+    });
+    return { ...log, ...result };
+  } catch {
+  }
+}
+__name(decodeEvent, "decodeEvent");
+
+// src/decoder/plugins/RegistryAbi.ts
+var RegistryAbi_default = [
+  {
+    inputs: [
+      { internalType: "address", name: "creator", type: "address" },
+      { internalType: "address", name: "_codehub", type: "address" }
+    ],
+    stateMutability: "nonpayable",
+    type: "constructor"
+  },
+  { inputs: [], name: "ERC725Y_DataKeysValuesEmptyArray", type: "error" },
+  { inputs: [], name: "ERC725Y_DataKeysValuesLengthMismatch", type: "error" },
+  { inputs: [], name: "ERC725Y_MsgValueDisallowed", type: "error" },
+  {
+    inputs: [{ internalType: "bytes", name: "storedData", type: "bytes" }],
+    name: "InvalidExtensionAddress",
+    type: "error"
+  },
+  {
+    inputs: [{ internalType: "bytes", name: "data", type: "bytes" }],
+    name: "InvalidFunctionSelector",
+    type: "error"
+  },
+  { inputs: [], name: "LSP4TokenNameNotEditable", type: "error" },
+  { inputs: [], name: "LSP4TokenSymbolNotEditable", type: "error" },
+  { inputs: [], name: "LSP4TokenTypeNotEditable", type: "error" },
+  {
+    inputs: [{ internalType: "uint256", name: "callIndex", type: "uint256" }],
+    name: "LSP8BatchCallFailed",
+    type: "error"
+  },
+  { inputs: [], name: "LSP8CannotSendToAddressZero", type: "error" },
+  { inputs: [], name: "LSP8CannotSendToSelf", type: "error" },
+  { inputs: [], name: "LSP8CannotUseAddressZeroAsOperator", type: "error" },
+  { inputs: [], name: "LSP8InvalidTransferBatch", type: "error" },
+  {
+    inputs: [{ internalType: "bytes32", name: "tokenId", type: "bytes32" }],
+    name: "LSP8NonExistentTokenId",
+    type: "error"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "operator", type: "address" },
+      { internalType: "bytes32", name: "tokenId", type: "bytes32" }
+    ],
+    name: "LSP8NonExistingOperator",
+    type: "error"
+  },
+  {
+    inputs: [
+      { internalType: "bytes32", name: "tokenId", type: "bytes32" },
+      { internalType: "address", name: "caller", type: "address" }
+    ],
+    name: "LSP8NotTokenOperator",
+    type: "error"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "tokenOwner", type: "address" },
+      { internalType: "bytes32", name: "tokenId", type: "bytes32" },
+      { internalType: "address", name: "caller", type: "address" }
+    ],
+    name: "LSP8NotTokenOwner",
+    type: "error"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "tokenReceiver", type: "address" }
+    ],
+    name: "LSP8NotifyTokenReceiverContractMissingLSP1Interface",
+    type: "error"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "tokenReceiver", type: "address" }
+    ],
+    name: "LSP8NotifyTokenReceiverIsEOA",
+    type: "error"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "operator", type: "address" },
+      { internalType: "bytes32", name: "tokenId", type: "bytes32" }
+    ],
+    name: "LSP8OperatorAlreadyAuthorized",
+    type: "error"
+  },
+  { inputs: [], name: "LSP8TokenContractCannotHoldValue", type: "error" },
+  {
+    inputs: [{ internalType: "bytes32", name: "tokenId", type: "bytes32" }],
+    name: "LSP8TokenIdAlreadyMinted",
+    type: "error"
+  },
+  { inputs: [], name: "LSP8TokenIdFormatNotEditable", type: "error" },
+  { inputs: [], name: "LSP8TokenIdsDataEmptyArray", type: "error" },
+  { inputs: [], name: "LSP8TokenIdsDataLengthMismatch", type: "error" },
+  { inputs: [], name: "LSP8TokenOwnerCannotBeOperator", type: "error" },
+  {
+    inputs: [
+      { internalType: "bytes4", name: "functionSelector", type: "bytes4" }
+    ],
+    name: "NoExtensionFoundForFunctionSelector",
+    type: "error"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "callerAddress", type: "address" }
+    ],
+    name: "OwnableCallerNotTheOwner",
+    type: "error"
+  },
+  { inputs: [], name: "OwnableCannotSetZeroAddressAsOwner", type: "error" },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "dataKey",
+        type: "bytes32"
+      },
+      {
+        indexed: false,
+        internalType: "bytes",
+        name: "dataValue",
+        type: "bytes"
+      }
+    ],
+    name: "DataChanged",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "operator",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "tokenOwner",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "tokenId",
+        type: "bytes32"
+      },
+      {
+        indexed: false,
+        internalType: "bytes",
+        name: "operatorNotificationData",
+        type: "bytes"
+      }
+    ],
+    name: "OperatorAuthorizationChanged",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "operator",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "tokenOwner",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "tokenId",
+        type: "bytes32"
+      },
+      { indexed: false, internalType: "bool", name: "notified", type: "bool" },
+      {
+        indexed: false,
+        internalType: "bytes",
+        name: "operatorNotificationData",
+        type: "bytes"
+      }
+    ],
+    name: "OperatorRevoked",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "previousOwner",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "newOwner",
+        type: "address"
+      }
+    ],
+    name: "OwnershipTransferred",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "tokenId",
+        type: "bytes32"
+      },
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "dataKey",
+        type: "bytes32"
+      },
+      {
+        indexed: false,
+        internalType: "bytes",
+        name: "dataValue",
+        type: "bytes"
+      }
+    ],
+    name: "TokenIdDataChanged",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: false,
+        internalType: "address",
+        name: "operator",
+        type: "address"
+      },
+      { indexed: true, internalType: "address", name: "from", type: "address" },
+      { indexed: true, internalType: "address", name: "to", type: "address" },
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "tokenId",
+        type: "bytes32"
+      },
+      { indexed: false, internalType: "bool", name: "force", type: "bool" },
+      { indexed: false, internalType: "bytes", name: "data", type: "bytes" }
+    ],
+    name: "Transfer",
+    type: "event"
+  },
+  { stateMutability: "payable", type: "fallback" },
+  {
+    inputs: [
+      { internalType: "address", name: "operator", type: "address" },
+      { internalType: "bytes32", name: "tokenId", type: "bytes32" },
+      {
+        internalType: "bytes",
+        name: "operatorNotificationData",
+        type: "bytes"
+      }
+    ],
+    name: "authorizeOperator",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "address", name: "tokenOwner", type: "address" }],
+    name: "balanceOf",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "banner",
+    outputs: [{ internalType: "contract Fractal", name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "bytes[]", name: "data", type: "bytes[]" }],
+    name: "batchCalls",
+    outputs: [{ internalType: "bytes[]", name: "results", type: "bytes[]" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "bytes32", name: "dataKey", type: "bytes32" }],
+    name: "getData",
+    outputs: [{ internalType: "bytes", name: "dataValue", type: "bytes" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "bytes32[]", name: "dataKeys", type: "bytes32[]" }
+    ],
+    name: "getDataBatch",
+    outputs: [{ internalType: "bytes[]", name: "dataValues", type: "bytes[]" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "bytes32[]", name: "tokenIds", type: "bytes32[]" },
+      { internalType: "bytes32[]", name: "dataKeys", type: "bytes32[]" }
+    ],
+    name: "getDataBatchForTokenIds",
+    outputs: [{ internalType: "bytes[]", name: "dataValues", type: "bytes[]" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "bytes32", name: "tokenId", type: "bytes32" },
+      { internalType: "bytes32", name: "dataKey", type: "bytes32" }
+    ],
+    name: "getDataForTokenId",
+    outputs: [{ internalType: "bytes", name: "dataValue", type: "bytes" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "bytes32", name: "tokenId", type: "bytes32" }],
+    name: "getOperatorsOf",
+    outputs: [{ internalType: "address[]", name: "", type: "address[]" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "to", type: "address" },
+      { internalType: "uint32", name: "seed", type: "uint32" },
+      { internalType: "address", name: "fractal", type: "address" }
+    ],
+    name: "inject",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "operator", type: "address" },
+      { internalType: "bytes32", name: "tokenId", type: "bytes32" }
+    ],
+    name: "isOperatorFor",
+    outputs: [{ internalType: "bool", name: "", type: "bool" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "fractal", type: "address" },
+      { internalType: "address", name: "owner", type: "address" },
+      { internalType: "address", name: "registry", type: "address" }
+    ],
+    name: "migrate",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "to", type: "address" },
+      { internalType: "uint32", name: "seed", type: "uint32" }
+    ],
+    name: "mint",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "uint32", name: "", type: "uint32" }],
+    name: "minted",
+    outputs: [{ internalType: "address", name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "owner",
+    outputs: [{ internalType: "address", name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "bool", name: "_paused", type: "bool" }],
+    name: "pause",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "paused",
+    outputs: [{ internalType: "bool", name: "", type: "bool" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "bytes32", name: "tokenId", type: "bytes32" },
+      { internalType: "uint256", name: "iters", type: "uint256" }
+    ],
+    name: "refine",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "renounceOwnership",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "operator", type: "address" },
+      { internalType: "bytes32", name: "tokenId", type: "bytes32" },
+      { internalType: "bool", name: "notify", type: "bool" },
+      {
+        internalType: "bytes",
+        name: "operatorNotificationData",
+        type: "bytes"
+      }
+    ],
+    name: "revokeOperator",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "address", name: "", type: "address" }],
+    name: "seeds",
+    outputs: [{ internalType: "uint32", name: "", type: "uint32" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "bytes32", name: "dataKey", type: "bytes32" },
+      { internalType: "bytes", name: "dataValue", type: "bytes" }
+    ],
+    name: "setData",
+    outputs: [],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "bytes32[]", name: "dataKeys", type: "bytes32[]" },
+      { internalType: "bytes[]", name: "dataValues", type: "bytes[]" }
+    ],
+    name: "setDataBatch",
+    outputs: [],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "bytes32[]", name: "tokenIds", type: "bytes32[]" },
+      { internalType: "bytes32[]", name: "dataKeys", type: "bytes32[]" },
+      { internalType: "bytes[]", name: "dataValues", type: "bytes[]" }
+    ],
+    name: "setDataBatchForTokenIds",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "bytes32", name: "tokenId", type: "bytes32" },
+      { internalType: "bytes32", name: "dataKey", type: "bytes32" },
+      { internalType: "bytes", name: "dataValue", type: "bytes" }
+    ],
+    name: "setDataForTokenId",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "bytes4", name: "interfaceId", type: "bytes4" }],
+    name: "supportsInterface",
+    outputs: [{ internalType: "bool", name: "", type: "bool" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "uint256", name: "index", type: "uint256" }],
+    name: "tokenAt",
+    outputs: [{ internalType: "bytes32", name: "", type: "bytes32" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "address", name: "tokenOwner", type: "address" }],
+    name: "tokenIdsOf",
+    outputs: [{ internalType: "bytes32[]", name: "", type: "bytes32[]" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "bytes32", name: "tokenId", type: "bytes32" }],
+    name: "tokenOwnerOf",
+    outputs: [{ internalType: "address", name: "", type: "address" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "totalSupply",
+    outputs: [{ internalType: "uint256", name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address", name: "from", type: "address" },
+      { internalType: "address", name: "to", type: "address" },
+      { internalType: "bytes32", name: "tokenId", type: "bytes32" },
+      { internalType: "bool", name: "force", type: "bool" },
+      { internalType: "bytes", name: "data", type: "bytes" }
+    ],
+    name: "transfer",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      { internalType: "address[]", name: "from", type: "address[]" },
+      { internalType: "address[]", name: "to", type: "address[]" },
+      { internalType: "bytes32[]", name: "tokenId", type: "bytes32[]" },
+      { internalType: "bool[]", name: "force", type: "bool[]" },
+      { internalType: "bytes[]", name: "data", type: "bytes[]" }
+    ],
+    name: "transferBatch",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [{ internalType: "address", name: "newOwner", type: "address" }],
+    name: "transferOwnership",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  { stateMutability: "payable", type: "receive" }
+];
+
+// src/decoder/plugins/enhanceBurntPix.ts
+var refineAggregation = standardAggregation({
+  key: "refine",
+  map: /* @__PURE__ */ __name((tx) => {
+    if ("functionName" in tx && tx.functionName === "refine" && tx.from) {
+      return {
+        callerCounts: {
+          [tx.from.toLowerCase()]: {
+            count: 1,
+            tokenIds: {
+              [`${tx.to}:${("args" in tx ? tx?.args?.[0]?.value : void 0) ?? "none"}`]: 1
+            }
+          }
+        },
+        minBlock: Number(tx.blockNumber),
+        maxBlock: Number(tx.blockNumber),
+        count: 1
+      };
+    }
+    return void 0;
+  }, "map"),
+  reduce: /* @__PURE__ */ __name((state, mapped) => {
+    if (!state) return mapped;
+    const callerCounts = { ...state.callerCounts };
+    for (const [caller, { count, tokenIds }] of Object.entries(
+      mapped.callerCounts
+    )) {
+      const item = callerCounts[caller] ?? { count: 0, tokenIds: {} };
+      item.count += count;
+      item.tokenIds = {
+        ...item.tokenIds,
+        ...tokenIds
+      };
+    }
+    return {
+      callerCounts,
+      minBlock: Math.min(state.minBlock, mapped.minBlock),
+      maxBlock: Math.max(state.maxBlock, mapped.maxBlock),
+      count: state.count + mapped.count
+    };
+  }, "reduce"),
+  finalize: /* @__PURE__ */ __name((state) => {
+    const stats = Object.entries(state.callerCounts).sort(([, a], [, b]) => b.count - a.count).slice(0, 10).map(([address, { count, tokenIds }]) => {
+      const tokens = Object.entries(tokenIds).sort(([, a], [, b]) => b - a).slice(0, 5).map(([token]) => token);
+      return { address, count, tokens };
+    });
+    return {
+      aggregate: {
+        count: state.count,
+        from: stats.map(({ address }) => address),
+        tokens: stats.flatMap(({ tokens }) => tokens),
+        blockRange: {
+          from: state.minBlock,
+          to: state.maxBlock
+        }
+      }
+    };
+  }, "finalize")
+});
+var enhanceBurntPixPlugin = standardPlugin(
+  RegistryAbi_default,
+  {
+    name: "burntpix",
+    abiName: "BurntPix",
+    decoderName: "@lukso/burntpix",
+    priority: 50
+  },
+  {
+    enhance: enhanceBurntPix,
+    decodeEvent: /* @__PURE__ */ __name(async (log, options) => {
+      return decodeEvent(options.chain, RegistryAbi_default, log);
+    }, "decodeEvent"),
+    aggregations: [refineAggregation]
+  }
+);
+async function enhanceBurntPix(result, pluginOptions, options) {
+  if ("functionName" in result && result.functionName === "refine") {
+    return {
+      ...result,
+      standard: pluginOptions.abiName,
+      __decoder: pluginOptions.decoderName,
+      aggregationKeys: [createAggregationKey(pluginOptions, "refine")]
+    };
+  }
+  return void 0;
+}
+__name(enhanceBurntPix, "enhanceBurntPix");
+var enhanceBurntPix_default = enhanceBurntPixPlugin;
+
+// src/decoder/plugins/enhanceGraffiti.ts
+import {
+  bytesToString,
+  hexToBytes,
+  size as size3,
+  slice as slice2
+} from "viem";
+var enhanceGraffitiPlugin = Object.freeze({
+  enhance: /* @__PURE__ */ __name(async (result, options) => enhanceGraffiti(
+    result,
+    { abiName: "graffiti", decoderName: "graffiti" },
+    options
+  ), "enhance"),
+  decodeEvent: /* @__PURE__ */ __name(async (log, options) => void 0, "decodeEvent"),
+  required: true,
+  priority: 1e3,
+  name: "graffiti"
+});
+async function enhanceGraffiti(result, _pluginOptions, _options) {
+  const { functionName, sig, args, input } = result;
+  if (input && size3(input || "0x") >= 4 && slice2(input || "0x", 0, 4) === "0x00000000") {
+    let graffiti = slice2(input, 4);
+    try {
+      graffiti = bytesToString(hexToBytes(graffiti));
+    } catch {
+    }
+    return {
+      ...result,
+      resultType: "grafitti",
+      sig: "0x",
+      functionName: "",
+      input,
+      graffiti,
+      __decoder: "grafitti"
+    };
+  }
+  return void 0;
+}
+__name(enhanceGraffiti, "enhanceGraffiti");
+var enhanceGraffiti_default = enhanceGraffitiPlugin;
+
+// src/decoder/plugins/enhanceLSP0ERC725Account.ts
+import { universalProfileAbi as UniversalProfile } from "@lukso/universalprofile-contracts/abi";
+
+// src/decoder/transaction.ts
+import { isAddress, isAddressEqual, slice as slice3, zeroAddress } from "viem";
+async function decodeTransaction(fullTransaction, options) {
+  const { preferError } = options;
+  const {
+    to,
+    from,
+    value,
+    input: rawInput,
+    data: rawData,
+    ...restTransaction
+  } = fullTransaction;
+  const { logs, ...transaction } = {
+    ...restTransaction,
+    to,
+    from,
+    value,
+    input: rawInput || rawData
+  };
+  const data = rawInput || rawData;
+  if (!data || data === "0x") {
+    if (preferError) {
+      return {
+        ...transaction,
+        isDecoded: true,
+        functionName: void 0,
+        __decoder: void 0,
+        sig: slice3(data || "0x", 0, 4),
+        resultType: "error",
+        errorType: "INVALID" /* INVALID */,
+        ...createNamedArgs([], []),
+        standard: void 0,
+        phase: "enhanced"
+      };
+    }
+    return {
+      ...transaction,
+      isDecoded: true,
+      functionName: void 0,
+      __decoder: void 0,
+      standard: void 0,
+      sig: slice3(data || "0x", 0, 4),
+      ...createNamedArgs([], []),
+      resultType: "execute",
+      phase: "enhanced"
+    };
+  }
+  let lastError;
+  const activePlugins = options.plugins;
+  for (const plugin of activePlugins) {
+    if (to && isAddress(to) && isAddressEqual(to, zeroAddress)) {
+      return {
+        ...transaction,
+        isDecoded: true,
+        ...createNamedArgs([], []),
+        resultType: "create",
+        to,
+        from,
+        value,
+        logs,
+        phase: "immediate"
+      };
+    }
+    try {
+      const check = await plugin.enhance(transaction, options);
+      if (check) {
+        const output = [];
+        if (logs) {
+          for (const log of logs) {
+            const data2 = await plugin.decodeEvent(log, options);
+            if (data2) {
+              output.push(data2);
+              continue;
+            }
+            let done = false;
+            for (const eventPlugin of activePlugins) {
+              if (eventPlugin !== plugin) {
+                const data3 = await eventPlugin.decodeEvent(log, options);
+                if (data3) {
+                  output.push(data3);
+                  done = true;
+                  break;
+                }
+              }
+            }
+            if (!done) {
+              output.push(log);
+            }
+          }
+          check.logs = output;
+        }
+        let phase2 = plugin.usesAsync || "functionName" in check && check.functionName && check.standard || check.input === "0x" || !check.input ? "enhanced" : "immediate";
+        const resultWithChildren = check;
+        if (phase2 === "enhanced" && resultWithChildren.children && Array.isArray(resultWithChildren.children) && resultWithChildren.children.length > 0) {
+          const allChildrenEnhanced = resultWithChildren.children.every(
+            (child) => child.phase === "enhanced"
+          );
+          if (!allChildrenEnhanced) {
+            phase2 = "immediate";
+          }
+        }
+        const result2 = {
+          ...transaction,
+          ...check,
+          phase: phase2
+        };
+        return result2;
+      }
+    } catch (e) {
+      console.error(e);
+      continue;
+    }
+  }
+  let phase = "functionName" in transaction && transaction.functionName && transaction.standard || transaction.input === "0x" || !transaction.input ? "enhanced" : "immediate";
+  const transactionWithChildren = transaction;
+  if (phase === "enhanced" && transactionWithChildren.children && Array.isArray(transactionWithChildren.children) && transactionWithChildren.children.length > 0) {
+    const allChildrenEnhanced = transactionWithChildren.children.every(
+      (child) => child.phase === "enhanced"
+    );
+    if (!allChildrenEnhanced) {
+      phase = "immediate";
+    }
+  }
+  const result = {
+    ...transaction,
+    standard: void 0,
+    __decoder: void 0,
+    resultType: "raw",
+    phase,
+    sig: slice3(
+      fullTransaction.input || "data" in fullTransaction && fullTransaction.data || "0x",
+      0,
+      4
+    ),
+    ...createNamedArgs([], []),
+    ...options.wrappers.length ? { wrappers: options.wrappers } : {},
+    logs
+  };
+  return result;
+}
+__name(decodeTransaction, "decodeTransaction");
+
+// src/decoder/plugins/enhanceSetData.ts
+async function enhanceSetData(result, pluginOptions, options) {
+  const { functionName, sig, args, input, blockNumber, to, from, value } = result;
+  switch (functionName) {
+    case "setData": {
+      const [_key, _value] = args.map(({ value: value2 }) => value2);
+      return {
+        ...result,
+        resultType: "setDataBatch",
+        functionName,
+        standard: result.standard || pluginOptions.abiName || "LSPContract",
+        __decoder: result.__decoder || pluginOptions.decoderName || "@lukso/lsp-smart-contracts",
+        input,
+        blockNumber,
+        sig,
+        args,
+        children: [
+          {
+            ...result,
+            info: await decodeKeyValueRaw(_key, _value, options),
+            standard: result.standard || pluginOptions.abiName || "LSPContract",
+            __decoder: result.__decoder || pluginOptions.decoderName || "@lukso/lsp-smart-contracts",
+            phase: "enhanced",
+            to,
+            from,
+            value,
+            ...args ? {
+              ...createNamedArgs(
+                [_key, _value],
+                [
+                  { name: "key", type: "bytes32" },
+                  { name: "value", type: "bytes" }
+                ]
+              )
+            } : {}
+          }
+        ],
+        to,
+        from,
+        value
+      };
+    }
+    case "setDataBatch": {
+      const children = [];
+      const [keys, values] = args.map(({ value: value2 }) => value2);
+      for (let i = 0; i < keys.length; i++) {
+        const key = keys[i];
+        const _value = values[i];
+        children.push({
+          ...result,
+          resultType: "setData",
+          standard: result.standard || pluginOptions.abiName || "LSPContract",
+          __decoder: result.__decoder || pluginOptions.decoderName || "@lukso/lsp-smart-contracts",
+          phase: "enhanced",
+          to,
+          from,
+          value,
+          ...createNamedArgs(
+            [key, _value],
+            [
+              { name: "key", type: "bytes32" },
+              { name: "value", type: "bytes" }
+            ]
+          ),
+          info: await decodeKeyValueRaw(key, _value, options)
+        });
+      }
+      const setDataBatchResult = {
+        ...result,
+        resultType: "setDataBatch",
+        functionName,
+        sig,
+        input,
+        ...args ? { args } : {},
+        standard: result.standard || pluginOptions.abiName || "LSPContract",
+        __decoder: result.__decoder || pluginOptions.decoderName || "@lukso/lsp-smart-contracts",
+        to,
+        from,
+        value,
+        children
+      };
+      return setDataBatchResult;
+    }
+  }
+  return void 0;
+}
+__name(enhanceSetData, "enhanceSetData");
+
+// src/decoder/plugins/enhanceLSP0ERC725Account.ts
+var enhanceLSP0ERC725AccountPlugin = standardPlugin(
+  UniversalProfile,
+  {
+    name: "profile",
+    abiName: "LSP0ERC725Account",
+    decoderName: "@lukso/lsp-smart-contracts"
+  },
+  {
+    enhance: enhanceLSP0ERC725Account,
+    decodeEvent: /* @__PURE__ */ __name(async (log, options) => {
+      return decodeEvent(options.chain, UniversalProfile, log);
+    }, "decodeEvent")
+  }
+);
+async function enhanceLSP0ERC725Account(result, pluginOptions, options) {
+  const setData = await enhanceSetData(
+    result,
+    { ...pluginOptions, abiName: "", decoderName: "" },
+    options
+  );
+  if (setData) {
+    return setData;
+  }
+  const {
+    functionName,
+    sig,
+    args,
+    input,
+    blockNumber,
+    to: _to,
+    from: _from,
+    value
+  } = result;
+  let to = _to;
+  let from = _from;
+  switch (functionName) {
+    case "executeBatch": {
+      const children = [];
+      const [executeTypes, targets, values, inputs] = args.map(
+        ({ value: value2 }) => value2
+      );
+      const {
+        functionName: _functionName,
+        sig: _sig,
+        args: _args,
+        resultType: _resultType,
+        ...plainResult
+      } = result;
+      for (let i = 0; i < values.length; i++) {
+        const _data = inputs[i];
+        const _value = BigInt(values[i]);
+        const _to2 = targets[i];
+        const decoded = await decodeTransaction(
+          {
+            input: _data,
+            to: _to2,
+            from,
+            value: _value
+          },
+          options
+        );
+        children.push(
+          executeTypes[i] === 1n ? {
+            ...plainResult,
+            ...decoded,
+            resultType: "create"
+          } : { ...plainResult, ...decoded }
+        );
+      }
+      options.wrappers.splice(0, 0, {
+        ...result,
+        resultType: "wrapper",
+        functionName,
+        sig,
+        standard: pluginOptions.abiName,
+        args,
+        to,
+        from,
+        value,
+        input,
+        __decoder: pluginOptions.decoderName
+      });
+      const execute = {
+        ...result,
+        resultType: "executeBatch",
+        standard: pluginOptions.abiName,
+        __decoder: pluginOptions.decoderName,
+        children,
+        to,
+        from,
+        value
+      };
+      return {
+        blockNumber,
+        ...execute
+      };
+    }
+    case "execute": {
+      const [executeType, target, value2, _data] = args.map(
+        ({ value: value3 }) => value3
+      );
+      const decoded = await decodeTransaction(
+        {
+          input: _data,
+          to: target,
+          from: to || from,
+          // This should be decoded to the profile address if it's a controller.
+          value: value2
+        },
+        options
+      );
+      from = to || from;
+      to = target || to;
+      options.wrappers?.splice(0, 0, {
+        ...result,
+        resultType: "wrapper",
+        functionName,
+        sig,
+        input,
+        __decoder: pluginOptions.decoderName,
+        to,
+        from,
+        value: value2,
+        standard: pluginOptions.abiName,
+        ...createNamedArgs(
+          [executeType, target, value2, _data],
+          [
+            { name: "executeType", type: "uint256" },
+            { name: "target", type: "address" },
+            { name: "value", type: "uint256" },
+            { name: "data", type: "bytes" }
+          ]
+        )
+      });
+      return {
+        ...result,
+        functionName,
+        sig,
+        standard: pluginOptions.abiName,
+        __decoder: pluginOptions.decoderName,
+        ...decoded,
+        resultType: executeType === 1n ? "create" : "execute"
+      };
+    }
+  }
+}
+__name(enhanceLSP0ERC725Account, "enhanceLSP0ERC725Account");
+var enhanceLSP0ERC725Account_default = enhanceLSP0ERC725AccountPlugin;
+
+// src/decoder/plugins/enhanceLSP6KeyManager.ts
+import { lsp6KeyManagerAbi as KeyManager } from "@lukso/lsp6-contracts/abi";
+
+// ../../node_modules/.pnpm/@lukso+lsp6-contracts@0.15.5/node_modules/@lukso/lsp6-contracts/artifacts/LSP6KeyManager.json
+var abi = [
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "target_",
+        type: "address"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "constructor"
+  },
+  {
+    inputs: [],
+    name: "BatchExecuteParamsLengthMismatch",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "BatchExecuteRelayCallParamsLengthMismatch",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "CallingKeyManagerNotAllowed",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "DelegateCallDisallowedViaKeyManager",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "ERC725X_ExecuteParametersEmptyArray",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "ERC725X_ExecuteParametersLengthMismatch",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "ERC725Y_DataKeysValuesLengthMismatch",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "dataKey",
+        type: "bytes32"
+      },
+      {
+        internalType: "bytes",
+        name: "dataValue",
+        type: "bytes"
+      }
+    ],
+    name: "InvalidDataValuesForDataKeys",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes4",
+        name: "invalidFunction",
+        type: "bytes4"
+      }
+    ],
+    name: "InvalidERC725Function",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "allowedCallsValue",
+        type: "bytes"
+      }
+    ],
+    name: "InvalidEncodedAllowedCalls",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "value",
+        type: "bytes"
+      },
+      {
+        internalType: "string",
+        name: "context",
+        type: "string"
+      }
+    ],
+    name: "InvalidEncodedAllowedERC725YDataKeys",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "InvalidLSP6Target",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "payload",
+        type: "bytes"
+      }
+    ],
+    name: "InvalidPayload",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "signer",
+        type: "address"
+      },
+      {
+        internalType: "uint256",
+        name: "invalidNonce",
+        type: "uint256"
+      },
+      {
+        internalType: "bytes",
+        name: "signature",
+        type: "bytes"
+      }
+    ],
+    name: "InvalidRelayNonce",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "from",
+        type: "address"
+      }
+    ],
+    name: "InvalidWhitelistedCall",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "KeyManagerCannotBeSetAsExtensionForLSP20Functions",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "totalValues",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "msgValue",
+        type: "uint256"
+      }
+    ],
+    name: "LSP6BatchExcessiveValueSent",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "totalValues",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "msgValue",
+        type: "uint256"
+      }
+    ],
+    name: "LSP6BatchInsufficientValueSent",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "from",
+        type: "address"
+      }
+    ],
+    name: "NoCallsAllowed",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "from",
+        type: "address"
+      }
+    ],
+    name: "NoERC725YDataKeysAllowed",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "from",
+        type: "address"
+      }
+    ],
+    name: "NoPermissionsSet",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "from",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "to",
+        type: "address"
+      },
+      {
+        internalType: "bytes4",
+        name: "selector",
+        type: "bytes4"
+      }
+    ],
+    name: "NotAllowedCall",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "from",
+        type: "address"
+      },
+      {
+        internalType: "bytes32",
+        name: "disallowedKey",
+        type: "bytes32"
+      }
+    ],
+    name: "NotAllowedERC725YDataKey",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "from",
+        type: "address"
+      },
+      {
+        internalType: "string",
+        name: "permission",
+        type: "string"
+      }
+    ],
+    name: "NotAuthorised",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "dataKey",
+        type: "bytes32"
+      }
+    ],
+    name: "NotRecognisedPermissionKey",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "RelayCallBeforeStartTime",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "RelayCallExpired",
+    type: "error"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "signer",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "uint256",
+        name: "value",
+        type: "uint256"
+      },
+      {
+        indexed: true,
+        internalType: "bytes4",
+        name: "selector",
+        type: "bytes4"
+      }
+    ],
+    name: "PermissionsVerified",
+    type: "event"
+  },
+  {
+    inputs: [],
+    name: "VERSION",
+    outputs: [
+      {
+        internalType: "string",
+        name: "",
+        type: "string"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "payload",
+        type: "bytes"
+      }
+    ],
+    name: "execute",
+    outputs: [
+      {
+        internalType: "bytes",
+        name: "",
+        type: "bytes"
+      }
+    ],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256[]",
+        name: "values",
+        type: "uint256[]"
+      },
+      {
+        internalType: "bytes[]",
+        name: "payloads",
+        type: "bytes[]"
+      }
+    ],
+    name: "executeBatch",
+    outputs: [
+      {
+        internalType: "bytes[]",
+        name: "",
+        type: "bytes[]"
+      }
+    ],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes",
+        name: "signature",
+        type: "bytes"
+      },
+      {
+        internalType: "uint256",
+        name: "nonce",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "validityTimestamps",
+        type: "uint256"
+      },
+      {
+        internalType: "bytes",
+        name: "payload",
+        type: "bytes"
+      }
+    ],
+    name: "executeRelayCall",
+    outputs: [
+      {
+        internalType: "bytes",
+        name: "",
+        type: "bytes"
+      }
+    ],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes[]",
+        name: "signatures",
+        type: "bytes[]"
+      },
+      {
+        internalType: "uint256[]",
+        name: "nonces",
+        type: "uint256[]"
+      },
+      {
+        internalType: "uint256[]",
+        name: "validityTimestamps",
+        type: "uint256[]"
+      },
+      {
+        internalType: "uint256[]",
+        name: "values",
+        type: "uint256[]"
+      },
+      {
+        internalType: "bytes[]",
+        name: "payloads",
+        type: "bytes[]"
+      }
+    ],
+    name: "executeRelayCallBatch",
+    outputs: [
+      {
+        internalType: "bytes[]",
+        name: "",
+        type: "bytes[]"
+      }
+    ],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "from",
+        type: "address"
+      },
+      {
+        internalType: "uint128",
+        name: "channelId",
+        type: "uint128"
+      }
+    ],
+    name: "getNonce",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "dataHash",
+        type: "bytes32"
+      },
+      {
+        internalType: "bytes",
+        name: "signature",
+        type: "bytes"
+      }
+    ],
+    name: "isValidSignature",
+    outputs: [
+      {
+        internalType: "bytes4",
+        name: "returnedStatus",
+        type: "bytes4"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "targetContract",
+        type: "address"
+      },
+      {
+        internalType: "address",
+        name: "caller",
+        type: "address"
+      },
+      {
+        internalType: "uint256",
+        name: "msgValue",
+        type: "uint256"
+      },
+      {
+        internalType: "bytes",
+        name: "callData",
+        type: "bytes"
+      }
+    ],
+    name: "lsp20VerifyCall",
+    outputs: [
+      {
+        internalType: "bytes4",
+        name: "",
+        type: "bytes4"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "",
+        type: "bytes32"
+      },
+      {
+        internalType: "bytes",
+        name: "",
+        type: "bytes"
+      }
+    ],
+    name: "lsp20VerifyCallResult",
+    outputs: [
+      {
+        internalType: "bytes4",
+        name: "",
+        type: "bytes4"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes4",
+        name: "interfaceId",
+        type: "bytes4"
+      }
+    ],
+    name: "supportsInterface",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "target",
+    outputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  }
+];
+
+// src/decoder/interfaces.ts
+import { LRUCache } from "lru-cache";
+import {
+  encodeFunctionData,
+  getContract
+} from "viem";
+var TARGETS = new LRUCache({
+  max: 1e3,
+  ttl: 1e3 * 60 * 60
+});
+async function getKMTarget(chain, address) {
+  if (!address) {
+    return void 0;
+  }
+  const info = TARGETS.get(address);
+  if (info) {
+    return info;
+  }
+  const client = getPublicClient(chain);
+  const out = client.readContract({
+    address,
+    abi,
+    functionName: "target"
+  }).catch(() => void 0);
+  TARGETS.set(address, out);
+  return out;
+}
+__name(getKMTarget, "getKMTarget");
+var INTERFACE_INFO = new LRUCache({
+  max: 1e3,
+  ttl: 1e3 * 60 * 60
+});
+
+// src/decoder/plugins/enhanceLSP6KeyManager.ts
+var enhanceLSP6KeyManagerPlugin = standardPlugin(
+  KeyManager,
+  {
+    name: "keyManager",
+    abiName: "LSP6KeyManager",
+    decoderName: "@lukso/lsp-smart-contracts"
+  },
+  {
+    enhance: /* @__PURE__ */ __name(async (result, pluginOptions, options) => {
+      const setData = await enhanceSetData(result, pluginOptions, options);
+      if (setData) {
+        return setData;
+      }
+      return enhanceKeyManager(result, pluginOptions, options);
+    }, "enhance"),
+    decodeEvent: /* @__PURE__ */ __name(async (log, options) => {
+      return decodeEvent(options.chain, KeyManager, log);
+    }, "decodeEvent")
+  }
+);
+async function enhanceKeyManager(result, pluginOptions, options) {
+  const {
+    functionName,
+    sig,
+    args,
+    input,
+    blockNumber,
+    to: _to,
+    from: _from,
+    value
+  } = result;
+  let to = _to;
+  let from = _from;
+  switch (functionName) {
+    case "execute": {
+      const decoded = await decodeTransaction(
+        {
+          input: args?.[0]?.value,
+          to,
+          from,
+          value
+        },
+        options
+      );
+      options.wrappers?.splice(0, 0, {
+        ...result,
+        resultType: "wrapper",
+        __decoder: pluginOptions.decoderName,
+        functionName,
+        sig,
+        input,
+        standard: pluginOptions.abiName,
+        args
+      });
+      const execute = {
+        ...result,
+        ...decoded,
+        to,
+        from,
+        value
+      };
+      return {
+        ...execute
+      };
+    }
+    case "executeBatch": {
+      const children = [];
+      const [values, inputs] = args.map(({ value: value2 }) => value2);
+      const {
+        functionName: _functionName,
+        sig: _sig,
+        args: _args,
+        resultType: _resultType,
+        ...plainResult
+      } = result;
+      for (let i = 0; i < values.length; i++) {
+        const _data = inputs[i];
+        const _value = BigInt(values[i]);
+        const decoded = await decodeTransaction(
+          {
+            input: _data,
+            to,
+            from,
+            value: _value
+          },
+          options
+        );
+        children.push({ ...plainResult, ...decoded });
+      }
+      options.wrappers?.splice(0, 0, {
+        ...result,
+        resultType: "wrapper",
+        functionName,
+        sig,
+        __decoder: pluginOptions.decoderName,
+        standard: pluginOptions.abiName,
+        args,
+        input
+      });
+      return {
+        ...result,
+        resultType: "executeBatch",
+        __decoder: "@lukso/lsp-smart-contracts",
+        standard: pluginOptions.abiName,
+        children,
+        to,
+        from,
+        value
+      };
+    }
+    case "executeRelayerCallBatch": {
+      const [signatures, nonces, validityTimestamps, values, payloads] = args.map(({ value: value2 }) => value2);
+      const children = [];
+      for (let i = 0; i < values.length; i++) {
+        const _data = payloads[i];
+        const _value = BigInt(values[i]);
+        const _signature = signatures[i];
+        const _nonce = nonces[i];
+        const _validityTimestamp = validityTimestamps[i];
+        const decoded = await decodeTransaction(
+          {
+            input: _data,
+            to,
+            from,
+            value: _value
+          },
+          options
+        );
+        children.push({ ...result, ...decoded });
+      }
+      options.wrappers?.splice(0, 0, {
+        ...result,
+        resultType: "wrapper",
+        __decoder: pluginOptions.decoderName,
+        functionName,
+        sig,
+        input,
+        standard: pluginOptions.abiName,
+        args
+      });
+      return {
+        ...result,
+        resultType: "executeBatch",
+        __decoder: pluginOptions.decoderName,
+        standard: pluginOptions.abiName,
+        children,
+        to,
+        from,
+        value
+      };
+    }
+    // -> executeRelayCall
+    case "executeRelayCall": {
+      const [_signature, _nonce, _validityTimestamps, _input] = args.map(
+        ({ value: value2 }) => value2
+      );
+      const _target = await getKMTarget(options.chain, to);
+      const decoded = await decodeTransaction(
+        {
+          input: _input,
+          to: _target ?? to,
+          from,
+          value
+        },
+        options
+      );
+      from = to || from;
+      to = _target || to;
+      options.wrappers?.splice(0, 0, {
+        ...result,
+        resultType: "wrapper",
+        __decoder: pluginOptions.decoderName,
+        functionName,
+        sig,
+        input,
+        standard: pluginOptions.abiName,
+        to,
+        from,
+        value,
+        args
+      });
+      return {
+        ...decoded
+      };
+    }
+  }
+}
+__name(enhanceKeyManager, "enhanceKeyManager");
+var enhanceLSP6KeyManager_default = enhanceLSP6KeyManagerPlugin;
+
+// src/decoder/plugins/enhanceLSP7DigitalAsset.ts
+import {
+  lsp7BurnableAbi,
+  lsp7CappedSupplyAbi,
+  lsp7DigitalAssetAbi,
+  lsp7MintableAbi,
+  lsp7VotesAbi
+} from "@lukso/lsp7-contracts/abi";
+
+// src/decoder/cache.ts
+function makeCacheKey(type, ...parts) {
+  return `${type}:${parts.join(":")}`;
+}
+__name(makeCacheKey, "makeCacheKey");
+
+// src/decoder/plugins/enhanceLSP7DigitalAsset.ts
+var LSP7 = [
+  ...lsp7DigitalAssetAbi,
+  ...lsp7MintableAbi,
+  ...lsp7BurnableAbi,
+  ...lsp7CappedSupplyAbi,
+  ...lsp7VotesAbi
+];
+var enhanceLSP7DigitalAssetPlugin = standardPlugin(
+  LSP7,
+  {
+    name: "lsp7",
+    abiName: "LSP7DigitalAsset",
+    decoderName: "@lukso/lsp-smart-contracts"
+  },
+  {
+    enhance: /* @__PURE__ */ __name(async (result, pluginOptions, options) => {
+      const setData = await enhanceSetData(
+        result,
+        { ...pluginOptions, abiName: "", decoderName: "" },
+        options
+      );
+      if (setData) {
+        return setData;
+      }
+      if (options.async) {
+        await enhanceLSP7Metadata(result, options);
+      }
+      const follow = await enhanceLSP26FollowerSystem(
+        result,
+        pluginOptions,
+        options
+      );
+      if (follow) {
+        return follow;
+      }
+      return result;
+    }, "enhance"),
+    decodeEvent: /* @__PURE__ */ __name(async (log, options) => {
+      return decodeEvent(options.chain, LSP7, log);
+    }, "decodeEvent")
+  }
+);
+async function enhanceLSP7Metadata(result, options) {
+  if (!options.cache || !result.to) return;
+  const contractAddress = result.to;
+  const cacheKey = makeCacheKey(
+    "contract-meta" /* CONTRACT_METADATA */,
+    contractAddress,
+    "lsp4-token-type"
+  );
+  try {
+    const metadata = await options.cache.getOrSet(
+      cacheKey,
+      async () => {
+        const client = getPublicClient(options.chain);
+        const tokenTypeData = await client.readContract({
+          address: contractAddress,
+          abi: LSP7,
+          functionName: "getData",
+          args: [
+            "0xe0261fa95db2eb3b5439bd033cda66d56b96f92f243a8228fd87550ed7bdfdb3"
+          ]
+        });
+        const typeValue = tokenTypeData ? Number.parseInt(tokenTypeData, 16) : 0;
+        return {
+          tokenType: typeValue,
+          isToken: typeValue === 0,
+          isNFT: typeValue === 1,
+          isCollection: typeValue === 2
+        };
+      },
+      {
+        ttl: 1e3 * 60 * 60 * 24,
+        // Cache for 24 hours (metadata rarely changes)
+        signal: options.signal
+      }
+    );
+    result.custom = result.custom || {};
+    Object.assign(result.custom, metadata);
+  } catch (error) {
+    console.warn("Failed to fetch LSP7 metadata:", error);
+    result.custom = result.custom || {};
+    result.custom.tokenType = 0;
+    result.custom.isToken = true;
+    result.custom.isNFT = false;
+    result.custom.isCollection = false;
+  }
+}
+__name(enhanceLSP7Metadata, "enhanceLSP7Metadata");
+async function enhanceLSP26FollowerSystem(result, _pluginOptions, _options) {
+  const { functionName, sig, args, input, blockNumber, to, from, value } = result;
+  switch (functionName) {
+  }
+  return void 0;
+}
+__name(enhanceLSP26FollowerSystem, "enhanceLSP26FollowerSystem");
+var enhanceLSP7DigitalAsset_default = enhanceLSP7DigitalAssetPlugin;
+
+// src/decoder/plugins/enhanceLSP8IdentifiableDigitalAsset.ts
+import {
+  lsp8BurnableAbi,
+  lsp8CappedSupplyAbi,
+  lsp8EnumerableAbi,
+  lsp8IdentifiableDigitalAssetAbi,
+  lsp8MintableAbi,
+  lsp8VotesAbi
+} from "@lukso/lsp8-contracts/abi";
+var LSP8 = [
+  ...lsp8IdentifiableDigitalAssetAbi,
+  ...lsp8MintableAbi,
+  ...lsp8BurnableAbi,
+  ...lsp8CappedSupplyAbi,
+  ...lsp8EnumerableAbi,
+  ...lsp8VotesAbi
+];
+var enhanceLSP8IdentifiableDigitalAssetPlugin = standardPlugin(
+  LSP8,
+  {
+    name: "lsp8",
+    abiName: "LSP8IdentifiableDigitalAsset",
+    decoderName: "@lukso/lsp-smart-contracts"
+  },
+  {
+    enhance: /* @__PURE__ */ __name(async (result, pluginOptions, options) => {
+      const setData = await enhanceSetData(result, pluginOptions, options);
+      if (setData) {
+        return setData;
+      }
+      return await enhanceLSP8IdentifiableDigitalAsset(
+        result,
+        pluginOptions,
+        options
+      );
+    }, "enhance"),
+    decodeEvent: /* @__PURE__ */ __name(async (log, options) => {
+      const event = decodeEvent(options.chain, LSP8, log);
+      if (event) {
+        const tokenId = event.args.find(({ name }) => name === "tokenId")?.value;
+        if (tokenId) {
+          event.address = `${event.address}:${tokenId}`;
+        }
+      }
+      return event;
+    }, "decodeEvent")
+  }
+);
+async function enhanceLSP8IdentifiableDigitalAsset(result, pluginOptions, options) {
+  const setData = await enhanceSetData(
+    result,
+    { ...pluginOptions, abiName: "", decoderName: "" },
+    options
+  );
+  if (setData) {
+    return setData;
+  }
+  const { functionName, sig, args, input, blockNumber, to, from, value } = result;
+  switch (functionName) {
+    case "setDataForTokenId": {
+      const [tokenId, _key, _value] = args.map(({ value: value2 }) => value2);
+      return {
+        blockNumber,
+        ...result,
+        __decoder: pluginOptions.decoderName,
+        resultType: "setDataBatch",
+        standard: pluginOptions.abiName,
+        input,
+        children: [
+          {
+            ...result,
+            standard: pluginOptions.abiName,
+            tokenId,
+            to: `${to}:${tokenId}`,
+            from,
+            value,
+            info: await decodeKeyValueRaw(_key, _value, options)
+          }
+        ]
+      };
+    }
+    case "setDataBatchForTokenIds": {
+      const children = [];
+      const [tokenIds, keys, values] = args.map(({ value: value2 }) => value2);
+      for (let i = 0; i < tokenIds.length; i++) {
+        const tokenId = tokenIds[i];
+        const key = keys[i];
+        const _value = values[i];
+        children.push({
+          ...result,
+          resultType: "setData",
+          __decoder: "@lukso/lsp-smart-contracts",
+          standard: key,
+          ...createNamedArgs(
+            [tokenId, key, _value],
+            [
+              { name: "tokenId", type: "bytes32" },
+              { name: "key", type: "bytes32" },
+              { name: "value", type: "bytes" }
+            ]
+          ),
+          tokenId,
+          phase: "enhanced",
+          to: `${to}:${tokenId}`,
+          from,
+          value,
+          info: await decodeKeyValueRaw(key, _value, options)
+        });
+      }
+      return {
+        ...result,
+        __decoder: pluginOptions.decoderName,
+        functionName,
+        sig,
+        input,
+        standard: pluginOptions.abiName,
+        resultType: "setDataBatch",
+        ...args ? { args } : {},
+        to,
+        from,
+        value,
+        children
+      };
+    }
+  }
+  return result;
+}
+__name(enhanceLSP8IdentifiableDigitalAsset, "enhanceLSP8IdentifiableDigitalAsset");
+var enhanceLSP8IdentifiableDigitalAsset_default = enhanceLSP8IdentifiableDigitalAssetPlugin;
+
+// src/decoder/plugins/enhanceLSP9Vault.ts
+import { lsp9VaultAbi as LSP9 } from "@lukso/lsp9-contracts/abi";
+var enhanceLSP9VaultPlugin = standardPlugin(
+  LSP9,
+  {
+    name: "lsp9",
+    abiName: "LSP9Vault",
+    decoderName: "@lukso/lsp-smart-contracts"
+  },
+  {
+    enhance: /* @__PURE__ */ __name(async (result, pluginOptions, options) => {
+      const setData = await enhanceSetData(result, pluginOptions, options);
+      if (setData) {
+        return setData;
+      }
+      return await enhanceLSP9Vault(result, pluginOptions, options);
+    }, "enhance"),
+    decodeEvent: /* @__PURE__ */ __name(async (log, options) => {
+      return decodeEvent(options.chain, LSP9, log);
+    }, "decodeEvent")
+  }
+);
+async function enhanceLSP9Vault(result, pluginOptions, options) {
+  const { functionName, sig, args, input, blockNumber, to, from, value } = result;
+  switch (functionName) {
+  }
+  return void 0;
+}
+__name(enhanceLSP9Vault, "enhanceLSP9Vault");
+var enhanceLSP9Vault_default = enhanceLSP9VaultPlugin;
+
+// src/decoder/plugins/enhanceLSP26FollowerSystem.ts
+import { lsp26FollowerSystemAbi as LSP26 } from "@lukso/lsp26-contracts/abi";
+var enhanceLSP26FollowerSystemPlugin = standardPlugin(
+  LSP26,
+  {
+    name: "lsp26",
+    abiName: "LSP26FollowerSystem",
+    decoderName: "@lukso/lsp-smart-contracts"
+  },
+  {
+    enhance: /* @__PURE__ */ __name(async (result, pluginOptions, options) => {
+      const setData = await enhanceSetData(result, pluginOptions, options);
+      if (setData) {
+        return setData;
+      }
+      return await enhanceLSP26FollowerSystem2(result, pluginOptions, options);
+    }, "enhance"),
+    decodeEvent: /* @__PURE__ */ __name(async (log, options) => {
+      return decodeEvent(options.chain, LSP26, log);
+    }, "decodeEvent")
+  }
+);
+async function enhanceLSP26FollowerSystem2(result, _pluginOptions, _options) {
+  const { functionName, sig, args, input, blockNumber, to, from, value } = result;
+  const { args: _args, ...partialResult } = result;
+  switch (functionName) {
+    case "follow":
+    case "unfollow":
+      return {
+        ...result,
+        children: [
+          {
+            ...partialResult,
+            resultType: "followProfile",
+            phase: "enhanced",
+            address: args[0]?.value
+          }
+        ]
+      };
+      break;
+    case "followBatch":
+    case "unfollowBatch":
+      return {
+        ...result,
+        children: (result.resultType === "execute" ? result.args?.[0]?.value || [] : []).map((address) => ({
+          ...partialResult,
+          phase: "enhanced",
+          resultType: "followProfile",
+          address
+        }))
+      };
+      break;
+  }
+  return void 0;
+}
+__name(enhanceLSP26FollowerSystem2, "enhanceLSP26FollowerSystem");
+var enhanceLSP26FollowerSystem_default = enhanceLSP26FollowerSystemPlugin;
+
+// ../../node_modules/.pnpm/@lukso+lsp-smart-contracts@0.16.7/node_modules/@lukso/lsp-smart-contracts/artifacts/LSP9Vault.json
+var abi2 = [
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "newOwner",
+        type: "address"
+      }
+    ],
+    stateMutability: "payable",
+    type: "constructor"
+  },
+  {
+    inputs: [],
+    name: "ERC725X_ContractDeploymentFailed",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "ERC725X_CreateOperationsRequireEmptyRecipientAddress",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "ERC725X_ExecuteParametersEmptyArray",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "ERC725X_ExecuteParametersLengthMismatch",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "balance",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "value",
+        type: "uint256"
+      }
+    ],
+    name: "ERC725X_InsufficientBalance",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "ERC725X_MsgValueDisallowedInStaticCall",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "ERC725X_NoContractBytecodeProvided",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "operationTypeProvided",
+        type: "uint256"
+      }
+    ],
+    name: "ERC725X_UnknownOperationType",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "ERC725Y_DataKeysValuesLengthMismatch",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "ERC725Y_MsgValueDisallowed",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "caller",
+        type: "address"
+      }
+    ],
+    name: "LSP14CallerNotPendingOwner",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "LSP14CannotTransferOwnershipToSelf",
+    type: "error"
+  },
+  {
+    inputs: [],
+    name: "LSP14MustAcceptOwnershipInSeparateTransaction",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "renounceOwnershipStart",
+        type: "uint256"
+      },
+      {
+        internalType: "uint256",
+        name: "renounceOwnershipEnd",
+        type: "uint256"
+      }
+    ],
+    name: "LSP14NotInRenounceOwnershipInterval",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "dataKey",
+        type: "bytes32"
+      }
+    ],
+    name: "LSP1DelegateNotAllowedToSetDataKey",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes4",
+        name: "functionSelector",
+        type: "bytes4"
+      }
+    ],
+    name: "NoExtensionFoundForFunctionSelector",
+    type: "error"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "callerAddress",
+        type: "address"
+      }
+    ],
+    name: "OwnableCallerNotTheOwner",
+    type: "error"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "uint256",
+        name: "operationType",
+        type: "uint256"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "contractAddress",
+        type: "address"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "value",
+        type: "uint256"
+      },
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "salt",
+        type: "bytes32"
+      }
+    ],
+    name: "ContractCreated",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "dataKey",
+        type: "bytes32"
+      },
+      {
+        indexed: false,
+        internalType: "bytes",
+        name: "dataValue",
+        type: "bytes"
+      }
+    ],
+    name: "DataChanged",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "uint256",
+        name: "operationType",
+        type: "uint256"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "target",
+        type: "address"
+      },
+      {
+        indexed: false,
+        internalType: "uint256",
+        name: "value",
+        type: "uint256"
+      },
+      {
+        indexed: true,
+        internalType: "bytes4",
+        name: "selector",
+        type: "bytes4"
+      }
+    ],
+    name: "Executed",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [],
+    name: "OwnershipRenounced",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "previousOwner",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "newOwner",
+        type: "address"
+      }
+    ],
+    name: "OwnershipTransferStarted",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "previousOwner",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "address",
+        name: "newOwner",
+        type: "address"
+      }
+    ],
+    name: "OwnershipTransferred",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [],
+    name: "RenounceOwnershipStarted",
+    type: "event"
+  },
+  {
+    anonymous: false,
+    inputs: [
+      {
+        indexed: true,
+        internalType: "address",
+        name: "from",
+        type: "address"
+      },
+      {
+        indexed: true,
+        internalType: "uint256",
+        name: "value",
+        type: "uint256"
+      },
+      {
+        indexed: true,
+        internalType: "bytes32",
+        name: "typeId",
+        type: "bytes32"
+      },
+      {
+        indexed: false,
+        internalType: "bytes",
+        name: "receivedData",
+        type: "bytes"
+      },
+      {
+        indexed: false,
+        internalType: "bytes",
+        name: "returnedValue",
+        type: "bytes"
+      }
+    ],
+    name: "UniversalReceiver",
+    type: "event"
+  },
+  {
+    stateMutability: "payable",
+    type: "fallback"
+  },
+  {
+    inputs: [],
+    name: "RENOUNCE_OWNERSHIP_CONFIRMATION_DELAY",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "RENOUNCE_OWNERSHIP_CONFIRMATION_PERIOD",
+    outputs: [
+      {
+        internalType: "uint256",
+        name: "",
+        type: "uint256"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "VERSION",
+    outputs: [
+      {
+        internalType: "string",
+        name: "",
+        type: "string"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "acceptOwnership",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes[]",
+        name: "data",
+        type: "bytes[]"
+      }
+    ],
+    name: "batchCalls",
+    outputs: [
+      {
+        internalType: "bytes[]",
+        name: "results",
+        type: "bytes[]"
+      }
+    ],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256",
+        name: "operationType",
+        type: "uint256"
+      },
+      {
+        internalType: "address",
+        name: "target",
+        type: "address"
+      },
+      {
+        internalType: "uint256",
+        name: "value",
+        type: "uint256"
+      },
+      {
+        internalType: "bytes",
+        name: "data",
+        type: "bytes"
+      }
+    ],
+    name: "execute",
+    outputs: [
+      {
+        internalType: "bytes",
+        name: "",
+        type: "bytes"
+      }
+    ],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "uint256[]",
+        name: "operationsType",
+        type: "uint256[]"
+      },
+      {
+        internalType: "address[]",
+        name: "targets",
+        type: "address[]"
+      },
+      {
+        internalType: "uint256[]",
+        name: "values",
+        type: "uint256[]"
+      },
+      {
+        internalType: "bytes[]",
+        name: "datas",
+        type: "bytes[]"
+      }
+    ],
+    name: "executeBatch",
+    outputs: [
+      {
+        internalType: "bytes[]",
+        name: "",
+        type: "bytes[]"
+      }
+    ],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "dataKey",
+        type: "bytes32"
+      }
+    ],
+    name: "getData",
+    outputs: [
+      {
+        internalType: "bytes",
+        name: "dataValue",
+        type: "bytes"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32[]",
+        name: "dataKeys",
+        type: "bytes32[]"
+      }
+    ],
+    name: "getDataBatch",
+    outputs: [
+      {
+        internalType: "bytes[]",
+        name: "dataValues",
+        type: "bytes[]"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "owner",
+    outputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "pendingOwner",
+    outputs: [
+      {
+        internalType: "address",
+        name: "",
+        type: "address"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [],
+    name: "renounceOwnership",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "dataKey",
+        type: "bytes32"
+      },
+      {
+        internalType: "bytes",
+        name: "dataValue",
+        type: "bytes"
+      }
+    ],
+    name: "setData",
+    outputs: [],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32[]",
+        name: "dataKeys",
+        type: "bytes32[]"
+      },
+      {
+        internalType: "bytes[]",
+        name: "dataValues",
+        type: "bytes[]"
+      }
+    ],
+    name: "setDataBatch",
+    outputs: [],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes4",
+        name: "interfaceId",
+        type: "bytes4"
+      }
+    ],
+    name: "supportsInterface",
+    outputs: [
+      {
+        internalType: "bool",
+        name: "",
+        type: "bool"
+      }
+    ],
+    stateMutability: "view",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "address",
+        name: "newOwner",
+        type: "address"
+      }
+    ],
+    name: "transferOwnership",
+    outputs: [],
+    stateMutability: "nonpayable",
+    type: "function"
+  },
+  {
+    inputs: [
+      {
+        internalType: "bytes32",
+        name: "typeId",
+        type: "bytes32"
+      },
+      {
+        internalType: "bytes",
+        name: "receivedData",
+        type: "bytes"
+      }
+    ],
+    name: "universalReceiver",
+    outputs: [
+      {
+        internalType: "bytes",
+        name: "returnedValues",
+        type: "bytes"
+      }
+    ],
+    stateMutability: "payable",
+    type: "function"
+  },
+  {
+    stateMutability: "payable",
+    type: "receive"
+  }
+];
+
+// src/decoder/functionSignature.ts
+import {
+  decodeAbiParameters as decodeAbiParameters3,
+  encodeAbiParameters,
+  getAddress,
+  isAddress as isAddress2,
+  isAddressEqual as isAddressEqual2,
+  parseAbiParameters,
+  zeroAddress as zeroAddress2
+} from "viem";
+
+// src/decoder/lruCache.ts
+import { LRUCache as LRUCache2 } from "lru-cache";
+var LRUDecoderCache = class {
+  static {
+    __name(this, "LRUDecoderCache");
+  }
+  cache;
+  promises;
+  defaultTTL;
+  defaultErrorTTL;
+  defaultStaleWhileRevalidate;
+  constructor(options = {}) {
+    this.defaultTTL = options.ttl ?? 5 * 60 * 1e3;
+    this.defaultErrorTTL = options.errorTTL ?? 30 * 1e3;
+    this.defaultStaleWhileRevalidate = options.staleWhileRevalidate;
+    this.cache = new LRUCache2({
+      max: options.max ?? 1e3
+    });
+    this.promises = /* @__PURE__ */ new Map();
+  }
+  async get(key) {
+    const entry = this.cache.get(key);
+    if (!entry) {
+      return void 0;
+    }
+    if (entry.expires && Date.now() > entry.expires) {
+      this.cache.delete(key);
+      return void 0;
+    }
+    return entry;
+  }
+  async set(key, value, options) {
+    const now = Date.now();
+    const ttl = options?.ttl ?? (options?.errorTTL ? options.errorTTL : this.defaultTTL);
+    const isError = options?.errorTTL !== void 0;
+    const entry = {
+      value,
+      expires: now + ttl,
+      isError
+    };
+    const staleWhileRevalidate = options?.staleWhileRevalidate ?? this.defaultStaleWhileRevalidate;
+    if (staleWhileRevalidate) {
+      entry.stale = now + ttl + staleWhileRevalidate;
+    }
+    this.cache.set(key, entry);
+  }
+  async delete(key) {
+    this.cache.delete(key);
+  }
+  async getMany(keys) {
+    const result = /* @__PURE__ */ new Map();
+    for (const key of keys) {
+      const entry = await this.get(key);
+      if (entry) {
+        result.set(key, entry);
+      }
+    }
+    return result;
+  }
+  async setMany(entries) {
+    for (const { key, value, options } of entries) {
+      await this.set(key, value, options);
+    }
+  }
+  async clear() {
+    this.cache.clear();
+    this.promises.clear();
+  }
+  async getOrSet(key, factory, options) {
+    const cached = await this.get(key);
+    const now = Date.now();
+    if (cached && (!cached.expires || now < cached.expires)) {
+      return cached.value;
+    }
+    if (cached && cached.stale && now < cached.stale && !this.promises.has(key)) {
+      const backgroundPromise = factory(options?.signal).then(async (fresh) => {
+        await this.set(key, fresh, options);
+        return fresh;
+      }).catch(() => {
+        return cached.value;
+      }).finally(() => {
+        this.promises.delete(key);
+      });
+      this.promises.set(key, backgroundPromise);
+      return cached.value;
+    }
+    const existingPromise = this.promises.get(key);
+    if (existingPromise) {
+      return existingPromise;
+    }
+    const promise = factory(options?.signal).then(async (value) => {
+      await this.set(key, value, options);
+      return value;
+    }).catch(async (error) => {
+      await this.set(key, error, {
+        ...options,
+        ttl: options?.errorTTL ?? this.defaultErrorTTL,
+        errorTTL: options?.errorTTL ?? this.defaultErrorTTL
+      });
+      throw error;
+    }).finally(() => {
+      this.promises.delete(key);
+    });
+    this.promises.set(key, promise);
+    return promise;
+  }
+};
+function createLRUCache(options) {
+  return new LRUDecoderCache(options);
+}
+__name(createLRUCache, "createLRUCache");
+
+// src/decoder/functionSignature.ts
+var defaultCache = createLRUCache({
+  max: 500,
+  ttl: 60 * 1e3,
+  // 1 minute
+  errorTTL: 30 * 1e3
+  // 30 seconds
+});
+function generateNamedAbiParameters(signature) {
+  const start = signature.indexOf("(");
+  const end = signature.lastIndexOf(")");
+  if (start === -1 || end === -1 || end <= start) {
+    throw new Error(`Invalid signature: ${signature}`);
+  }
+  const paramString = signature.slice(start + 1, end);
+  const rawParams = parseAbiParameters(paramString);
+  const assignNames = /* @__PURE__ */ __name((params, prefix) => {
+    return params.map((param, index) => {
+      const name = `${prefix}${index + 1}`;
+      if (param.type === "tuple" && "components" in param) {
+        const components = assignNames(
+          param.components,
+          `${name}_`
+        );
+        return { ...param, name, components };
+      }
+      return { ...param, name };
+    });
+  }, "assignNames");
+  return assignNames(rawParams, "arg");
+}
+__name(generateNamedAbiParameters, "generateNamedAbiParameters");
+async function fetchAbi(chain, address, options) {
+  const explorer = chain.blockExplorers?.default?.apiUrl;
+  if (!explorer) return void 0;
+  const cache = options?.cache ?? defaultCache;
+  let key = getAddress(address);
+  const cacheKey = makeCacheKey("abi" /* ABI */, key, String(chain.id));
+  return cache.getOrSet(
+    cacheKey,
+    async (signal) => {
+      let isProxy = false;
+      let decoderVerifiedContract = false;
+      let factoryName;
+      const originalKey = key;
+      const addressUrl = new URL(`/api/v2/addresses/${key}`, explorer);
+      const addressRes = await fetch(addressUrl, { signal });
+      if (addressRes.ok) {
+        const data = await addressRes.json();
+        const {
+          implementations: [
+            { address: _address, address_hash: _addressHash } = {}
+          ] = [],
+          is_contract,
+          is_verified: __decoderVerifiedContract,
+          proxy_type,
+          name: __factoryName
+        } = data;
+        const address2 = _address || _addressHash;
+        factoryName = __factoryName;
+        decoderVerifiedContract = Boolean(__decoderVerifiedContract || false);
+        if (address2 && is_contract && proxy_type !== "null" && proxy_type != null) {
+          key = address2;
+          isProxy = true;
+        }
+      }
+      if (!decoderVerifiedContract) {
+        return void 0;
+      }
+      const url = new URL(`/api/v2/smart-contracts/${key}`, explorer);
+      const res = await fetch(url, { signal });
+      if (!res.ok) {
+        return void 0;
+      }
+      const result = await res.json();
+      const {
+        name = factoryName || "UnknownName",
+        abi: abi3,
+        is_verified
+      } = result || {};
+      if (abi3 && is_verified) {
+        return {
+          abi: abi3,
+          __decoderVerifiedContract: decoderVerifiedContract,
+          // If we have an ABI, treat it as verified
+          __decoderIsProxy: isProxy,
+          name,
+          explorer
+        };
+      }
+      return void 0;
+    },
+    { signal: options?.signal }
+  );
+}
+__name(fetchAbi, "fetchAbi");
+var getFunctionSignature = /* @__PURE__ */ __name(async (chain, input, to, preferError = false, options) => {
+  if (to && isAddress2(to) && isAddressEqual2(to, zeroAddress2)) {
+    return {
+      __decoder: "none",
+      standard: "unknown",
+      to,
+      input,
+      resultType: "raw"
+    };
+  }
+  const data = input?.slice(2);
+  const selector = data.slice(0, 8);
+  if (selector) {
+    if (to) {
+      const info = await fetchAbi(chain, to, options);
+      if (info) {
+        const decoded = customDecodeFunctionData({
+          abi: info.abi,
+          data: input || "0x"
+        });
+        if (decoded) {
+          return {
+            ...decoded,
+            __decoder: info.explorer,
+            __decoderVerifiedContract: info.__decoderVerifiedContract,
+            __decoderIsProxy: info.__decoderIsProxy,
+            standard: info.name
+          };
+        }
+      }
+    }
+    const cache = options?.cache ?? defaultCache;
+    const cacheKey = makeCacheKey("sig" /* FUNCTION_SIGNATURE */, selector);
+    const signatureEntry = cache.getOrSet(
+      cacheKey,
+      async (signal) => {
+        const url = `${OPENCHAIN_DICTIONARY_URL}?function=0x${selector}`;
+        let __decoder = new URL(OPENCHAIN_DICTIONARY_URL).hostname;
+        try {
+          const res = await fetch(url, { signal });
+          if (res.ok) {
+            const result = await res.json();
+            if (result) {
+              result.__decoder = __decoder;
+              return result;
+            }
+          }
+        } catch {
+        }
+        __decoder = new URL(FUNCTION_DICTIONARY_URL).hostname;
+        const fallbackRes = await fetch(
+          `${FUNCTION_DICTIONARY_URL}/${selector}`,
+          { signal }
+        );
+        if (!fallbackRes.ok) {
+          return void 0;
+        }
+        const fallbackResult = await fallbackRes.json();
+        if (fallbackResult) {
+          fallbackResult.__decoder = __decoder;
+        }
+        return fallbackResult;
+      },
+      { signal: options?.signal }
+    );
+    const methods = await signatureEntry;
+    if (methods?.results?.length > 0) {
+      let search = methods.results.reverse();
+      if (preferError) {
+        const withError = search.filter(
+          (result) => /Error/.test(result.text_signature)
+        );
+        const withoutError = search.filter(
+          (result) => !/Error/.test(result.text_signature)
+        );
+        search = [...withError, ...withoutError];
+      }
+      for (const result of search) {
+        try {
+          const params = generateNamedAbiParameters(
+            result.text_signature || result.name
+          );
+          const args = decodeAbiParameters3(params, `0x${data.slice(8)}`);
+          const encodeArgs = Array.from({ length: params.length }).map(
+            (_val, index) => {
+              if (params[index].type === "bool") {
+                const val = args[`${index}`];
+                if (val !== 1 && val !== 0 && val !== true && val !== false) {
+                  throw new Error("Invalid boolean value");
+                }
+              }
+              if (params[index].type === "address") {
+                const val = args[`${index}`];
+                if (!isAddress2(val)) {
+                  throw new Error(`Invalid address value ${val}`);
+                }
+              }
+              return args[`${index}`] ?? "0x";
+            }
+          );
+          const newData = encodeAbiParameters(
+            params,
+            encodeArgs
+          ).slice(2);
+          if (data.slice(8) === newData) {
+            return {
+              resultType: "execute",
+              standard: "unknown",
+              sig: `0x${selector}`,
+              functionName: result.text_signature.replace(/\(.*$/, ""),
+              ...args ? {
+                ...createNamedArgs(encodeArgs, params)
+              } : {},
+              __decoder: methods.__decoder || FUNCTION_DICTIONARY_URL
+            };
+          }
+        } catch (error) {
+        }
+      }
+    }
+  }
+  return void 0;
+}, "getFunctionSignature");
+
+// src/decoder/plugins/enhanceRetrieveAbi.ts
+var enhanceRetrieveAbiPlugin = standardPlugin(
+  abi2,
+  {
+    abiName: "Internal",
+    decoderName: "explorer",
+    name: "abiRetrieve",
+    usesAsync: true,
+    priority: 0
+  },
+  {
+    enhance: /* @__PURE__ */ __name(async () => {
+      return void 0;
+    }, "enhance"),
+    overrideEnhance: enhanceRetrieveAbi,
+    decodeEvent: /* @__PURE__ */ __name(async (log, options) => {
+      if (!log) {
+        return void 0;
+      }
+      const info = await fetchAbi(options.chain, log.address);
+      if (info) {
+        const result = decodeEvent(options.chain, info.abi, log);
+        if (result) {
+          return { ...result, __decoder: info.explorer };
+        }
+      }
+      return void 0;
+    }, "decodeEvent")
+  }
+);
+async function enhanceRetrieveAbi(result, _pluginOptions, options) {
+  const { functionName, sig, args, input, blockNumber, to, from, value } = result;
+  try {
+    const decoded = await getFunctionSignature(
+      options.chain,
+      input,
+      to || void 0,
+      options.preferError
+    );
+    if (decoded) {
+      return {
+        ...result,
+        ...decoded,
+        resultType: "execute",
+        to,
+        from,
+        value,
+        input
+      };
+    }
+  } catch {
+  }
+  return void 0;
+}
+__name(enhanceRetrieveAbi, "enhanceRetrieveAbi");
+var enhanceRetrieveAbi_default = enhanceRetrieveAbiPlugin;
+
+// src/decoder/plugins/index.ts
+[enhanceLSP0ERC725Account_default, enhanceLSP6KeyManager_default, enhanceLSP7DigitalAsset_default, enhanceLSP8IdentifiableDigitalAsset_default, enhanceLSP9Vault_default, enhanceLSP26FollowerSystem_default, enhanceBurntPix_default].forEach((p) => p);
+var defaultPlugins = Object.freeze([
+  enhanceGraffiti_default,
+  enhanceLSP6KeyManager_default,
+  enhanceLSP0ERC725Account_default,
+  enhanceLSP7DigitalAsset_default,
+  enhanceLSP8IdentifiableDigitalAsset_default,
+  enhanceLSP9Vault_default,
+  enhanceLSP26FollowerSystem_default,
+  enhanceRetrieveAbi_default,
+  enhanceBurntPix_default
+]);
+var defaultSchemaPlugins = Object.freeze([
+  schemaDefault_default
+]);
+async function decodeKeyValue(result, options) {
+  const key = getArgByName(result.args, "key") ?? "0x";
+  const value = getArgByName(result.args, "value") ?? "0x";
+  return await decodeKeyValueRaw(key, value, options);
+}
+__name(decodeKeyValue, "decodeKeyValue");
+async function decodeKeyValueRaw(key, value, options) {
+  for (const schemaPlugin of options.schemaPlugins) {
+    try {
+      const output = await schemaPlugin(key, value);
+      if (output) {
+        return output;
+      }
+    } catch {
+    }
+  }
+  return void 0;
+}
+__name(decodeKeyValueRaw, "decodeKeyValueRaw");
+pluginRegistry.register("graffiti", enhanceGraffiti_default, {
+  priority: 100,
+  required: false
+});
+pluginRegistry.register("abiRetrieve", enhanceRetrieveAbi_default, {
+  priority: 1,
+  required: false,
+  usesAsync: true
+});
+pluginRegistry.registerSchema("default-schema", schemaDefault_default, {
+  priority: 100,
+  required: false
+});
+
+export {
+  __name,
+  customDecodeFunctionData,
+  createNamedArgs,
+  getArgByName,
+  extractAddress,
+  getPublicClient,
+  isAsyncOperationEnabled,
+  needsEnhancement,
+  collectDataKeys,
+  pluginRegistry,
+  registerPlugin,
+  registerSchemaPlugin,
+  createNamedSchemaPlugin,
+  createNamedPlugin,
+  decodeTransaction,
+  IPFS_GATEWAY,
+  defaultSchema,
+  createAggregationKey,
+  standardPlugin,
+  standardSchemaPlugin,
+  createDebug,
+  standardAggregation,
+  PluginAggregationEngine,
+  decodeEvent,
+  defaultPlugins,
+  defaultSchemaPlugins,
+  decodeKeyValue,
+  decodeKeyValueRaw
+};
+//# sourceMappingURL=chunk-XVHJWV5U.js.map