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

package/dist/index.d.cts

@@ -0,0 +1,756 @@
+export { A as TransactionAddressResolver, T as TransactionDecoderResult, i as consumerModel, l as createAggregationKey, j as createGlobalInstance, a as decodeTransaction, k as decodeTransactionAsync, m as defaultPlugins, n as defaultSchemaPlugins, p as getArgByName, q as needsEnhancement, o as standardPlugin, s as standardSchemaPlugin } from './utils-CBAkjQh3.cjs';
+import * as viem from 'viem';
+import { Chain, Hex, Address } from 'viem';
+import * as _preact_signals_core from '@preact/signals-core';
+import { c as DataKey, E as EnhancedInfo, I as IDataModel, h as DecoderOptions, b as DecoderResult, T as TransactionState, n as DecoderPlugin, p as ResultAggregate, m as Aggregation, S as SchemaPlugin, e as Info, d as AddressState } from './index-BzXh7poJ.cjs';
+export { j as DecodeEventCallback, a as DecodeEventResult, i as EnhancerCallback, g as IDataModelConsumer, P as PluginOptions, q as ResultCreate, r as ResultError, s as ResultExecute, t as ResultExecuteBatch, u as ResultFollowProfile, v as ResultGrafitti, w as ResultRaw, o as ResultSetData, x as ResultSetDataBatch, y as ResultWrapper } from './index-BzXh7poJ.cjs';
+import '@erc725/erc725.js';
+
+/**
+ * Address identity cache interface
+ * Can be implemented with different backends (LRU, Redis, etc.)
+ */
+interface AddressIdentityCache {
+    /**
+     * Get cached address data
+     */
+    get(key: DataKey): EnhancedInfo | undefined | Promise<EnhancedInfo | undefined>;
+    /**
+     * Set address data in cache
+     */
+    set(key: DataKey, value: EnhancedInfo): void | Promise<void>;
+    /**
+     * Check if address is in cache
+     */
+    has(key: DataKey): boolean | Promise<boolean>;
+    /**
+     * Get multiple addresses at once
+     */
+    getMany?(keys: readonly DataKey[]): Map<DataKey, EnhancedInfo> | Promise<Map<DataKey, EnhancedInfo>>;
+    /**
+     * Set multiple addresses at once
+     */
+    setMany?(entries: Array<[DataKey, EnhancedInfo]>): void | Promise<void>;
+    /**
+     * Clear all cached data
+     */
+    clear?(): void | Promise<void>;
+}
+/**
+ * Helper to convert DataKey to cache key string
+ */
+declare function getDataKeyCacheKey(key: DataKey): string;
+/**
+ * Convert a DataKey to the standardized string format
+ * @param dataKey - A hex string (address or address:tokenId)
+ * @returns The same string
+ */
+declare function dataKeyToString(dataKey: DataKey): string;
+/**
+ * Parse a string to a DataKey
+ * @param str - String in format "address" or "address:tokenId"
+ * @returns DataKey as a hex string
+ */
+declare function parseDataKey(str: string): DataKey;
+/**
+ * Create a simple in-memory address cache
+ */
+declare function createMemoryAddressIdentityCache(ttlMs?: number): AddressIdentityCache;
+
+interface ResolveAddressesOptions {
+    /**
+     * API endpoint URL (defaults to '/api/resolveAddresses')
+     */
+    endpoint?: string;
+    /**
+     * Optional cache to check before making API call
+     */
+    cache?: AddressIdentityCache;
+    /**
+     * Maximum number of addresses per batch (defaults to 100)
+     */
+    batchSize?: number;
+    /**
+     * Request timeout in milliseconds (defaults to 10000)
+     */
+    timeout?: number;
+}
+interface ResolveAddressesResponse {
+    success: boolean;
+    addresses?: Record<string, EnhancedInfo>;
+    cached?: number;
+    fetched?: number;
+    total?: number;
+    error?: string;
+}
+/**
+ * Resolve addresses using the API endpoint
+ * This allows clients to populate the server cache and get resolved addresses
+ */
+declare function resolveAddresses(addresses: DataKey[], chain: Chain, options?: ResolveAddressesOptions): Promise<Map<DataKey, EnhancedInfo>>;
+/**
+ * Create a cache-through address resolver that uses the API
+ * This can be used as a drop-in replacement for fetchMultipleAddresses
+ */
+declare function createApiAddressResolver(chain: Chain, options?: ResolveAddressesOptions): (addresses: DataKey[]) => Promise<Map<DataKey, EnhancedInfo>>;
+
+/**
+ * Collect all DataKeys from a data structure
+ * This is a simplified version that just returns the keys
+ * @param data - The data to analyze
+ * @param skipGqlTypes - Whether to skip GraphQL type fields
+ * @param existingKeys - Optional existing keys to merge with
+ */
+declare function collectDataKeys(data: unknown, skipGqlTypes?: boolean, existingKeys?: DataKey[]): DataKey[];
+
+/**
+ * Configuration for address resolver
+ */
+interface AddressResolverConfig {
+    dataModel: IDataModel;
+    graphqlEndpoint: string;
+    chain: Chain;
+    batchSize?: number;
+    batchDelay?: number;
+    cache?: AddressIdentityCache;
+}
+/**
+ * Resolve addresses using GraphQL
+ * Replaces the old patchValue mechanism
+ */
+declare class AddressResolver {
+    private dataModel;
+    private graphqlEndpoint;
+    private batchSize;
+    private batchDelay;
+    private pendingAddresses;
+    private batchTimer?;
+    private cache?;
+    constructor(config: AddressResolverConfig);
+    /**
+     * Start watching for missing addresses
+     */
+    startWatching(): void;
+    /**
+     * Queue addresses for batch resolution
+     */
+    queueAddresses(addresses: DataKey[]): void;
+    /**
+     * Process a batch of addresses
+     */
+    private processBatch;
+    /**
+     * Stop watching for addresses
+     */
+    stopWatching(): void;
+}
+
+/**
+ * Configuration for decoder integration
+ */
+interface DecoderIntegrationConfig {
+    dataModel: IDataModel;
+    decoderOptions?: Partial<DecoderOptions>;
+    addressCache?: AddressCache;
+}
+/**
+ * External cache interface for address data
+ */
+interface AddressCache {
+    get(key: DataKey): Promise<EnhancedInfo | undefined>;
+    set(key: DataKey, value: EnhancedInfo): Promise<void>;
+    has(key: DataKey): Promise<boolean>;
+    delete(key: DataKey): Promise<void>;
+    clear(): Promise<void>;
+}
+/**
+ * Integrate the decoder with the data model
+ * Handles progressive transaction enhancement and address population
+ */
+declare class DecoderIntegration {
+    private dataModel;
+    private decoderOptions;
+    private addressCache?;
+    constructor(config: DecoderIntegrationConfig);
+    /**
+     * Add and decode a transaction
+     * @param transaction - Raw transaction data
+     * @returns Transaction signal that updates as decoding progresses
+     */
+    addAndDecodeTransaction(transaction: DecoderResult): Promise<_preact_signals_core.Signal<TransactionState>>;
+    /**
+     * Add and decode multiple transactions
+     * @param transactions - Array of raw transactions
+     * @returns Array of transaction signals
+     */
+    addAndDecodeTransactions(transactions: DecoderResult[]): Promise<_preact_signals_core.Signal<TransactionState>[]>;
+    /**
+     * Extract and register addresses from decoded transaction data
+     */
+    private updateAddressesFromDecoded;
+    /**
+     * 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
+     */
+    private flattenBatchTransactions;
+    /**
+     * Load missing address data
+     * This would be called by an external service that fetches address data
+     */
+    loadAddressData(addressData: EnhancedInfo[]): Promise<void>;
+    /**
+     * Get addresses that need to be fetched
+     */
+    getMissingAddresses(): DataKey[];
+    /**
+     * Get addresses currently being loaded
+     */
+    getLoadingAddresses(): DataKey[];
+}
+/**
+ * Create a simple in-memory address cache
+ */
+declare function createMemoryAddressCache(): AddressCache;
+
+/**
+ * Helper function to create a typed aggregation configuration
+ * @param config The aggregation configuration
+ * @returns A frozen aggregation object
+ */
+declare function standardAggregation<T>(config: {
+    key: string;
+    map: (tx: DecoderResult) => T | undefined;
+    reduce: (state: T | undefined, mapped: T) => T;
+    finalize: (state: T) => Omit<ResultAggregate, 'resultType'>;
+}): Aggregation<T>;
+/**
+ * Aggregation engine for processing transactions with map/reduce pattern
+ */
+interface AggregationState<T = unknown> {
+    data: T;
+    lastTransaction: DecoderResult;
+}
+declare class PluginAggregationEngine {
+    private plugins;
+    private states;
+    /**
+     * Register a plugin with aggregations
+     */
+    registerPlugin(plugin: DecoderPlugin): void;
+    /**
+     * Process a transaction through relevant aggregations
+     */
+    processTransaction(tx: DecoderResult): void;
+    /**
+     * Process a batch of transactions
+     */
+    processBatch(txs: DecoderResult[]): void;
+    /**
+     * Get finalized result for a specific plugin and aggregation key
+     */
+    getResult(pluginName: string, key: string): DecoderResult | undefined;
+    /**
+     * Get all aggregation results
+     */
+    getAllResults(): Array<{
+        plugin: string;
+        key: string;
+        result: DecoderResult;
+    }>;
+    /**
+     * Clear all aggregation states
+     */
+    clear(): void;
+    /**
+     * Clear states for a specific plugin
+     */
+    clearPlugin(pluginName: string): void;
+    /**
+     * Get current state (for persistence)
+     */
+    getStates(): Map<string, Map<string, AggregationState>>;
+    /**
+     * Restore states (from persistence)
+     */
+    restoreStates(states: Map<string, Map<string, AggregationState>>): void;
+}
+
+/**
+ * Plugin metadata for registry
+ */
+interface PluginMetadata {
+    name: string;
+    plugin: DecoderPlugin;
+    priority?: number;
+    required?: boolean;
+    description?: string;
+    version?: string;
+    usesAsync?: boolean;
+}
+/**
+ * Schema plugin metadata
+ */
+interface SchemaPluginMetadata {
+    name: string;
+    plugin: SchemaPlugin;
+    priority?: number;
+    required?: boolean;
+    description?: string;
+    version?: string;
+}
+/**
+ * Global plugin registry for auto-registration
+ */
+declare class PluginRegistry {
+    private plugins;
+    private schemaPlugins;
+    /**
+     * Register a decoder plugin
+     * @param name - Unique plugin name
+     * @param plugin - Plugin instance
+     * @param options - Registration options
+     */
+    register(name: string, plugin: DecoderPlugin, options?: {
+        priority?: number;
+        required?: boolean;
+        override?: boolean;
+        description?: string;
+        version?: string;
+        usesAsync?: boolean;
+    }): void;
+    /**
+     * Register a schema plugin
+     * @param name - Unique plugin name
+     * @param plugin - Schema plugin instance
+     * @param options - Registration options
+     */
+    registerSchema(name: string, plugin: SchemaPlugin, options?: {
+        priority?: number;
+        required?: boolean;
+        override?: boolean;
+        description?: string;
+        version?: string;
+    }): void;
+    /**
+     * Unregister a plugin
+     */
+    unregister(name: string): boolean;
+    /**
+     * Get all registered decoder plugins (excluding overridden ones)
+     * @param options - Filter options
+     */
+    getAll(options?: {
+        excludeNames?: string[];
+        syncOnly?: boolean;
+    }): Promise<DecoderPlugin[]>;
+    /**
+     * Get all schema plugins (excluding overridden ones)
+     * @param excludeNames - Plugin names to exclude
+     */
+    getAllSchema(excludeNames?: string[]): SchemaPlugin[];
+    /**
+     * Get a specific plugin by name
+     */
+    get(name: string): Promise<DecoderPlugin | undefined>;
+    /**
+     * Get plugin metadata
+     */
+    getMetadata(name: string): PluginMetadata | undefined;
+    /**
+     * Get schema plugin metadata
+     */
+    getSchemaMetadata(name: string): SchemaPluginMetadata | undefined;
+    /**
+     * Check if a plugin is registered
+     */
+    has(name: string): boolean;
+    /**
+     * Clear all plugins
+     */
+    clear(): void;
+    /**
+     * Get the number of registered plugins
+     */
+    get size(): number;
+    /**
+     * List all registered plugins with metadata
+     */
+    list(): {
+        plugins: PluginMetadata[];
+        schemaPlugins: SchemaPluginMetadata[];
+    };
+}
+declare const pluginRegistry: PluginRegistry;
+declare function registerPlugin(name: string, plugin: DecoderPlugin, options?: {
+    priority?: number;
+    required?: boolean;
+    override?: boolean;
+    description?: string;
+    version?: string;
+    usesAsync?: boolean;
+}): void;
+declare function registerSchemaPlugin(name: string, plugin: SchemaPlugin, options?: {
+    priority?: number;
+    required?: boolean;
+    override?: boolean;
+    description?: string;
+    version?: string;
+}): void;
+declare function createNamedSchemaPlugin(name: string, plugin: (key: Hex, value: Hex) => Promise<Info | undefined>): SchemaPlugin;
+declare function createNamedPlugin(name: string, plugin: Omit<DecoderPlugin, 'name'>): DecoderPlugin;
+
+/**
+ * LSP23 Factory address (same on all networks)
+ */
+declare const LSP23_FACTORY_ADDRESS: "0x2300000a84d25df63081feaa37ba6b62c4c89a30";
+/**
+ * deployERC1167Proxies function selector
+ */
+declare const DEPLOY_ERC1167_PROXIES_SELECTOR: "0x6a66a753";
+/**
+ * LSP23 deployment data structure
+ */
+interface LSP23DeploymentData {
+    profileAddress: Address;
+    urdAddress: Address;
+    deployerAddress: Address;
+    salt: string;
+    primaryImplementation: Address;
+    secondaryImplementation: Address;
+    postDeploymentModule: Address;
+    initializationCalldata: string;
+    deploymentCalldata: string;
+    transactionHash: string;
+    blockNumber: bigint;
+    blockTimestamp: number;
+    chainId: number;
+}
+/**
+ * Contract deployment tuple structures
+ * Primary: (bytes32 salt, uint256 fundingAmount, address implementationContract, bytes initializeCalldata)
+ * Secondary: (uint256 fundingAmount, address implementationContract, bytes addInitializeCalldata, bool addConstructor, bytes constructorParams)
+ */
+/**
+ * Decode deployERC1167Proxies calldata
+ *
+ * Function signature:
+ * deployERC1167Proxies(
+ *   (bytes32 salt, uint256 fundingAmount, address implementationContract, bytes initializeCalldata) primaryContractDeployment,
+ *   (uint256 fundingAmount, address implementationContract, bytes addInitializeCalldata, bool addConstructor, bytes constructorParams) secondaryContractDeployment,
+ *   address postDeploymentModule,
+ *   bytes postDeploymentModuleCalldata
+ * )
+ */
+declare function decodeDeploymentCalldata(input: string): {
+    salt: string;
+    primaryImplementation: Address;
+    secondaryImplementation: Address;
+    postDeploymentModule: Address;
+    initializationCalldata: string;
+} | null;
+/**
+ * Decode deployERC1167Proxies output to get deployed addresses
+ *
+ * Returns: (address primaryContractAddress, address secondaryContractAddress)
+ */
+declare function decodeDeploymentOutput(output: string): {
+    profileAddress: Address;
+    urdAddress: Address;
+} | null;
+/**
+ * Extract controller addresses from initialization calldata
+ *
+ * The initializationCalldata contains a setDataBatch call that sets up controller permissions.
+ * Function: setDataBatch(bytes32[] dataKeys, bytes[] dataValues)
+ *
+ * The dataKeys contain entries like:
+ * - AddressPermissions:Permissions:<controller-address>
+ *
+ * We extract controller addresses from these keys.
+ */
+declare function extractControllersFromInitCalldata(initializationCalldata: string): Address[];
+/**
+ * Hypersync query configuration for LSP23 deployments
+ */
+interface HypersyncQueryConfig {
+    /**
+     * Controller addresses (derived keys) that deployed profiles
+     * We only want LSP23 data for profiles WE created, not imported
+     */
+    controllerAddresses?: Address[];
+    /**
+     * Profile addresses to query deployment data for
+     * More efficient than querying by controllers when we already know the profiles
+     */
+    profileAddresses?: Address[];
+    /**
+     * Starting block (0 for genesis)
+     */
+    fromBlock?: number;
+    /**
+     * Ending block (undefined for latest)
+     */
+    toBlock?: number;
+    /**
+     * Chain ID to query
+     */
+    chainId: number;
+}
+/**
+ * Build Hypersync query to find LSP23 deployments
+ *
+ * Strategy 1 (by profileAddresses - RECOMMENDED):
+ * Query CREATE2 traces where the created address matches our profile addresses.
+ * Then filter transactions to LSP23 factory and verify deployer is one of our controllers.
+ * This is more efficient when we already know the profile addresses from GraphQL.
+ *
+ * Strategy 2 (by controllerAddresses - LEGACY):
+ * Query transactions TO the LSP23 factory FROM our controller addresses.
+ * This scans the entire chain history for all deployments by our controllers.
+ */
+declare function buildLSP23DeploymentQuery(config: HypersyncQueryConfig): {
+    from_block: number;
+    to_block: number | undefined;
+    traces: {
+        type: string[];
+        to: string[];
+    }[];
+    transactions: {
+        to: string[];
+    }[];
+    field_selection: {
+        transaction: string[];
+        trace: string[];
+        block: string[];
+    };
+    include_all_blocks: boolean;
+} | {
+    from_block: number;
+    to_block: number | undefined;
+    transactions: {
+        from: string[];
+        to: string[];
+    }[];
+    traces: {
+        type: string[];
+    }[];
+    field_selection: {
+        transaction: string[];
+        trace: string[];
+        block: string[];
+    };
+    include_all_blocks: boolean;
+};
+/**
+ * Parse Hypersync response to extract LSP23 deployment data
+ * @param response - Hypersync API response
+ * @param chainId - Chain ID
+ * @param controllerAddresses - Optional list of controller addresses to filter by (only return deployments from these deployers)
+ */
+declare function parseLSP23DeploymentsFromHypersync(response: any, chainId: number, controllerAddresses?: Address[]): LSP23DeploymentData[];
+
+interface ImageData {
+    width?: number;
+    height?: number;
+    url?: string;
+    src?: string;
+    verified?: boolean;
+}
+interface LinkData {
+    url: string;
+    title?: string;
+}
+interface ProfileData {
+    id: Hex;
+    name?: string;
+    fullName?: string;
+    tags?: string[];
+    description?: string;
+    links?: LinkData[];
+    standard?: string;
+    controllers?: Array<{
+        address: string;
+        tags?: string[];
+        permissions?: Hex;
+    }>;
+    owner?: {
+        id: string;
+    };
+    profileImages?: ImageData[];
+    backgroundImages?: ImageData[];
+    avatars?: ImageData[];
+}
+interface AssetData {
+    id: Hex;
+    name?: string;
+    standard?: string;
+    lsp4TokenName?: string;
+    lsp4TokenSymbol?: string;
+    lsp4TokenType?: string;
+    method?: string;
+    description?: string;
+    links?: LinkData[];
+    decimals?: number;
+    interfaces?: string[];
+    isCollection?: boolean;
+    isLSP7?: boolean;
+    isUnknown?: boolean;
+    icons?: ImageData[];
+    images?: ImageData[];
+}
+interface TokenData {
+    id: Hex;
+    tokenId?: Hex;
+    name?: string;
+    description?: string;
+    links?: LinkData[];
+    lsp4TokenName?: string;
+    lsp4TokenSymbol?: string;
+    lsp4TokenType?: string;
+    lsp8TokenIdFormat?: string;
+    formattedTokenId?: string;
+    baseAsset?: {
+        id: Hex;
+        description?: string;
+        icons?: ImageData[];
+        isCollection?: boolean;
+        isLSP7?: boolean;
+        isUnknown?: boolean;
+        name?: string;
+        standard?: string;
+        interfaces?: string[];
+        decimals?: number;
+    };
+    icons?: ImageData[];
+    images?: ImageData[];
+}
+type TFetchAddressData = {
+    Profile?: ProfileData[];
+    Asset?: AssetData[];
+    Token?: TokenData[];
+};
+/**
+ * Fetch multiple addresses from GraphQL and return them as a Map
+ * This is the shared implementation that both server and core can use
+ */
+declare function fetchMultipleAddresses(addresses: readonly DataKey[], graphqlEndpoint: string, cache?: AddressIdentityCache): Promise<Map<DataKey, EnhancedInfo>>;
+/**
+ * Get GraphQL endpoint for a given chain
+ */
+declare function getGraphQLEndpoint(chain: Chain): string;
+/**
+ * Find profiles controlled by specific controller addresses
+ * @param controllerAddresses - Array of controller addresses to search for
+ * @param chain - Which chain to query
+ * @returns Array of profile data
+ */
+declare function fetchProfilesByControllers(controllerAddresses: readonly Address[], chain: Chain): Promise<ProfileData[]>;
+type ImageURL = {
+    url?: string;
+    data?: string;
+    src?: string;
+    width: number;
+    height: number;
+    index?: number;
+    verified?: string;
+};
+/**
+ * Assuming the images are sorted ascending by width and/or height pick the first
+ * image that's larger than the requested size * dpr and process that one.
+ * By default this will assume the data came from the indexer and therefore
+ * we do not need to verify the existence of all the images (i.e. HEAD requests for
+ * each image) Setting ignoreHead to false is important during RPC mode so that
+ * we can skip images that are not really available.
+ *
+ * @param images - array of images
+ * @param options - specify arguments for search/processing
+ * @returns { width, height, src } - the image that fits the criteria
+ */
+declare function getImage(images: ImageURL[], options: {
+    width: number;
+    height?: number;
+    index?: number;
+    ignoreVerification?: boolean;
+    forcePng?: boolean;
+    ignoreHead?: boolean;
+    fallback?: string;
+    dpr?: number;
+}): Promise<{
+    width: number;
+    height: number;
+    src?: string;
+} | undefined>;
+
+/**
+ * Debug wrapper for edge/worker environments
+ * This avoids the tty dependency in the debug module
+ */
+declare function createDebug(namespace: string): (...args: any[]) => void;
+
+/**
+ * JSON serializer/deserializer that preserves BigInt types
+ *
+ * This implementation uses an 'n' suffix to indicate BigInt values,
+ * ensuring that values that were originally BigInt remain BigInt,
+ * and values that were originally numbers remain numbers.
+ *
+ * Example:
+ * - BigInt(123) serializes to "123n"
+ * - Number(123) serializes to 123
+ *
+ * This is important for blockchain data where some values must be BigInt
+ * (e.g., gas, value, nonce) while others should remain as numbers
+ * (e.g., array indices, status codes).
+ */
+declare const JSONbigString: {
+    /**
+     * Stringify an object, converting BigInt values to strings with 'n' suffix
+     */
+    stringify: (obj: any, replacer?: any, space?: string | number) => string;
+    /**
+     * Parse a JSON string, converting strings ending with 'n' back to BigInt
+     */
+    parse: (text: string) => any;
+};
+
+declare const getTransaction: (jsonTransaction: unknown) => _preact_signals_core.Signal<TransactionState> | undefined;
+declare const getTransactionByKey: (hash: viem.Hex, decoderIndex?: number) => _preact_signals_core.Signal<TransactionState> | undefined;
+declare const getTransactionsByIndex: (index: number) => Map<number | null, _preact_signals_core.Signal<TransactionState>> | undefined;
+declare const getTransactionHashByIndex: (index: number) => viem.Hex | undefined;
+declare const getTransactionCount: () => number;
+declare const getDecodedCount: (hash: viem.Hex) => number;
+declare const getDecodedTransactions: (hash: viem.Hex) => Array<_preact_signals_core.Signal<TransactionState>>;
+declare const getTransactionsInOrder: () => Array<{
+    hash: viem.Hex;
+    transactions: Array<_preact_signals_core.Signal<TransactionState>>;
+}>;
+declare const getAddress: (address: DataKey) => _preact_signals_core.Signal<AddressState>;
+declare const getSignal: (key: DataKey) => _preact_signals_core.Signal<AddressState>;
+declare const subscribe: (key: DataKey, callback: (state: AddressState) => void) => () => void;
+declare const getState: (key: DataKey) => AddressState;
+declare const hasData: (key: DataKey) => boolean;
+declare const getData: (key: DataKey) => {
+    readonly [x: string]: unknown;
+    readonly address: `0x${string}`;
+    readonly standard?: string | undefined;
+    readonly tokenId?: `0x${string}` | undefined;
+    readonly name?: string | undefined;
+    readonly __gqltype?: "Profile" | "Asset" | "Token" | undefined;
+} | undefined;
+declare const isLoading: (key: DataKey) => boolean;
+declare const getError: (key: DataKey) => string | undefined;
+declare const getAllKeys: () => ReadonlyArray<DataKey>;
+declare const getAllData: () => Readonly<Record<string, AddressState>>;
+declare const getAllTransactions: () => Readonly<Record<string, TransactionState>>;
+
+export { type AddressCache, type AddressIdentityCache, AddressResolver, type AddressResolverConfig, AddressState, Aggregation, type AggregationState, type AssetData, DEPLOY_ERC1167_PROXIES_SELECTOR, DataKey, DecoderIntegration, type DecoderIntegrationConfig, DecoderPlugin, DecoderResult, EnhancedInfo, type HypersyncQueryConfig, type ImageData, type ImageURL, JSONbigString, type LSP23DeploymentData, LSP23_FACTORY_ADDRESS, type LinkData, PluginAggregationEngine, type PluginMetadata, type ProfileData, type ResolveAddressesOptions, type ResolveAddressesResponse, ResultAggregate, SchemaPlugin, type SchemaPluginMetadata, type TFetchAddressData, type TokenData, TransactionState, buildLSP23DeploymentQuery, collectDataKeys, createApiAddressResolver, createDebug, createMemoryAddressCache, createMemoryAddressIdentityCache, createNamedPlugin, createNamedSchemaPlugin, dataKeyToString, decodeDeploymentCalldata, decodeDeploymentOutput, extractControllersFromInitCalldata, fetchMultipleAddresses, fetchProfilesByControllers, getAddress, getAllData, getAllKeys, getAllTransactions, getData, getDataKeyCacheKey, getDecodedCount, getDecodedTransactions, getError, getGraphQLEndpoint, getImage, getSignal, getState, getTransaction, getTransactionByKey, getTransactionCount, getTransactionHashByIndex, getTransactionsByIndex, getTransactionsInOrder, hasData, isLoading, parseDataKey, parseLSP23DeploymentsFromHypersync, pluginRegistry, registerPlugin, registerSchemaPlugin, resolveAddresses, standardAggregation, subscribe };