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

package/dist/chunk-LJ6ES5XF.js

@@ -0,0 +1,776 @@
+import {
+  consumerModel,
+  decodeTransaction
+} from "./chunk-GXZOF3QY.js";
+import {
+  fetchMultipleAddresses
+} from "./chunk-GGBHTWJL.js";
+import {
+  __name,
+  collectDataKeys,
+  defaultPlugins,
+  defaultSchemaPlugins
+} from "./chunk-XVHJWV5U.js";
+
+// src/shared/cache.ts
+function isPromise(value) {
+  return value instanceof Promise;
+}
+__name(isPromise, "isPromise");
+function getDataKeyCacheKey(key) {
+  return key.toLowerCase();
+}
+__name(getDataKeyCacheKey, "getDataKeyCacheKey");
+function dataKeyToString(dataKey) {
+  return dataKey;
+}
+__name(dataKeyToString, "dataKeyToString");
+function parseDataKey(str) {
+  return str;
+}
+__name(parseDataKey, "parseDataKey");
+function createMemoryAddressIdentityCache(ttlMs = 1e3 * 60 * 5) {
+  const cache = /* @__PURE__ */ new Map();
+  return {
+    get(key) {
+      const cacheKey = getDataKeyCacheKey(key);
+      const entry = cache.get(cacheKey);
+      if (!entry) return void 0;
+      if (Date.now() > entry.expires) {
+        cache.delete(cacheKey);
+        return void 0;
+      }
+      return entry.data;
+    },
+    set(key, value) {
+      const cacheKey = getDataKeyCacheKey(key);
+      cache.set(cacheKey, {
+        data: value,
+        expires: Date.now() + ttlMs
+      });
+    },
+    has(key) {
+      const cacheKey = getDataKeyCacheKey(key);
+      const entry = cache.get(cacheKey);
+      if (!entry) return false;
+      if (Date.now() > entry.expires) {
+        cache.delete(cacheKey);
+        return false;
+      }
+      return true;
+    },
+    getMany(keys) {
+      const results = /* @__PURE__ */ new Map();
+      for (const key of keys) {
+        const data = this.get(key);
+        if (data && !isPromise(data)) {
+          results.set(key, data);
+        }
+      }
+      return results;
+    },
+    setMany(entries) {
+      for (const [key, value] of entries) {
+        this.set(key, value);
+      }
+    },
+    clear() {
+      cache.clear();
+    }
+  };
+}
+__name(createMemoryAddressIdentityCache, "createMemoryAddressIdentityCache");
+
+// src/client/resolveAddresses.ts
+async function resolveAddresses(addresses, chain, options = {}) {
+  const {
+    endpoint = "/api/resolveAddresses",
+    cache,
+    batchSize = 100,
+    timeout = 1e4
+  } = options;
+  const results = /* @__PURE__ */ new Map();
+  if (addresses.length === 0) {
+    return results;
+  }
+  const uncachedAddresses = [];
+  if (cache) {
+    for (const addr of addresses) {
+      const cached = await cache.get(addr);
+      if (cached) {
+        results.set(addr, cached);
+      } else {
+        uncachedAddresses.push(addr);
+      }
+    }
+    if (uncachedAddresses.length === 0) {
+      return results;
+    }
+  } else {
+    uncachedAddresses.push(...addresses);
+  }
+  const batches = [];
+  for (let i = 0; i < uncachedAddresses.length; i += batchSize) {
+    batches.push(uncachedAddresses.slice(i, i + batchSize));
+  }
+  const batchPromises = batches.map(async (batch) => {
+    try {
+      const apiAddresses = batch;
+      const controller = new AbortController();
+      const timeoutId = setTimeout(() => controller.abort(), timeout);
+      const response = await fetch(endpoint, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/json"
+        },
+        body: JSON.stringify({
+          chainId: chain.id,
+          addresses: apiAddresses
+        }),
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (!response.ok) {
+        console.error(
+          `Address resolution failed: ${response.status} ${response.statusText}`
+        );
+        return;
+      }
+      const data = await response.json();
+      if (data.success && data.addresses) {
+        for (const [cacheKey, enhancedInfo] of Object.entries(data.addresses)) {
+          const matchingKey = batch.find(
+            (key) => getDataKeyCacheKey(key) === cacheKey
+          );
+          if (matchingKey) {
+            results.set(matchingKey, enhancedInfo);
+            if (cache) {
+              await cache.set(matchingKey, enhancedInfo);
+            }
+          }
+        }
+      }
+    } catch (error) {
+      console.error("Failed to resolve addresses batch:", error);
+    }
+  });
+  await Promise.all(batchPromises);
+  return results;
+}
+__name(resolveAddresses, "resolveAddresses");
+function createApiAddressResolver(chain, options = {}) {
+  return async (addresses) => {
+    return resolveAddresses(addresses, chain, options);
+  };
+}
+__name(createApiAddressResolver, "createApiAddressResolver");
+
+// src/core/addressResolver.ts
+var AddressResolver = class {
+  static {
+    __name(this, "AddressResolver");
+  }
+  dataModel;
+  graphqlEndpoint;
+  batchSize;
+  batchDelay;
+  pendingAddresses = /* @__PURE__ */ new Set();
+  batchTimer;
+  cache;
+  constructor(config) {
+    this.dataModel = config.dataModel;
+    this.graphqlEndpoint = config.graphqlEndpoint;
+    this.batchSize = config.batchSize || 50;
+    this.batchDelay = config.batchDelay || 100;
+    this.cache = config.cache;
+  }
+  /**
+   * Start watching for missing addresses
+   */
+  startWatching() {
+    setInterval(() => {
+      const missing = this.dataModel.getMissingKeys();
+      if (missing.length > 0) {
+        this.queueAddresses(missing);
+      }
+    }, 1e3);
+  }
+  /**
+   * Queue addresses for batch resolution
+   */
+  queueAddresses(addresses) {
+    for (const addr of addresses) {
+      this.pendingAddresses.add(addr);
+    }
+    if (this.batchTimer) {
+      clearTimeout(this.batchTimer);
+    }
+    this.batchTimer = setTimeout(() => {
+      this.processBatch();
+    }, this.batchDelay);
+    if (this.pendingAddresses.size >= this.batchSize) {
+      clearTimeout(this.batchTimer);
+      this.processBatch();
+    }
+  }
+  /**
+   * Process a batch of addresses
+   */
+  async processBatch() {
+    const batch = Array.from(this.pendingAddresses).slice(0, this.batchSize);
+    if (batch.length === 0) return;
+    for (const key of batch) {
+      this.pendingAddresses.delete(key);
+    }
+    const dataKeys = batch.map((key) => {
+      return key;
+    });
+    try {
+      const results = await fetchMultipleAddresses(
+        dataKeys,
+        this.graphqlEndpoint,
+        this.cache
+      );
+      const enhancedData = Array.from(results.values());
+      if (enhancedData.length > 0) {
+        this.dataModel.injectData(enhancedData);
+      }
+    } catch (error) {
+      console.error("Failed to resolve addresses:", error);
+      for (const key of dataKeys) {
+        this.dataModel.setError(key, "Failed to fetch address data");
+      }
+    }
+    if (this.pendingAddresses.size > 0) {
+      this.batchTimer = setTimeout(() => {
+        this.processBatch();
+      }, this.batchDelay);
+    }
+  }
+  /**
+   * Stop watching for addresses
+   */
+  stopWatching() {
+    if (this.batchTimer) {
+      clearTimeout(this.batchTimer);
+    }
+  }
+};
+
+// src/core/integrateDecoder.ts
+import { effect } from "@preact/signals-core";
+import { lukso } from "viem/chains";
+var DecoderIntegration = class {
+  static {
+    __name(this, "DecoderIntegration");
+  }
+  dataModel;
+  decoderOptions;
+  addressCache;
+  constructor(config) {
+    this.dataModel = config.dataModel;
+    this.addressCache = config.addressCache;
+    this.decoderOptions = {
+      plugins: defaultPlugins,
+      schemaPlugins: defaultSchemaPlugins,
+      wrappers: [],
+      chain: config.decoderOptions?.chain || lukso,
+      ...config.decoderOptions
+    };
+  }
+  /**
+   * Add and decode a transaction
+   * @param transaction - Raw transaction data
+   * @returns Transaction signal that updates as decoding progresses
+   */
+  async addAndDecodeTransaction(transaction) {
+    const signal = this.dataModel.addTransactions(transaction);
+    const transactionOptions = {
+      ...this.decoderOptions,
+      wrappers: []
+      // Fresh array for collecting wrappers in this decode hierarchy
+    };
+    const { signal: decodingSignal } = await decodeTransaction(
+      transaction,
+      transactionOptions
+    );
+    effect(() => {
+      const state = decodingSignal.value;
+      if (state.data) {
+        const decodedResult = state.data;
+        if (transactionOptions.wrappers.length > 0) {
+          if ("wrappers" in decodedResult && typeof decodedResult === "object") {
+            ;
+            decodedResult.wrappers = transactionOptions.wrappers;
+          }
+          for (const wrapper of transactionOptions.wrappers) {
+            this.updateAddressesFromDecoded(wrapper);
+          }
+        }
+        const processedResult = this.flattenBatchTransactions(decodedResult);
+        if (transaction.hash) {
+          this.dataModel.updateTransactionData(
+            transaction.hash,
+            processedResult,
+            0
+            // decoder index
+          );
+        }
+        this.updateAddressesFromDecoded(processedResult);
+      }
+    });
+    return signal;
+  }
+  /**
+   * Add and decode multiple transactions
+   * @param transactions - Array of raw transactions
+   * @returns Array of transaction signals
+   */
+  async addAndDecodeTransactions(transactions) {
+    const signals = this.dataModel.addTransactions(transactions);
+    const decodingPromises = transactions.map(async (tx, index) => {
+      const transactionOptions = {
+        ...this.decoderOptions,
+        wrappers: []
+        // Fresh array for collecting wrappers in this decode hierarchy
+      };
+      const { signal: decodingSignal } = await decodeTransaction(
+        tx,
+        transactionOptions
+      );
+      effect(() => {
+        const state = decodingSignal.value;
+        if (state.data) {
+          const decodedResult = state.data;
+          if (transactionOptions.wrappers.length > 0) {
+            if ("wrappers" in decodedResult && typeof decodedResult === "object") {
+              ;
+              decodedResult.wrappers = transactionOptions.wrappers;
+            }
+            for (const wrapper of transactionOptions.wrappers) {
+              this.updateAddressesFromDecoded(wrapper);
+            }
+          }
+          const processedResult = this.flattenBatchTransactions(decodedResult);
+          if (tx.hash) {
+            this.dataModel.updateTransactionData(
+              tx.hash,
+              processedResult,
+              0
+              // decoder index
+            );
+          }
+          this.updateAddressesFromDecoded(processedResult);
+        }
+      });
+      return decodingSignal;
+    });
+    await Promise.all(decodingPromises);
+    return signals;
+  }
+  /**
+   * Extract and register addresses from decoded transaction data
+   */
+  async updateAddressesFromDecoded(decodedData) {
+    const addresses = collectDataKeys(decodedData);
+    for (const address of addresses) {
+      if (this.addressCache) {
+        const cached = await this.addressCache.get(address);
+        if (cached) {
+          this.dataModel.updateData(cached);
+        }
+      }
+      this.dataModel.getAddress(address);
+    }
+  }
+  /**
+   * Flatten nested batch transactions
+   * If a batch contains another batch as a child, flatten all sub-transactions into the parent's children
+   *
+   * Structure:
+   * - Wrappers: The "invisible" execute functions (execute, executeRelayCall, etc.) that wrap the actual transaction
+   * - Children: The actual transactions being executed
+   *
+   * Result:
+   * - Single transaction: { resultType: 'execute', wrappers: [...] }
+   * - Batch transaction: { resultType: 'executeBatch', children: [flat list], wrappers: [...] }
+   *
+   * This ensures only ONE level of batch with all transactions flattened
+   */
+  flattenBatchTransactions(result) {
+    if (result.resultType !== "executeBatch" && result.resultType !== "setDataBatch") {
+      return result;
+    }
+    if (!("children" in result) || !Array.isArray(result.children)) {
+      return result;
+    }
+    const flattenedChildren = [];
+    for (const child of result.children) {
+      if (typeof child === "object" && child && "resultType" in child) {
+        const childResult = child;
+        if (childResult.resultType === "executeBatch" || childResult.resultType === "setDataBatch") {
+          if ("children" in childResult && Array.isArray(childResult.children)) {
+            flattenedChildren.push(...childResult.children);
+          }
+        } else {
+          flattenedChildren.push(child);
+        }
+      }
+    }
+    return {
+      ...result,
+      children: flattenedChildren
+    };
+  }
+  /**
+   * Load missing address data
+   * This would be called by an external service that fetches address data
+   */
+  async loadAddressData(addressData) {
+    this.dataModel.injectData(addressData);
+    if (this.addressCache) {
+      await Promise.all(
+        addressData.map((data) => {
+          const key = data.tokenId ? `${data.address}:${data.tokenId}` : data.address;
+          return this.addressCache?.set(key, data) ?? Promise.resolve();
+        })
+      );
+    }
+  }
+  /**
+   * Get addresses that need to be fetched
+   */
+  getMissingAddresses() {
+    return this.dataModel.getMissingKeys();
+  }
+  /**
+   * Get addresses currently being loaded
+   */
+  getLoadingAddresses() {
+    return this.dataModel.getLoadingKeys();
+  }
+};
+function createMemoryAddressCache() {
+  const cache = /* @__PURE__ */ new Map();
+  return {
+    async get(key) {
+      return cache.get(key);
+    },
+    async set(key, value) {
+      cache.set(key, value);
+    },
+    async has(key) {
+      return cache.has(key);
+    },
+    async delete(key) {
+      cache.delete(key);
+    },
+    async clear() {
+      cache.clear();
+    }
+  };
+}
+__name(createMemoryAddressCache, "createMemoryAddressCache");
+
+// src/server/lsp23Resolver.ts
+import {
+  bytesToHex,
+  decodeAbiParameters,
+  isHex,
+  parseAbiParameters
+} from "viem";
+var LSP23_FACTORY_ADDRESS = "0x2300000a84d25df63081feaa37ba6b62c4c89a30";
+var DEPLOY_ERC1167_PROXIES_SELECTOR = "0x6a66a753";
+function decodeDeploymentCalldata(input) {
+  try {
+    const params = `0x${input.slice(10)}`;
+    const decoded = decodeAbiParameters(
+      parseAbiParameters(
+        "(bytes32,uint256,address,bytes), (uint256,address,bytes,bool,bytes), address, bytes"
+      ),
+      params
+    );
+    const [
+      primaryDeployment,
+      secondaryDeployment,
+      postDeploymentModule,
+      postDeploymentModuleCalldata
+    ] = decoded;
+    const [salt, , primaryImplementation] = primaryDeployment;
+    const [, secondaryImplementation] = secondaryDeployment;
+    if (!primaryImplementation || !secondaryImplementation) {
+      return null;
+    }
+    return {
+      salt,
+      primaryImplementation,
+      secondaryImplementation,
+      postDeploymentModule,
+      initializationCalldata: postDeploymentModuleCalldata
+    };
+  } catch (error) {
+    console.error("Failed to decode LSP23 deployment calldata:", error);
+    return null;
+  }
+}
+__name(decodeDeploymentCalldata, "decodeDeploymentCalldata");
+function decodeDeploymentOutput(output) {
+  try {
+    const decoded = decodeAbiParameters(
+      parseAbiParameters("address, address"),
+      output
+    );
+    return {
+      profileAddress: decoded[0],
+      urdAddress: decoded[1]
+    };
+  } catch (error) {
+    console.error("Failed to decode LSP23 deployment output:", error);
+    return null;
+  }
+}
+__name(decodeDeploymentOutput, "decodeDeploymentOutput");
+function extractControllersFromInitCalldata(initializationCalldata) {
+  try {
+    if (!initializationCalldata || initializationCalldata === "0x") {
+      return [];
+    }
+    const decoded = decodeAbiParameters(
+      parseAbiParameters("bytes32[], bytes[]"),
+      initializationCalldata
+    );
+    const [dataKeys, dataValues] = decoded;
+    const controllers = [];
+    const ADDRESS_PERMISSIONS_ARRAY_PREFIX = "0xdf30dba06db6a30e65354d9a64c60986";
+    for (let i = 0; i < dataKeys.length; i++) {
+      const keyStr = dataKeys[i].toLowerCase();
+      if (keyStr.startsWith(ADDRESS_PERMISSIONS_ARRAY_PREFIX)) {
+        const value = dataValues[i];
+        const valueHex = isHex(value) ? value : bytesToHex(value);
+        if (valueHex.length === 42) {
+          const addr = valueHex;
+          if (addr !== "0x0000000000000000000000000000000000000000" && !controllers.some((c) => c.toLowerCase() === addr.toLowerCase())) {
+            controllers.push(addr);
+          }
+        }
+      }
+    }
+    return controllers;
+  } catch (error) {
+    console.error("Failed to extract controllers from init calldata:", error);
+    return [];
+  }
+}
+__name(extractControllersFromInitCalldata, "extractControllersFromInitCalldata");
+function buildLSP23DeploymentQuery(config) {
+  const {
+    controllerAddresses,
+    profileAddresses,
+    fromBlock = 0,
+    toBlock,
+    chainId
+  } = config;
+  if (profileAddresses && profileAddresses.length > 0) {
+    return {
+      from_block: fromBlock,
+      to_block: toBlock,
+      // Query CREATE2 traces where the created address is one of our profiles
+      traces: [
+        {
+          type: ["create2"],
+          to: profileAddresses.map((addr) => addr.toLowerCase())
+        }
+      ],
+      // Also get the transactions to verify they're to the LSP23 factory
+      transactions: [
+        {
+          to: [LSP23_FACTORY_ADDRESS.toLowerCase()]
+        }
+      ],
+      field_selection: {
+        transaction: ["hash", "from", "to", "input", "output", "block_number"],
+        trace: ["transaction_hash", "type", "from", "to"],
+        block: ["number", "timestamp"]
+      },
+      include_all_blocks: false
+    };
+  }
+  if (controllerAddresses && controllerAddresses.length > 0) {
+    return {
+      from_block: fromBlock,
+      to_block: toBlock,
+      // Query transactions to the LSP23 factory from our controllers
+      transactions: [
+        {
+          from: controllerAddresses.map((addr) => addr.toLowerCase()),
+          to: [LSP23_FACTORY_ADDRESS.toLowerCase()]
+        }
+      ],
+      // Also get traces to see the CREATE2 operations
+      traces: [
+        {
+          type: ["create2"]
+          // No filter on 'to' - we'll match by transaction hash
+        }
+      ],
+      field_selection: {
+        transaction: ["hash", "from", "to", "input", "output", "block_number"],
+        trace: ["transaction_hash", "type", "from", "to"],
+        block: ["number", "timestamp"]
+      },
+      include_all_blocks: false
+    };
+  }
+  throw new Error(
+    "Either profileAddresses or controllerAddresses must be provided"
+  );
+}
+__name(buildLSP23DeploymentQuery, "buildLSP23DeploymentQuery");
+function parseLSP23DeploymentsFromHypersync(response, chainId, controllerAddresses) {
+  const deployments = [];
+  if (!response?.data) {
+    return deployments;
+  }
+  const blockTimestamps = /* @__PURE__ */ new Map();
+  for (const block of response.data.blocks || []) {
+    blockTimestamps.set(block.number, block.timestamp);
+  }
+  const txMap = /* @__PURE__ */ new Map();
+  for (const tx of response.data.transactions || []) {
+    if (tx.to?.toLowerCase() === LSP23_FACTORY_ADDRESS.toLowerCase() && tx.input?.startsWith(DEPLOY_ERC1167_PROXIES_SELECTOR)) {
+      txMap.set(tx.hash.toLowerCase(), tx);
+    }
+  }
+  const create2Traces = /* @__PURE__ */ new Map();
+  for (const trace of response.data.traces || []) {
+    if (trace.type === "create2" && trace.to) {
+      create2Traces.set(
+        trace.transaction_hash.toLowerCase(),
+        trace.to
+      );
+    }
+  }
+  const controllerSet = controllerAddresses ? new Set(controllerAddresses.map((addr) => addr.toLowerCase())) : null;
+  for (const [txHash, profileAddress] of create2Traces) {
+    const tx = txMap.get(txHash);
+    if (!tx) continue;
+    if (controllerSet && !controllerSet.has(tx.from.toLowerCase())) {
+      continue;
+    }
+    const decodedInput = decodeDeploymentCalldata(tx.input);
+    const decodedOutput = tx.output ? decodeDeploymentOutput(tx.output) : null;
+    if (!decodedInput || !decodedOutput) continue;
+    const blockTimestamp = blockTimestamps.get(tx.block_number) || 0;
+    deployments.push({
+      profileAddress: decodedOutput.profileAddress,
+      urdAddress: decodedOutput.urdAddress,
+      deployerAddress: tx.from,
+      // The controller that deployed this profile
+      salt: decodedInput.salt,
+      primaryImplementation: decodedInput.primaryImplementation,
+      secondaryImplementation: decodedInput.secondaryImplementation,
+      postDeploymentModule: decodedInput.postDeploymentModule,
+      initializationCalldata: decodedInput.initializationCalldata,
+      deploymentCalldata: tx.input,
+      // Full calldata to deployERC1167Proxies
+      transactionHash: tx.hash,
+      blockNumber: BigInt(tx.block_number),
+      blockTimestamp,
+      // Unix timestamp of the block
+      chainId
+    });
+  }
+  return deployments;
+}
+__name(parseLSP23DeploymentsFromHypersync, "parseLSP23DeploymentsFromHypersync");
+
+// src/utils/json-bigint.ts
+var JSONbigString = {
+  /**
+   * Stringify an object, converting BigInt values to strings with 'n' suffix
+   */
+  stringify: /* @__PURE__ */ __name((obj, replacer, space) => {
+    return JSON.stringify(
+      obj,
+      (key, value) => {
+        if (typeof value === "bigint") {
+          return value.toString() + "n";
+        }
+        return value;
+      },
+      space
+    );
+  }, "stringify"),
+  /**
+   * Parse a JSON string, converting strings ending with 'n' back to BigInt
+   */
+  parse: /* @__PURE__ */ __name((text) => {
+    return JSON.parse(text, (key, value) => {
+      if (typeof value === "string" && /^\d+n$/.test(value)) {
+        return BigInt(value.slice(0, -1));
+      }
+      return value;
+    });
+  }, "parse")
+};
+
+// src/index.ts
+var getTransaction = consumerModel.getTransaction.bind(consumerModel);
+var getTransactionByKey = consumerModel.getTransactionByKey.bind(consumerModel);
+var getTransactionsByIndex = consumerModel.getTransactionsByIndex.bind(consumerModel);
+var getTransactionHashByIndex = consumerModel.getTransactionHashByIndex.bind(consumerModel);
+var getTransactionCount = consumerModel.getTransactionCount.bind(consumerModel);
+var getDecodedCount = consumerModel.getDecodedCount.bind(consumerModel);
+var getDecodedTransactions = consumerModel.getDecodedTransactions.bind(consumerModel);
+var getTransactionsInOrder = consumerModel.getTransactionsInOrder.bind(consumerModel);
+var getAddress = consumerModel.getAddress.bind(consumerModel);
+var getSignal = consumerModel.getSignal.bind(consumerModel);
+var subscribe = consumerModel.subscribe.bind(consumerModel);
+var getState = consumerModel.getState.bind(consumerModel);
+var hasData = consumerModel.hasData.bind(consumerModel);
+var getData = consumerModel.getData.bind(consumerModel);
+var isLoading = consumerModel.isLoading.bind(consumerModel);
+var getError = consumerModel.getError.bind(consumerModel);
+var getAllKeys = consumerModel.getAllKeys.bind(consumerModel);
+var getAllData = consumerModel.getAllData.bind(consumerModel);
+var getAllTransactions = consumerModel.getAllTransactions.bind(consumerModel);
+
+export {
+  getDataKeyCacheKey,
+  dataKeyToString,
+  parseDataKey,
+  createMemoryAddressIdentityCache,
+  resolveAddresses,
+  createApiAddressResolver,
+  AddressResolver,
+  DecoderIntegration,
+  createMemoryAddressCache,
+  LSP23_FACTORY_ADDRESS,
+  DEPLOY_ERC1167_PROXIES_SELECTOR,
+  decodeDeploymentCalldata,
+  decodeDeploymentOutput,
+  extractControllersFromInitCalldata,
+  buildLSP23DeploymentQuery,
+  parseLSP23DeploymentsFromHypersync,
+  JSONbigString,
+  getTransaction,
+  getTransactionByKey,
+  getTransactionsByIndex,
+  getTransactionHashByIndex,
+  getTransactionCount,
+  getDecodedCount,
+  getDecodedTransactions,
+  getTransactionsInOrder,
+  getAddress,
+  getSignal,
+  subscribe,
+  getState,
+  hasData,
+  getData,
+  isLoading,
+  getError,
+  getAllKeys,
+  getAllData,
+  getAllTransactions
+};
+//# sourceMappingURL=chunk-LJ6ES5XF.js.map