@the_library/public 1.0.0

package/dist/state-BTsp-E4v.d.ts

@@ -0,0 +1,111 @@
+type FilePhase$1 = 'unknown' | 'queued' | 'downloading' | 'done' | 'error';
+interface FileState$1 {
+    phase: FilePhase$1;
+    loaded?: number;
+    total?: number;
+    error?: string;
+}
+interface BookData {
+    txId: string;
+    dimensions: Array<{
+        width: number;
+        height: number;
+    }>;
+    parsed: boolean;
+}
+type WorkerCommand = {
+    type: 'GetFile';
+    txId: string;
+    mime: 'pdf' | 'preview';
+} | {
+    type: 'ProcessPages';
+    txId: string;
+    from: number;
+    to: number;
+} | {
+    type: 'CancelDownload';
+    txId: string;
+};
+type WorkerMessage = {
+    type: 'FileRpcResponse';
+    ok: boolean;
+    key: string;
+    error?: string;
+} | {
+    type: 'HYDRATE';
+    payload: HydratePayload;
+} | {
+    type: 'DownloadProgress';
+    txId: string;
+    loaded: number;
+    total?: number;
+} | {
+    type: 'DownloadFinished';
+    txId: string;
+    key: string;
+    mime: 'pdf' | 'preview';
+} | {
+    type: 'DownloadError';
+    txId: string;
+    error: string;
+    retryable: boolean;
+} | {
+    type: 'StoragePruneStarted';
+    targetFreeBytes: number;
+} | {
+    type: 'StoragePruned';
+    removed: number;
+    freedBytes: number;
+    prunedTxIds: string[];
+} | {
+    type: 'MuPageDone';
+    txId: string;
+    page: number;
+} | {
+    type: 'MuPageError';
+    txId: string;
+    page: number;
+    error: string;
+} | {
+    type: 'MuPdfData';
+    txId: string;
+    bookData: BookData;
+};
+interface HydratePayload {
+    files: Array<[txId: string, state: FileState$1]>;
+    renders: Array<[txId: string, pages: Array<[page: number, phase: FilePhase$1]>]>;
+}
+
+type FilePhase = 'unknown' | 'queued' | 'downloading' | 'done' | 'error';
+interface FileState {
+    phase: FilePhase;
+    loaded?: number;
+    total?: number;
+    error?: string;
+}
+interface RenderState {
+    bookData?: BookData;
+    pages: Map<number, FilePhase>;
+}
+interface PruningState {
+    active: boolean;
+    freedBytes: number;
+    removedCount: number;
+}
+type Listener = (changedKey: string) => void;
+declare const downloadState: {
+    readonly files: ReadonlyMap<string, FileState>;
+    readonly renders: ReadonlyMap<string, RenderState>;
+    readonly pruning: Readonly<PruningState>;
+    get(txId: string): FileState;
+    getRender(txId: string): RenderState;
+    summary(): {
+        active: number;
+        queued: number;
+        loaded: number;
+        total: number;
+    };
+    subscribe(listener: Listener): () => void;
+};
+
+export { type BookData as B, type FileState as F, type HydratePayload as H, type PruningState as P, type RenderState as R, type WorkerCommand as W, type FilePhase as a, type WorkerMessage as b, downloadState as d };

package/dist/types-Dn0EFMO_.d.ts

@@ -0,0 +1,293 @@
+import { TransactionRequest, WalletClient } from 'viem';
+
+interface ContractAddresses {
+    factory: string;
+    bouncerStorage: string;
+    scientistStorage: string;
+    backupStorage: string;
+    projectManagerStorage: string;
+    subscriptionManager?: string;
+    libraryRegistryStorage?: string;
+    publicLibraryStorage?: string;
+}
+interface StripeDonation {
+    stripePaymentId: string;
+    amountUSD: bigint;
+    username: string;
+    donor: string;
+    country: string;
+    language: string;
+    timestamp: number;
+    chainId: number | string;
+}
+interface BouncerStorageReadAPI {
+    hasAccount(address: string): Promise<boolean>;
+    userInfos(address: string): Promise<[username: string, country: string, language: string, userId: number]>;
+    userData(userId: number): Promise<[id: number, addr: string, username: string, language: string, country: string]>;
+    getUsernameByAddress(address: string): Promise<string>;
+    userIdOf(address: string): Promise<number>;
+    userIdToUsername(userId: number): Promise<string>;
+    usernameToUserId(username: string): Promise<number>;
+    userAddr(userId: number): Promise<string>;
+    getAccountCountByCountryLanguage(country: string, language: string): Promise<number>;
+    getAllLocationCounts(): Promise<any[]>;
+    getActiveLocationCount(): Promise<number>;
+    nbAccounts(): Promise<number>;
+    identityStats(): Promise<[nbVerbs: number, nbAdjectives: number]>;
+    isAuthorized(address: string): Promise<boolean>;
+    getLatestRegisteredUser(): Promise<string | null>;
+    getTokenName(): Promise<string>;
+}
+interface ArchivistStorageReadAPI {
+    userLevel(userId: number): Promise<number>;
+    isAuthorized(address: string): Promise<boolean>;
+    nbWrites(userId: number): Promise<number>;
+    loadActions(userId: number): Promise<[bigint[], bigint[], string[]]>;
+    loadActionsSince(userId: number, index: number): Promise<[bigint[], bigint[], string[]]>;
+}
+interface ScientistStorageReadAPI {
+    getLastMonthId(): Promise<number>;
+    getDeploymentDate(): Promise<[year: number, month: number]>;
+    getStatsRaw(action: number, objectType: number, monthId: number): Promise<[bigint[], number[]]>;
+    isAuthorized(address: string): Promise<boolean>;
+}
+interface ProjectManagerStorageReadAPI {
+    nbProjects(): Promise<number>;
+    getProjectSupportedLanguages(projectId: number): Promise<Array<string>>;
+    addressDonationsPerProject(address: string): Promise<Array<number>>;
+    balanceOfAddress(address: string): Promise<{
+        total: number;
+        donations: number;
+        unspent: number;
+    }>;
+    loadProject(projectId: number): Promise<{
+        id: number;
+        balance: number;
+        versions: any[];
+        availableLanguages: string[];
+    }>;
+    projectVotingBalances(projectId: number): Promise<number>;
+    getWeeklyDonations(week: number): Promise<StripeDonation[]>;
+    getDonationsRange(fromWeek: number, toWeek: number): Promise<StripeDonation[]>;
+    isAuthorized(address: string): Promise<boolean>;
+    admin(): Promise<string>;
+    getNbLanguages(projectId: number): Promise<number>;
+    getLanguageAtIndex(projectId: number, index: number): Promise<string>;
+    getNbVersions(projectId: number, lang: string): Promise<number>;
+    getVersion(projectId: number, lang: string, versionNumber: number): Promise<ProjectVersion>;
+    getVotingBalance(projectId: number, lang: string): Promise<bigint>;
+    getUserBalances(address: string): Promise<[donated: bigint, allocated: bigint, remaining: bigint]>;
+}
+interface FactoryReadAPI {
+    nbWritesByUsername(username: string): Promise<number>;
+    loadUsername(username: string): Promise<[bigint[], bigint[], string[]]>;
+    loadUsernameSince(username: string, index: number): Promise<[bigint[], bigint[], string[]]>;
+    load(): Promise<[bigint[], bigint[], string[]]>;
+    isAuthorized(address: string): Promise<boolean>;
+    owner(): Promise<string>;
+    oracleSigner(): Promise<string>;
+    bouncerStorage(): Promise<string>;
+    scientistStorage(): Promise<string>;
+    backupStorage(): Promise<string>;
+    projectManagerStorage(): Promise<string>;
+    usedPaymentIntents(paymentIntentId: string): Promise<boolean>;
+}
+interface TransactionOptions {
+    feeLimit?: number;
+    gasLimit?: bigint;
+    value?: number;
+    onAccepted?: (txId: string) => void;
+}
+interface FactoryWriteAPI {
+    register(country: string, language: string, paymentValue: number, options?: TransactionOptions): Promise<any>;
+    unregister(options?: TransactionOptions): Promise<any>;
+    save(patches: Array<bigint>, level: number, textIndex: Array<number>, text: Array<string>, options?: TransactionOptions): Promise<any>;
+    createProject(lang: string, uri: string, publicationDate: number, name: string, headline: string, arweaveAddressLogo: string, arweaveAddressBanner: string, descriptionMarkdown: string, minimumFundingBeforeStartWork: number, maximumFunding: number, tags: number[], complexity: number, options?: TransactionOptions): Promise<any>;
+    addProjectVersion(projectId: number, lang: string, publicationDate: number, uri: string, name: string, headline: string, arweaveAddressLogo: string, arweaveAddressBanner: string, descriptionMarkdown: string, minimumFundingBeforeStartWork: number, maximumFunding: number, tags: number[], status: number, complexity: number, options?: TransactionOptions): Promise<any>;
+    deleteProject(projectId: number, lang: string, options?: TransactionOptions): Promise<any>;
+    registerStripe(country: string, language: string, paymentIntentId: string, votes: bigint, signature: string, options?: TransactionOptions): Promise<any>;
+    fundStripe(paymentIntentId: string, votes: bigint, signature: string, options?: TransactionOptions): Promise<any>;
+    donateToProject(projectId: number, lang: string, amount: number, options?: TransactionOptions): Promise<any>;
+}
+interface AddressRegistryWriteAPI {
+    addData(key: string, value: string, options?: TransactionOptions): Promise<any>;
+}
+interface AddressRegistryContractRecord {
+    contractAddress: string;
+    abiUrl: string;
+}
+interface AddressRegistryUpdateInfo {
+    timestamp: number;
+    blockNumber: bigint;
+    transactionHash: string;
+}
+interface AddressRegistryReadAPI {
+    getLatestContract(name: string): Promise<[address: string, abiUrl: string]>;
+    getContractHistory(name: string): Promise<AddressRegistryContractRecord[]>;
+    getAllContractNames(): Promise<string[]>;
+    getLatestData(key: string): Promise<string>;
+    getAllDataKeys(): Promise<string[]>;
+    getLastUpdateInfo(name: string): Promise<AddressRegistryUpdateInfo | null>;
+    admin(): Promise<string>;
+}
+interface CollectionInput {
+    id: string;
+    slug: string;
+    manifestUrl: string;
+    importerUsername: string;
+    owner: string;
+    fileCount: number;
+    libraryType: number;
+    publicLibraryId: number;
+    country: string;
+    language: string;
+    isPublic: boolean;
+    initialBookCount: number;
+    dSafeBookCount: number;
+}
+interface Collection extends CollectionInput {
+    verified: boolean;
+    createdAt: number;
+    updatedAt: number;
+    importStatus: number;
+    published: boolean;
+}
+interface LibraryRegistryStorageReadAPI {
+    getUnverifiedCollectionIds(): Promise<string[]>;
+    getVerifiedCollectionIds(): Promise<string[]>;
+    getCollection(id: string): Promise<Collection>;
+}
+interface LibraryRegistryStorageWriteAPI {
+    addUnverifiedCollection(input: CollectionInput, options?: TransactionOptions): Promise<any>;
+    verifyCollection(id: string, options?: TransactionOptions): Promise<any>;
+    rejectCollection(id: string, options?: TransactionOptions): Promise<any>;
+    updateCollectionStats(id: string, initialBookCount: number, dSafeBookCount: number, options?: TransactionOptions): Promise<any>;
+    setImportStatus(id: string, status: number, options?: TransactionOptions): Promise<any>;
+    setPublished(id: string, isPublished: boolean, options?: TransactionOptions): Promise<any>;
+    setCollectionPublicLibrary(id: string, publicLibraryId: number, options?: TransactionOptions): Promise<any>;
+    setPublicLibraryStorage(storageAddr: string, options?: TransactionOptions): Promise<any>;
+}
+declare enum LibraryOwnership {
+    Public = 0,
+    Private = 1
+}
+declare enum PreferredFormat {
+    MARC21 = 0,
+    UNIMARC = 1,
+    MARCXML = 2,
+    DublinCore = 3,
+    MODS = 4,
+    BIBFRAME = 5,
+    ONIX = 6,
+    OPDS = 7,
+    InternetArchive = 8,
+    HathiTrust = 9,
+    EAD = 10,
+    Other = 11
+}
+interface PublicLibraryInput {
+    name: string;
+    physicalAddress: string;
+    country: string;
+    language: string;
+    ownership: LibraryOwnership | number;
+    website: string;
+    preferredFormat: PreferredFormat | number;
+}
+interface PublicLibrary extends PublicLibraryInput {
+    id: number;
+    createdAt: number;
+    updatedAt: number;
+}
+interface PublicLibraryStorageReadAPI {
+    libraryExists(id: number): Promise<boolean>;
+    getPublicLibrary(id: number): Promise<PublicLibrary>;
+    nbLibraries(): Promise<number>;
+}
+interface PublicLibraryStorageWriteAPI {
+    addPublicLibrary(input: PublicLibraryInput, options?: TransactionOptions): Promise<any>;
+    updatePublicLibrary(id: number, input: PublicLibraryInput, options?: TransactionOptions): Promise<any>;
+}
+interface SubscriptionManagerReadAPI {
+    getSubscriptions(userId: number): Promise<number[]>;
+    getSubscriptionCount(userId: number): Promise<bigint>;
+    isSubscribed(subscriber: number, target: number): Promise<boolean>;
+    scoreOf(userId: number): Promise<bigint>;
+}
+interface SubscriptionManagerWriteAPI {
+    subscribeTo(subscriber: number, target: number, options?: TransactionOptions): Promise<any>;
+    unsubscribeFrom(subscriber: number, target: number, options?: TransactionOptions): Promise<any>;
+}
+interface ReadOnlyDomainAPI {
+    readonly chainId: number;
+    readonly ready: Promise<void>;
+    readonly bouncerStorage: BouncerStorageReadAPI;
+    readonly scientistStorage: ScientistStorageReadAPI;
+    readonly archivistStorage: ArchivistStorageReadAPI;
+    readonly projectManagerStorage: ProjectManagerStorageReadAPI;
+    readonly factory: FactoryReadAPI;
+    readonly addressRegistry: AddressRegistryReadAPI;
+    readonly subscriptionManager: SubscriptionManagerReadAPI;
+    readonly libraryRegistryStorage: LibraryRegistryStorageReadAPI;
+    readonly publicLibraryStorage: PublicLibraryStorageReadAPI;
+    getUsdPrice(): Promise<number>;
+    getRegistryStatus(): Promise<any>;
+}
+interface WriteOnlyDomainAPI {
+    readonly factory: FactoryWriteAPI;
+    readonly subscriptionManager: SubscriptionManagerWriteAPI;
+    readonly addressRegistry: AddressRegistryWriteAPI;
+    readonly libraryRegistryStorage: LibraryRegistryStorageWriteAPI;
+    readonly publicLibraryStorage: PublicLibraryStorageWriteAPI;
+}
+interface ProjectVersion {
+    uri: string;
+    publicationDate: Date;
+    name: string;
+    headline: string;
+    descriptionMarkdown: string;
+    arweaveAddressLogo: string;
+    arweaveAddressBanner: string;
+    minimumFundingBeforeStartWork: number;
+    maximumFunding: number;
+    tags: Array<number>;
+    status: number;
+    complexity: number;
+}
+interface Project {
+    id: number;
+    balance: number;
+    availableLanguages: Array<string>;
+    versions: Array<ProjectVersion>;
+}
+type ErrorCode = 'REVERT' | 'INSUFFICIENT_FUNDS' | 'NONCE_TOO_LOW' | 'USER_REJECTED' | 'NETWORK_ERROR' | 'TIMEOUT' | 'INVALID_ARGUMENT' | 'INVALID_COMPRESSED_ACTIONS' | 'UNSUPPORTED_OPERATION' | 'SWITCH_CHAIN_ERROR' | 'SWITCH_TO_UNSUPPORTED_CHAIN' | 'NO_WALLET_CONNECTED' | 'WALLET_NOT_INSTALLED' | 'UNKNOWN';
+interface NormalizedError {
+    code: ErrorCode;
+    message: string;
+    reason?: string;
+    data?: any;
+    originalError?: any;
+}
+type WalletType = 'metamask' | 'private_key';
+interface ConnectResult {
+    address: string;
+    chainId: number;
+}
+interface WalletConnector {
+    readonly type: WalletType;
+    isAvailable(): boolean;
+    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>;
+    onAccountChanged(cb: (address: string) => void): () => void;
+    onChainChanged(cb: (chainId: number) => void): () => void;
+    disconnect(): void;
+}
+interface EvmWalletConnector extends WalletConnector {
+    getWalletClient(chainId: number): Promise<WalletClient>;
+}
+
+export { type AddressRegistryReadAPI as A, type BouncerStorageReadAPI as B, type ConnectResult as C, type EvmWalletConnector as E, type FactoryReadAPI as F, type LibraryRegistryStorageReadAPI as L, type NormalizedError as N, type ProjectVersion as P, type ReadOnlyDomainAPI as R, type ScientistStorageReadAPI as S, type TransactionOptions as T, type WalletType as W, type Project as a, type WalletConnector as b, type ArchivistStorageReadAPI as c, type ProjectManagerStorageReadAPI as d, type SubscriptionManagerReadAPI as e, type PublicLibraryStorageReadAPI as f, type WriteOnlyDomainAPI as g, type FactoryWriteAPI as h, type SubscriptionManagerWriteAPI as i, type AddressRegistryWriteAPI as j, type LibraryRegistryStorageWriteAPI as k, type PublicLibraryStorageWriteAPI as l, type ContractAddresses as m, type StripeDonation as n, type AddressRegistryContractRecord as o, type AddressRegistryUpdateInfo as p, type CollectionInput as q, type Collection as r, LibraryOwnership as s, PreferredFormat as t, type PublicLibraryInput as u, type PublicLibrary as v, type ErrorCode as w };

package/dist/types-Xb8Ta9tZ.d.ts

@@ -0,0 +1,155 @@
+import { Chain } from 'viem';
+import { W as WalletType, P as ProjectVersion, a as Project } from './types-Dn0EFMO_.js';
+
+type ChainPrice = {
+    stable: true;
+} | {
+    stable?: false;
+    pythOracle: string;
+    usdPriceId: string;
+};
+interface EvmChainConfig {
+    chainId: number;
+    name: string;
+    symbol: string;
+    shortName: string;
+    decimals: number;
+    explorer: string;
+    rpc: string;
+    website: string;
+    main: boolean;
+    logo: string;
+    price: ChainPrice;
+    addresses?: {
+        addressRegistry?: string;
+        stagingAddressRegistry?: string;
+        [contract: string]: string | undefined;
+    };
+    deployed?: boolean;
+    stagingDeployed?: boolean;
+}
+declare const EVM_CHAINS: Record<number, EvmChainConfig>;
+declare const DEFAULT_CHAIN_ID = 1116;
+declare function getChain(chainId: number | string): EvmChainConfig;
+declare function toViemChain(config: EvmChainConfig): Chain;
+
+interface Web3SessionAccount {
+    account: string;
+    username: string;
+    hasAccount: boolean;
+    userId: number;
+    lastPatchIndex: number;
+    lastRestorationIndex: number;
+    country?: string;
+    language?: string;
+    lastUpdated?: number;
+    level?: number;
+    projectBalance?: {
+        contributions: number;
+        allocated: number;
+        remaining: number;
+    };
+    donationsPerProject?: number[];
+    chainId: number;
+    wallet: WalletType;
+}
+interface SessionState {
+    active: Web3SessionAccount | null;
+    known: Web3SessionAccount[];
+}
+interface SessionStore {
+    getState(): SessionState;
+    setActive(account: Web3SessionAccount | null): void;
+    addKnown(account: Web3SessionAccount): void;
+    updateAccount(address: string, chainId: number, patch: Partial<Web3SessionAccount>): void;
+    removeAccount(address: string, chainId: number): void;
+    clearAll(): void;
+    setLastSavedPatchIndex(address: string, chainId: number, index: number): void;
+    setLastRestorationIndex(address: string, chainId: number, index: number): void;
+    lastSyncCounters(address: string, chainId: number): {
+        lastPatchIndex: number;
+        lastRestorationIndex: number;
+    };
+    updateProjectVotes(address: string, chainId: number, projectId: number, amount: number): void;
+    persist(): void;
+    load(): void;
+    subscribe(listener: () => void): () => void;
+}
+
+interface ProjectLocale {
+    id: number;
+    lang: string;
+    version: ProjectVersion;
+    balance: number;
+}
+declare const projectLocale: (project: Project, userLanguage: string, chainId: number) => ProjectLocale;
+declare const loadProjects: (chainId: number, language: string) => Promise<Array<ProjectLocale | null>>;
+declare const loadProject: (chainId: number, language: string, projectId: number, refresh?: boolean) => Promise<ProjectLocale>;
+
+interface SubscriptionNode {
+    userId: number;
+    subscriptions: number[];
+    score?: bigint;
+}
+/**
+ * A patch batch fetched from one userId's on-chain BackupStorage history
+ * (spec §15.2: reads directly from BackupStorage.loadActions/loadActionsSince —
+ * no Arweave TX resolution, per O2).
+ *
+ * `raw` decoding is deferred until the web3-sdk / models_v2 / downloader_v2
+ * bundling (spec §16) — per explicit decision, O3 stays unresolved for now and
+ * `raw` is left fully opaque (O3 Option 2). Callers that need the decoded
+ * patch content import their own models_v2 codec against
+ * `raw as { compressedActions: bigint[]; indexes: bigint[]; stringIndexes: string[] }`.
+ */
+interface Patch {
+    userId: number;
+    fromIndex: number;
+    toIndex: number;
+    raw: unknown;
+}
+interface SubscriptionGraph {
+    rootUserId: number;
+    nodes: Map<number, SubscriptionNode>;
+    truncated: boolean;
+}
+interface SyncResult {
+    patches: Patch[];
+    cursor: SyncCursor;
+    truncated: boolean;
+}
+/**
+ * Serializable — safe to persist in IndexedDB between sessions (spec §15.8).
+ * `patchIndex` replaces the original spec's arweaveTxId `Set<string>` with a
+ * per-userId last-delivered-index map, since patches are now on-chain and
+ * index-addressed (BackupStorage.loadActionsSince), not txId-addressed.
+ */
+interface SyncCursor {
+    rootUserId: number;
+    knownNodes: Map<number, SubscriptionNode>;
+    countSnapshot: Map<number, number>;
+    patchIndex: Map<number, number>;
+}
+interface WalkOptions {
+    maxNodes?: number;
+    maxDepth?: number;
+}
+interface FetchOptions {
+    concurrency?: number;
+}
+interface SyncOptions extends WalkOptions, FetchOptions {
+    cursor?: SyncCursor;
+}
+/**
+ * Carried forward from the original spec (§15.5, "unchanged") for API shape
+ * compatibility. Not wired into patch-resolver.ts today — the original
+ * motivation (avoid re-fetching immutable Arweave data by txId) doesn't map
+ * onto index-paginated on-chain reads, which are already cheap to re-issue.
+ * Left available for a future persistent cache if that changes.
+ */
+interface PatchCacheAdapter {
+    get(key: string): Promise<Patch | undefined>;
+    set(key: string, patch: Patch): Promise<void>;
+}
+
+export { type ChainPrice as C, DEFAULT_CHAIN_ID as D, type EvmChainConfig as E, type FetchOptions as F, type ProjectLocale as P, type SyncCursor as S, type Web3SessionAccount as W, type SessionStore as a, type SubscriptionNode as b, type WalkOptions as c, type SubscriptionGraph as d, type Patch as e, type SyncOptions as f, type SyncResult as g, type SessionState as h, loadProject as i, type PatchCacheAdapter as j, EVM_CHAINS as k, loadProjects as l, getChain as m, projectLocale as p, toViemChain as t };