@the_library/public 1.0.0

package/dist/web3/index.d.ts

@@ -0,0 +1,820 @@
+import { R as ReadOnlyDomainAPI, A as AddressRegistryReadAPI, c as ArchivistStorageReadAPI, B as BouncerStorageReadAPI, S as ScientistStorageReadAPI, F as FactoryReadAPI, d as ProjectManagerStorageReadAPI, e as SubscriptionManagerReadAPI, L as LibraryRegistryStorageReadAPI, f as PublicLibraryStorageReadAPI, g as WriteOnlyDomainAPI, h as FactoryWriteAPI, i as SubscriptionManagerWriteAPI, j as AddressRegistryWriteAPI, k as LibraryRegistryStorageWriteAPI, l as PublicLibraryStorageWriteAPI, W as WalletType, T as TransactionOptions, b as WalletConnector, E as EvmWalletConnector, C as ConnectResult } from '../types-Dn0EFMO_.js';
+export { o as AddressRegistryContractRecord, p as AddressRegistryUpdateInfo, r as Collection, q as CollectionInput, m as ContractAddresses, w as ErrorCode, s as LibraryOwnership, N as NormalizedError, t as PreferredFormat, a as Project, P as ProjectVersion, v as PublicLibrary, u as PublicLibraryInput, n as StripeDonation } from '../types-Dn0EFMO_.js';
+import * as viem from 'viem';
+import { PublicClient, WalletClient, TransactionRequest } from 'viem';
+export { formatEther, parseEther } from 'viem';
+import { E as EvmChainConfig, a as SessionStore, W as Web3SessionAccount, S as SyncCursor, b as SubscriptionNode, c as WalkOptions, d as SubscriptionGraph, F as FetchOptions, e as Patch, f as SyncOptions, g as SyncResult } from '../types-Xb8Ta9tZ.js';
+export { C as ChainPrice, D as DEFAULT_CHAIN_ID, k as EVM_CHAINS, j as PatchCacheAdapter, P as ProjectLocale, h as SessionState, m as getChain, i as loadProject, l as loadProjects, p as projectLocale, t as toViemChain } from '../types-Xb8Ta9tZ.js';
+export { CACHE_DURATION_MS, CacheEntry, ContractLoadingStatus, LoadingStatus, Manifest, ManifestContractEntry, ManifestNetwork, ManifestProvenance, NodeFileCacheStorage, RegistryAddressLoader, RegistryCache, RegistryCacheStorage, ResolvedSidecarUrls, SidecarObjectPointers, V2DataBlock, addressLoader, createNodeFileCacheStorage, getContractAbi, getRegistryBaseUrl, setRegistryBaseUrl, sidecarUrlsFromManifest } from './registry.js';
+
+declare class EvmClient implements ReadOnlyDomainAPI {
+    readonly ready: Promise<void>;
+    readonly chainId: number;
+    readonly chain: viem.Chain;
+    readonly publicClient: PublicClient;
+    readonly environment: 'production' | 'staging';
+    readonly config: EvmChainConfig;
+    private _contractAddresses;
+    addressRegistry: AddressRegistryReadAPI;
+    archivistStorage: ArchivistStorageReadAPI;
+    bouncerStorage: BouncerStorageReadAPI;
+    scientistStorage: ScientistStorageReadAPI;
+    factory: FactoryReadAPI;
+    projectManagerStorage: ProjectManagerStorageReadAPI;
+    subscriptionManager: SubscriptionManagerReadAPI;
+    libraryRegistryStorage: LibraryRegistryStorageReadAPI;
+    publicLibraryStorage: PublicLibraryStorageReadAPI;
+    getUsdPrice(): Promise<number>;
+    constructor(chainId: number, environment?: 'production' | 'staging');
+    private get activeRegistryAddress();
+    private addresses;
+    private requireAbi;
+    private read;
+    private createAddressRegistryReadAPI;
+    private createArchivistReadApi;
+    private createProjectManagerStorageReadAPI;
+    private createBouncerStorageReadAPI;
+    private createScientistStorageReadAPI;
+    private createFactoryReadAPI;
+    private createSubscriptionManagerReadAPI;
+    private createLibraryRegistryStorageReadAPI;
+    private createPublicLibraryStorageReadAPI;
+    getRegistryStatus(): Promise<any>;
+}
+declare function createEvmClient(chainId?: number, environment?: 'production' | 'staging'): EvmClient;
+
+declare class EvmWriteClient implements WriteOnlyDomainAPI {
+    readonly readonly: EvmClient;
+    readonly writeOnly: WriteOnlyDomainAPI;
+    private readonly publicClient;
+    private readonly chain;
+    readonly config: EvmChainConfig;
+    readonly wallet: string;
+    private readonly environment;
+    private readonly _account;
+    constructor(wallet: string, readonlyApi: EvmClient, walletClient: WalletClient, account: string);
+    get factory(): FactoryWriteAPI;
+    get subscriptionManager(): SubscriptionManagerWriteAPI;
+    get addressRegistry(): AddressRegistryWriteAPI;
+    get libraryRegistryStorage(): LibraryRegistryStorageWriteAPI;
+    get publicLibraryStorage(): PublicLibraryStorageWriteAPI;
+    getChainId(): number;
+    account(): string;
+    getNormalizedAddress(address: string): string;
+    private requireAbi;
+    private getFactoryAddress;
+    private getRegistryAddress;
+    private createFactoryWriteAPI;
+    private createSubscriptionManagerWriteAPI;
+    private createAddressRegistryWriteAPI;
+    private getLibraryRegistryStorageAddress;
+    private createLibraryRegistryStorageWriteAPI;
+    private getPublicLibraryStorageAddress;
+    private createPublicLibraryStorageWriteAPI;
+}
+
+declare const readOnlyClients: Record<number, ReadOnlyDomainAPI>;
+declare const readOnlyStagingClients: Record<number, ReadOnlyDomainAPI>;
+declare function getReadClient(chainId: number, environment?: 'production' | 'staging'): ReadOnlyDomainAPI;
+declare function getEvmClient(chainId: number, environment?: 'production' | 'staging'): EvmClient;
+declare function getReadyEvmClient(chainId: number, environment?: 'production' | 'staging'): Promise<EvmClient>;
+
+declare function createSessionStore(): SessionStore;
+declare const sessionStore: SessionStore;
+/**
+ * Returns all known accounts that have completed on-chain registration
+ * (i.e. `hasAccount === true`). This is a plain (non-reactive) snapshot —
+ * wrap in `computed()` at the call site if reactivity is needed.
+ */
+declare const allRegisteredAccounts: () => Web3SessionAccount[];
+
+/**
+ * Hydrates one address from chain and updates sessionStore. Replaces
+ * registry.addAccount(wallet, tech, chainId, address, forceRefresh).
+ */
+declare function syncAccount(address: string, chainId: number, wallet: WalletType, environment?: 'production' | 'staging', forceRefresh?: boolean): Promise<Web3SessionAccount>;
+/**
+ * Cross-device sync for the caller's own saved patches: checks local state
+ * against on-chain "writes" and, if the chain is ahead, decodes, persists to
+ * IndexedDB, and merges the missing patches into the live ORM — all
+ * internally. Callers get only a completion boolean; WalletEvents.onSaveRestored
+ * fires afterward as a UX-only "sync finished" signal (no patch payload to act on).
+ * Meant to be called once at boot, non-blocking (fire-and-forget).
+ * Replaces registry.restoreMySave(wallet, tech, chainId, account).
+ */
+declare function restoreAccountSave(address: string, chainId: number, environment?: 'production' | 'staging'): Promise<boolean>;
+/**
+ * Read-only check for whether the caller has locally-authored patches not
+ * yet pushed to BackupStorage via saveMyLevel() (mutations.ts). No wallet/
+ * connector required — safe to call just to drive a "you have unsaved
+ * changes" UI hint.
+ */
+declare function hasUnsavedPatches(address: string, chainId: number): Promise<boolean>;
+/**
+ * Pure data fetcher for network-wide statistics.
+ */
+declare function loadNetworkInfos(chainId: number, environment?: 'production' | 'staging', forceRefresh?: boolean): Promise<any>;
+
+declare const resetTransactionState: () => void;
+declare const handleWriteOperationErrors: (wallet: WalletType, chainId: number, e: any) => void;
+declare const writeOperations: {
+    register: (wallet: WalletType, chainId: number, account: string, amount: number) => Promise<boolean>;
+    retire: (wallet: WalletType, chainId: number, account: string, options?: TransactionOptions) => Promise<boolean>;
+    vote: (wallet: WalletType, chainId: number, account: string, projectId: number, lang: string, amount: number, options?: TransactionOptions) => Promise<boolean>;
+    save: (wallet: WalletType, chainId: number, account: string, compressedActions: Array<bigint>, textIndexes: Array<number>, textData: Array<string>, level: number, options?: TransactionOptions & {
+        skipCounterUpdate?: boolean;
+    }) => Promise<boolean>;
+    subscribe: (wallet: WalletType, chainId: number, account: string, subscriber: number, target: number) => Promise<boolean>;
+    unsubscribe: (wallet: WalletType, chainId: number, account: string, subscriber: number, target: number) => Promise<boolean>;
+};
+/**
+ * Assembles the caller's own locally-authored patches since their last save
+ * (getNbPatches/serializePatches, models_v2) and pushes them to BackupStorage
+ * via writeOperations.save — the pipeline apps used to assemble by hand.
+ * Returns false (no-op, no transaction sent) if there's nothing new to save.
+ */
+declare function saveMyLevel(wallet: WalletType, chainId: number, account: string, options?: TransactionOptions & {
+    skipCounterUpdate?: boolean;
+}): Promise<boolean>;
+
+/**
+ * Bridges a connected WalletConnector to a concrete EvmWriteClient. Kept out of
+ * client/ and wallet/ so neither layer needs to know about the other:
+ * WalletConnector stays viem-free (client/types.ts), EvmWriteClient stays
+ * connector-agnostic (client/EvmWriteClient.ts) — this is the seam.
+ */
+declare function createWriteClient(connector: WalletConnector, chainId: number, environment?: 'production' | 'staging'): Promise<EvmWriteClient>;
+/**
+ * Same bridge as createWriteClient, but for a key that only ever exists
+ * decrypted-in-memory — for callers with their own encrypted vault (e.g. an
+ * admin tool) that want to sign without ever persisting the key via
+ * wallet/credentials.ts's plaintext localStorage or going through the
+ * connector registry.
+ */
+declare function createPrivateKeyWriteClient(chainId: number, privateKey: string, environment?: 'production' | 'staging'): Promise<EvmWriteClient>;
+
+interface SerializedCursor {
+    rootUserId: number;
+    knownNodes: Array<[number, SubscriptionNode]>;
+    countSnapshot: Array<[number, number]>;
+    patchIndex: Array<[number, number]>;
+}
+declare function serializeCursor(cursor: SyncCursor): SerializedCursor;
+declare function deserializeCursor(serialized: SerializedCursor): SyncCursor;
+declare function emptyCursor(rootUserId: number): SyncCursor;
+/**
+ * IndexedDB-backed cursor store keyed by userId — a sibling of sessionStore,
+ * not a field on it (spec §15.8: SyncCursor is heavier than the counters
+ * already on Web3SessionAccount, and bloating that struct isn't worth it for
+ * 5 component files that reference it as a prop/ref type).
+ */
+declare const cursorStore: {
+    get(userId: number): Promise<SyncCursor | undefined>;
+    set(userId: number, cursor: SyncCursor): Promise<void>;
+    clear(userId: number): Promise<void>;
+};
+
+interface SubscriptionClientConfig {
+    chainId: number;
+    environment?: 'production' | 'staging';
+    maxWalkNodes?: number;
+    maxDepth?: number;
+}
+/**
+ * Orchestrates graph walk + patch fetch. Algorithm unchanged from the
+ * original `web3_subscription_package.md` spec (§5-8); only the module
+ * boundary and the patch source (on-chain BackupStorage, not Arweave) moved.
+ */
+declare class SubscriptionClient {
+    private readonly client;
+    private readonly defaultMaxWalkNodes?;
+    private readonly defaultMaxDepth?;
+    constructor(config: SubscriptionClientConfig);
+    walkGraph(rootUserId: number, opts?: WalkOptions): Promise<SubscriptionGraph>;
+    fetchPatches(graph: SubscriptionGraph, cursor?: Map<number, number>, opts?: FetchOptions): Promise<Patch[]>;
+    /** Full walk + fetch from scratch. */
+    sync(rootUserId: number, opts?: SyncOptions): Promise<SyncResult>;
+    /**
+     * Incremental sync (spec §8, unchanged algorithm): multicall
+     * getSubscriptionCount for every known node, deep re-walk only the nodes
+     * whose count changed (O4: completeness over cost), then fetch only new
+     * patches per node since the cursor.
+     */
+    syncSince(cursor: SyncCursor, opts?: SyncOptions): Promise<SyncResult>;
+    getSubscriptions(userId: number): Promise<number[]>;
+    getScore(userId: number): Promise<bigint>;
+    /**
+     * High-level API: load and apply library patches for a user by username.
+     * Orchestrates: username→userId lookup, sync, deserialize, and IndexedDB application.
+     * Errors are caught and logged to console but not thrown (graceful degradation).
+     */
+    loadLibraryByUsername(username: string): Promise<void>;
+}
+
+declare function getSubscriptionClient(chainId: number, environment?: 'production' | 'staging'): SubscriptionClient;
+
+declare const addressRegistryAbi: readonly [{
+    readonly inputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "constructor";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "oldAdmin";
+        readonly type: "address";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "newAdmin";
+        readonly type: "address";
+    }];
+    readonly name: "AdminChanged";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "string";
+        readonly name: "key";
+        readonly type: "string";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "string";
+        readonly name: "arweaveTxId";
+        readonly type: "string";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "bytes32";
+        readonly name: "sha256Hash";
+        readonly type: "bytes32";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "version";
+        readonly type: "uint256";
+    }];
+    readonly name: "BlobRefAdded";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "string";
+        readonly name: "name";
+        readonly type: "string";
+    }, {
+        readonly indexed: true;
+        readonly internalType: "address";
+        readonly name: "contractAddress";
+        readonly type: "address";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "string";
+        readonly name: "abiUrl";
+        readonly type: "string";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "version";
+        readonly type: "uint256";
+    }];
+    readonly name: "ContractAdded";
+    readonly type: "event";
+}, {
+    readonly anonymous: false;
+    readonly inputs: readonly [{
+        readonly indexed: true;
+        readonly internalType: "string";
+        readonly name: "key";
+        readonly type: "string";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "string";
+        readonly name: "value";
+        readonly type: "string";
+    }, {
+        readonly indexed: false;
+        readonly internalType: "uint256";
+        readonly name: "version";
+        readonly type: "uint256";
+    }];
+    readonly name: "DataAdded";
+    readonly type: "event";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "string";
+        readonly name: "key";
+        readonly type: "string";
+    }, {
+        readonly internalType: "string";
+        readonly name: "arweaveTxId";
+        readonly type: "string";
+    }, {
+        readonly internalType: "bytes32";
+        readonly name: "sha256Hash";
+        readonly type: "bytes32";
+    }];
+    readonly name: "addBlobRef";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "string";
+        readonly name: "name";
+        readonly type: "string";
+    }, {
+        readonly internalType: "address";
+        readonly name: "contractAddress";
+        readonly type: "address";
+    }, {
+        readonly internalType: "string";
+        readonly name: "abiUrl";
+        readonly type: "string";
+    }];
+    readonly name: "addContract";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "string";
+        readonly name: "key";
+        readonly type: "string";
+    }, {
+        readonly internalType: "string";
+        readonly name: "value";
+        readonly type: "string";
+    }];
+    readonly name: "addData";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "admin";
+    readonly outputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "newAdmin";
+        readonly type: "address";
+    }];
+    readonly name: "changeAdmin";
+    readonly outputs: readonly [];
+    readonly stateMutability: "nonpayable";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "getAllBlobRefKeys";
+    readonly outputs: readonly [{
+        readonly internalType: "string[]";
+        readonly name: "";
+        readonly type: "string[]";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "getAllContractNames";
+    readonly outputs: readonly [{
+        readonly internalType: "string[]";
+        readonly name: "";
+        readonly type: "string[]";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [];
+    readonly name: "getAllDataKeys";
+    readonly outputs: readonly [{
+        readonly internalType: "string[]";
+        readonly name: "";
+        readonly type: "string[]";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "string";
+        readonly name: "key";
+        readonly type: "string";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "offset";
+        readonly type: "uint256";
+    }, {
+        readonly internalType: "uint256";
+        readonly name: "limit";
+        readonly type: "uint256";
+    }];
+    readonly name: "getBlobRefHistory";
+    readonly outputs: readonly [{
+        readonly components: readonly [{
+            readonly internalType: "string";
+            readonly name: "arweaveTxId";
+            readonly type: "string";
+        }, {
+            readonly internalType: "bytes32";
+            readonly name: "sha256Hash";
+            readonly type: "bytes32";
+        }];
+        readonly internalType: "struct AddressRegistry.BlobRef[]";
+        readonly name: "";
+        readonly type: "tuple[]";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "string";
+        readonly name: "name";
+        readonly type: "string";
+    }];
+    readonly name: "getContractHistory";
+    readonly outputs: readonly [{
+        readonly components: readonly [{
+            readonly internalType: "address";
+            readonly name: "contractAddress";
+            readonly type: "address";
+        }, {
+            readonly internalType: "string";
+            readonly name: "abiUrl";
+            readonly type: "string";
+        }];
+        readonly internalType: "struct AddressRegistry.ContractRecord[]";
+        readonly name: "";
+        readonly type: "tuple[]";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "string";
+        readonly name: "key";
+        readonly type: "string";
+    }];
+    readonly name: "getDataHistory";
+    readonly outputs: readonly [{
+        readonly internalType: "string[]";
+        readonly name: "";
+        readonly type: "string[]";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "string";
+        readonly name: "key";
+        readonly type: "string";
+    }];
+    readonly name: "getLatestBlobRef";
+    readonly outputs: readonly [{
+        readonly internalType: "string";
+        readonly name: "";
+        readonly type: "string";
+    }, {
+        readonly internalType: "bytes32";
+        readonly name: "";
+        readonly type: "bytes32";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "string";
+        readonly name: "name";
+        readonly type: "string";
+    }];
+    readonly name: "getLatestContract";
+    readonly outputs: readonly [{
+        readonly internalType: "address";
+        readonly name: "";
+        readonly type: "address";
+    }, {
+        readonly internalType: "string";
+        readonly name: "";
+        readonly type: "string";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "string";
+        readonly name: "key";
+        readonly type: "string";
+    }];
+    readonly name: "getLatestData";
+    readonly outputs: readonly [{
+        readonly internalType: "string";
+        readonly name: "";
+        readonly type: "string";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}];
+
+declare const pythAbi: readonly [{
+    readonly inputs: readonly [{
+        readonly internalType: "bytes32";
+        readonly name: "id";
+        readonly type: "bytes32";
+    }];
+    readonly name: "getPriceUnsafe";
+    readonly outputs: readonly [{
+        readonly components: readonly [{
+            readonly internalType: "int64";
+            readonly name: "price";
+            readonly type: "int64";
+        }, {
+            readonly internalType: "uint64";
+            readonly name: "conf";
+            readonly type: "uint64";
+        }, {
+            readonly internalType: "int32";
+            readonly name: "expo";
+            readonly type: "int32";
+        }, {
+            readonly internalType: "uint256";
+            readonly name: "publishTime";
+            readonly type: "uint256";
+        }];
+        readonly internalType: "struct PythStructs.Price";
+        readonly name: "price";
+        readonly type: "tuple";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes[]";
+        readonly name: "updateData";
+        readonly type: "bytes[]";
+    }];
+    readonly name: "getUpdateFee";
+    readonly outputs: readonly [{
+        readonly internalType: "uint256";
+        readonly name: "feeAmount";
+        readonly type: "uint256";
+    }];
+    readonly stateMutability: "view";
+    readonly type: "function";
+}, {
+    readonly inputs: readonly [{
+        readonly internalType: "bytes[]";
+        readonly name: "updateData";
+        readonly type: "bytes[]";
+    }];
+    readonly name: "updatePriceFeeds";
+    readonly outputs: readonly [];
+    readonly stateMutability: "payable";
+    readonly type: "function";
+}];
+
+declare enum EventName {
+    WALLET_STATE_CHANGED = "wallet:state:changed",
+    WALLET_CHAIN_CHANGED = "wallet:chain:changed",
+    WALLET_ERROR = "wallet:error",
+    SESSION_UPDATED = "session:updated",
+    WALLET_DISCONNECTED = "wallet:disconnected",
+    SESSION_DELETED = "session:deleted",
+    SAVE_RESTORED = "save:restored",
+    SUBSCRIPTION_PATCHES_SYNCED = "subscription:patches:synced"
+}
+declare enum WalletState {
+    INITIALIZING = "INITIALIZING",
+    UPDATING_STATE_STARTED = "UPDATING_STATE_STARTED",
+    UPDATING_STATE_DONE = "UPDATING_STATE_DONE",
+    UPDATING_STATE_FAILED = "UPDATING_STATE_FAILED",
+    READY = "READY",
+    INTERNAL_ERROR = "INTERNAL_ERROR",
+    NOT_CONNECTED = "NOT_CONNECTED",
+    NOT_INSTALLED = "NOT_INSTALLED",
+    NOT_ALLOWED = "NOT_ALLOWED",
+    NOT_SUPPORTED = "NOT_SUPPORTED",
+    NOT_READY = "NOT_READY",
+    CONNECT_STARTED = "CONNECT_STARTED",
+    CONNECT_DONE = "CONNECT_DONE",
+    CONNECT_FAILED = "CONNECT_FAILED",
+    TRANSACTION_STARTED = "TRANSACTION_STARTED",
+    TRANSACTION_DONE = "TRANSACTION_DONE",
+    TRANSACTION_FAILED = "TRANSACTION_FAILED",
+    TIMEOUT = "TIMEOUT",
+    CHAIN_CHANGED_STARTED = "CHAIN_CHANGED_STARTED",
+    CHAIN_CHANGED_DONE = "CHAIN_CHANGED_DONE",
+    CHAIN_CHANGED_FAILED = "CHAIN_CHANGED_FAILED",
+    WALLET_INSTALLED = "WALLET_INSTALLED"
+}
+declare enum WalletError {
+    NO_ACCOUNTS = "NO_ACCOUNTS",
+    USER_REJECTED = "USER_REJECTED",
+    INSUFFICIENT_FUNDS = "INSUFFICIENT_FUNDS",
+    LOGIN_INTO_WALLET = "LOGIN_INTO_WALLET",
+    REQUEST_ALREADY_PENDING = "REQUEST_ALREADY_PENDING",
+    UNKNOWN_ERROR = "UNKNOWN_ERROR",
+    CONFIG_MISSING = "CONFIG_MISSING",
+    NOT_SUPPORTED = "NOT_SUPPORTED",
+    NOT_CONNECTED = "NOT_CONNECTED",
+    NOT_INSTALLED = "NOT_INSTALLED",
+    NOT_ALLOWED = "NOT_ALLOWED",
+    NETWORK_NOT_SUPPORTED = "NETWORK_NOT_SUPPORTED"
+}
+declare enum WalletUxError {
+    NO_ACCOUNT_SWITCH = "NO_ACCOUNT_SWITCH",
+    NO_NETWORK_SWITCH = "NO_NETWORK_SWITCH",
+    NETWORK_NOT_SUPPORTED = "NETWORK_NOT_SUPPORTED",
+    NO_INTERNET = "NO_INTERNET",
+    NO_DISCONNECT = "NO_DISCONNECT",
+    NO_ACCOUNT_DISCONNECT = "NO_ACCOUNT_DISCONNECT"
+}
+
+interface CommonWalletEvent {
+    wallet: WalletType;
+    chainId?: number;
+    timestamp: number;
+}
+interface WalletStateEvent extends CommonWalletEvent {
+    event: WalletState;
+    functionName?: string;
+    functionArgs?: any[];
+}
+interface WalletSessionEvent {
+    account: string;
+    chainId: number;
+    wallet: WalletType;
+}
+interface WalletSessionDeletedEvent {
+    account: string;
+    chainId: number;
+    wallet: WalletType;
+}
+interface WalletErrorEvent extends CommonWalletEvent {
+    reason: WalletUxError | WalletError;
+    args?: any[];
+}
+interface WalletChainChangedEvent extends CommonWalletEvent {
+}
+interface WalletDisconnectedEvent extends CommonWalletEvent {
+    reason?: string;
+    timestamp: number;
+}
+interface WalletSaveRestoredEvent extends CommonWalletEvent {
+    username: string;
+    account: string;
+    newRestorationIndex: number;
+    appliedCount: number;
+}
+interface SubscriptionPatchesSyncedEvent {
+    rootUserId: number;
+    chainId: number;
+    appliedCount: number;
+    timestamp: number;
+}
+
+type EventListener<T = any> = (data: T) => void;
+/**
+ * Central EventBus for wallet and session events. Pub/sub pattern for
+ * cross-module communication within the SDK.
+ */
+declare class EventBus {
+    private listeners;
+    on<T = any>(eventType: EventName, listener: EventListener<T>): () => void;
+    off<T = any>(eventType: EventName, listener: EventListener<T>): void;
+    emit<T = any>(eventType: EventName, data: T): void;
+    once<T = any>(eventType: EventName, listener: EventListener<T>): () => void;
+    clear(eventType?: EventName): void;
+    listenerCount(eventType: EventName): number;
+}
+declare function getEventBus(): EventBus;
+
+declare const WalletEvents: {
+    emitWalletStateEvent: (data: WalletStateEvent) => void;
+    onWalletStateEvent: (listener: EventListener<WalletStateEvent>) => () => void;
+    emitSessionUpdated: (data: WalletSessionEvent) => void;
+    onSessionUpdated: (listener: EventListener<WalletSessionEvent>) => () => void;
+    emitChainChanged: (data: WalletChainChangedEvent) => void;
+    onChainChanged: (listener: EventListener<WalletChainChangedEvent>) => () => void;
+    emitDisconnected: (data: WalletDisconnectedEvent) => void;
+    onDisconnected: (listener: EventListener<WalletDisconnectedEvent>) => () => void;
+    emitWalletSessionDeleted: (data: WalletSessionDeletedEvent) => void;
+    onWalletSessionDeleted: (listener: EventListener<WalletSessionDeletedEvent>) => () => void;
+    emitWalletError: (data: WalletErrorEvent) => void;
+    onWalletError: (listener: EventListener<WalletErrorEvent>) => () => void;
+    emitSaveRestored: (data: WalletSaveRestoredEvent) => void;
+    onSaveRestored: (listener: EventListener<WalletSaveRestoredEvent>) => () => void;
+    emitSubscriptionPatchesSynced: (data: SubscriptionPatchesSyncedEvent) => void;
+    onSubscriptionPatchesSynced: (listener: EventListener<SubscriptionPatchesSyncedEvent>) => () => void;
+};
+
+declare enum Browser {
+    chromium = "chromium",
+    firefox = "firefox",
+    safari = "safari",
+    edge = "edge",
+    opera = "opera",
+    brave = "brave",
+    vivaldi = "vivaldi",
+    yandex = "yandex",
+    palemoon = "palemoon"
+}
+declare enum Platform {
+    android = "android",
+    ios = "ios",
+    browsers = "browsers"
+}
+declare const parseUserAgent: (userAgent?: string) => {
+    browser: Browser;
+    platform: Platform;
+};
+
+declare function getCachedEmail(): string | null;
+declare function setCachedEmail(email: string | null): void;
+/**
+ * Stores the private key in localStorage in plain text.
+ * @param chainId The chain/network ID
+ * @param privateKey The raw private key (with or without 0x)
+ */
+declare function storePrivateKey(chainId: string | number, privateKey: string): void;
+/**
+ * Retrieves the private key from localStorage.
+ * @param chainId The chain/network ID
+ * @returns The private key or null if not found
+ */
+declare function getPrivateKey(chainId: string | number): string | null;
+/**
+ * Checks if a private key exists in localStorage for a given chainId.
+ */
+declare function hasPrivateKey(chainId: string | number): boolean;
+/**
+ * Checks if any private key exists in localStorage.
+ */
+declare function hasAnyPrivateKey(): boolean;
+declare const storeEncryptedPrivateKey: (chainId: string | number, privateKey: string, _email?: string) => void;
+declare const getDecryptedPrivateKey: (chainId: string | number, _email?: string) => string | null;
+declare const hasEncryptedPrivateKey: (chainId: string | number) => boolean;
+
+declare class MetaMaskConnector implements EvmWalletConnector {
+    readonly type: WalletType;
+    private accountChangedCallbacks;
+    private chainChangedCallbacks;
+    private isListening;
+    private getProvider;
+    isAvailable(): boolean;
+    private setupListeners;
+    connect(): Promise<ConnectResult>;
+    getAccounts(): Promise<string[]>;
+    getChainId(): Promise<number>;
+    requestSwitchChain(chainId: number): Promise<void>;
+    sendTransaction(tx: TransactionRequest, chainId: number): Promise<string>;
+    signMessage(message: string): Promise<string>;
+    getWalletClient(chainId: number): Promise<WalletClient>;
+    onAccountChanged(cb: (address: string) => void): () => void;
+    onChainChanged(cb: (chainId: number) => void): () => void;
+    disconnect(): void;
+}
+declare function createMetaMaskConnector(): MetaMaskConnector;
+
+declare function addressFromPrivateKey(privateKey: string): string;
+declare function createPrivateKeyWalletClient(chainId: number, privateKey: string): WalletClient;
+declare class PrivateKeyConnector implements EvmWalletConnector {
+    readonly type: WalletType;
+    private activeChainId;
+    private chainChangedCallbacks;
+    isAvailable(): boolean;
+    connect(chainId?: number): Promise<ConnectResult>;
+    getAccounts(): Promise<string[]>;
+    getChainId(): Promise<number>;
+    requestSwitchChain(chainId: number): Promise<void>;
+    sendTransaction(tx: TransactionRequest, chainId: number): Promise<string>;
+    signMessage(message: string): Promise<string>;
+    getWalletClient(chainId: number): Promise<WalletClient>;
+    onAccountChanged(cb: (address: string) => void): () => void;
+    onChainChanged(cb: (chainId: number) => void): () => void;
+    disconnect(): void;
+}
+declare function createPrivateKeyConnector(): PrivateKeyConnector;
+
+interface WalletMeta {
+    readonly displayName: string;
+    readonly logoUrl: string;
+    readonly description: string;
+    readonly website: string;
+    getInstallUrl(browser?: Browser): string;
+    isInstalled(): boolean;
+    isInstallable(): boolean;
+}
+declare const walletMeta: Record<WalletType, WalletMeta>;
+
+declare function registerConnector(connector: WalletConnector): void;
+declare function getConnector(type: WalletType): WalletConnector | undefined;
+declare function getRegisteredConnectors(): WalletConnector[];
+
+export { AddressRegistryReadAPI, AddressRegistryWriteAPI, ArchivistStorageReadAPI, BouncerStorageReadAPI, Browser, type CommonWalletEvent, ConnectResult, EventBus, type EventListener, EventName, EvmChainConfig, EvmClient, EvmWalletConnector, EvmWriteClient, FactoryReadAPI, FactoryWriteAPI, FetchOptions, LibraryRegistryStorageReadAPI, LibraryRegistryStorageWriteAPI, MetaMaskConnector, Patch, Platform, PrivateKeyConnector, ProjectManagerStorageReadAPI, PublicLibraryStorageReadAPI, PublicLibraryStorageWriteAPI, ReadOnlyDomainAPI, ScientistStorageReadAPI, SessionStore, SubscriptionClient, type SubscriptionClientConfig, SubscriptionGraph, SubscriptionManagerReadAPI, SubscriptionManagerWriteAPI, SubscriptionNode, type SubscriptionPatchesSyncedEvent, SyncCursor, SyncOptions, SyncResult, TransactionOptions, WalkOptions, type WalletChainChangedEvent, WalletConnector, type WalletDisconnectedEvent, WalletError, type WalletErrorEvent, WalletEvents, type WalletMeta, type WalletSaveRestoredEvent, type WalletSessionDeletedEvent, type WalletSessionEvent, WalletState, type WalletStateEvent, WalletType, WalletUxError, Web3SessionAccount, WriteOnlyDomainAPI, addressFromPrivateKey, addressRegistryAbi, allRegisteredAccounts, createEvmClient, createMetaMaskConnector, createPrivateKeyConnector, createPrivateKeyWalletClient, createPrivateKeyWriteClient, createSessionStore, createWriteClient, cursorStore, deserializeCursor, emptyCursor, getCachedEmail, getConnector, getDecryptedPrivateKey, getEventBus, getEvmClient, getPrivateKey, getReadClient, getReadyEvmClient, getRegisteredConnectors, getSubscriptionClient, handleWriteOperationErrors, hasAnyPrivateKey, hasEncryptedPrivateKey, hasPrivateKey, hasUnsavedPatches, loadNetworkInfos, parseUserAgent, pythAbi, readOnlyClients, readOnlyStagingClients, registerConnector, resetTransactionState, restoreAccountSave, saveMyLevel, serializeCursor, sessionStore, setCachedEmail, storeEncryptedPrivateKey, storePrivateKey, syncAccount, walletMeta, writeOperations };