diff --git a/components/AuthorPresentationEditor.tsx b/components/AuthorPresentationEditor.tsx
index 5213f2d..6ce2885 100644
--- a/components/AuthorPresentationEditor.tsx
+++ b/components/AuthorPresentationEditor.tsx
@@ -1,593 +1 @@
-import { useState, useCallback, useEffect, type FormEvent } from 'react'
-import { useRouter } from 'next/router'
-import { useNostrAuth } from '@/hooks/useNostrAuth'
-import { useAuthorPresentation } from '@/hooks/useAuthorPresentation'
-import { ArticleField } from './ArticleField'
-import { CreateAccountModal } from './CreateAccountModal'
-import { RecoveryStep } from './CreateAccountModalSteps'
-import { UnlockAccountModal } from './UnlockAccountModal'
-import { ImageUploadField } from './ImageUploadField'
-import { PresentationFormHeader } from './PresentationFormHeader'
-import { extractPresentationData } from '@/lib/presentationParsing'
-import type { Article } from '@/types/nostr'
-import { t } from '@/lib/i18n'
-import { userConfirm } from '@/lib/userConfirm'
-
-interface AuthorPresentationDraft {
-  authorName: string
-  presentation: string
-  contentDescription: string
-  mainnetAddress: string
-  pictureUrl?: string
-}
-
-const ADDRESS_PATTERN = /^(1|3|bc1)[a-zA-Z0-9]{25,62}$/
-
-function SuccessNotice({ pubkey }: { pubkey: string | null }): React.ReactElement {
-  return (
-    <div className="border border-neon-green/50 rounded-lg p-6 bg-neon-green/10">
-      <h3 className="text-lg font-semibold text-neon-green mb-2">{t('presentation.success')}</h3>
-      <p className="text-cyber-accent mb-4">
-        {t('presentation.successMessage')}
-      </p>
-      {pubkey && (
-        <div className="mt-4">
-          <a
-            href={`/author/${pubkey}`}
-            className="inline-block px-4 py-2 bg-neon-cyan/20 hover:bg-neon-cyan/30 text-neon-cyan rounded-lg font-medium transition-all border border-neon-cyan/50 hover:shadow-glow-cyan"
-          >
-            {t('presentation.manageSeries')}
-          </a>
-        </div>
-      )}
-    </div>
-  )
-}
-
-function ValidationError({ message }: { message: string | null }): React.ReactElement | null {
-  if (!message) {
-    return null
-  }
-  return (
-    <div className="bg-red-500/10 border border-red-500/50 rounded-lg p-3">
-      <p className="text-sm text-red-400">{message}</p>
-    </div>
-  )
-}
-
-function PresentationField({
-  draft,
-  onChange,
-}: {
-  draft: AuthorPresentationDraft
-  onChange: (next: AuthorPresentationDraft) => void
-}): React.ReactElement {
-  return (
-    <ArticleField
-      id="presentation"
-      label={t('presentation.field.presentation')}
-      value={draft.presentation}
-      onChange={(value) => onChange({ ...draft, presentation: value as string })}
-      required
-      type="textarea"
-      rows={6}
-      placeholder={t('presentation.field.presentation.placeholder')}
-      helpText={t('presentation.field.presentation.help')}
-    />
-  )
-}
-
-function ContentDescriptionField({
-  draft,
-  onChange,
-}: {
-  draft: AuthorPresentationDraft
-  onChange: (next: AuthorPresentationDraft) => void
-}): React.ReactElement {
-  return (
-    <ArticleField
-      id="contentDescription"
-      label={t('presentation.field.contentDescription')}
-      value={draft.contentDescription}
-      onChange={(value) => onChange({ ...draft, contentDescription: value as string })}
-      required
-      type="textarea"
-      rows={6}
-      placeholder={t('presentation.field.contentDescription.placeholder')}
-      helpText={t('presentation.field.contentDescription.help')}
-    />
-  )
-}
-
-function MainnetAddressField({
-  draft,
-  onChange,
-}: {
-  draft: AuthorPresentationDraft
-  onChange: (next: AuthorPresentationDraft) => void
-}): React.ReactElement {
-  return (
-    <ArticleField
-      id="mainnetAddress"
-      label={t('presentation.field.mainnetAddress')}
-      value={draft.mainnetAddress}
-      onChange={(value) => onChange({ ...draft, mainnetAddress: value as string })}
-      required
-      type="text"
-      placeholder={t('presentation.field.mainnetAddress.placeholder')}
-      helpText={t('presentation.field.mainnetAddress.help')}
-    />
-  )
-}
-
-function AuthorNameField({
-  draft,
-  onChange,
-}: {
-  draft: AuthorPresentationDraft
-  onChange: (next: AuthorPresentationDraft) => void
-}): React.ReactElement {
-  return (
-    <ArticleField
-      id="authorName"
-      label={t('presentation.field.authorName')}
-      value={draft.authorName}
-      onChange={(value) => onChange({ ...draft, authorName: value as string })}
-      required
-      type="text"
-      placeholder={t('presentation.field.authorName.placeholder')}
-      helpText={t('presentation.field.authorName.help')}
-    />
-  )
-}
-
-function PictureField({
-  draft,
-  onChange,
-}: {
-  draft: AuthorPresentationDraft
-  onChange: (next: AuthorPresentationDraft) => void
-}): React.ReactElement {
-  return (
-    <ImageUploadField
-      id="picture"
-      value={draft.pictureUrl}
-      onChange={(url) => onChange({ ...draft, pictureUrl: url })}
-    />
-  )
-}
-
-const PresentationFields = ({
-  draft,
-  onChange,
-}: {
-  draft: AuthorPresentationDraft
-  onChange: (next: AuthorPresentationDraft) => void
-}): React.ReactElement => (
-  <div className="space-y-4">
-    <AuthorNameField draft={draft} onChange={onChange} />
-    <PictureField draft={draft} onChange={onChange} />
-    <PresentationField draft={draft} onChange={onChange} />
-    <ContentDescriptionField draft={draft} onChange={onChange} />
-    <MainnetAddressField draft={draft} onChange={onChange} />
-  </div>
-)
-
-function DeleteButton({ onDelete, deleting }: { onDelete: () => void; deleting: boolean }): React.ReactElement {
-  return (
-    <button
-      type="button"
-      onClick={onDelete}
-      disabled={deleting}
-      className="px-4 py-2 bg-red-500/20 hover:bg-red-500/30 text-red-400 rounded-lg text-sm font-medium transition-all border border-red-500/50 hover:shadow-glow-red disabled:opacity-50"
-    >
-      {deleting ? t('presentation.delete.deleting') : t('presentation.delete.button')}
-    </button>
-  )
-}
-
-type PresentationFormProps = {
-  draft: AuthorPresentationDraft
-  setDraft: (next: AuthorPresentationDraft) => void
-  validationError: string | null
-  error: string | null
-  loading: boolean
-  handleSubmit: (e: FormEvent<HTMLFormElement>) => Promise<void>
-  deleting: boolean
-  handleDelete: () => void
-  hasExistingPresentation: boolean
-}
-
-function PresentationForm(props: PresentationFormProps): React.ReactElement {
-  return (
-    <form
-      onSubmit={(e: FormEvent<HTMLFormElement>) => {
-        void props.handleSubmit(e)
-      }}
-      className="border border-neon-cyan/20 rounded-lg p-6 bg-cyber-dark space-y-4"
-    >
-      <PresentationFormHeader />
-      <PresentationFields draft={props.draft} onChange={props.setDraft} />
-      <ValidationError message={props.validationError ?? props.error} />
-      <div className="flex items-center gap-4">
-        <div className="flex-1">
-          <button
-            type="submit"
-            disabled={props.loading ?? props.deleting}
-            className="w-full px-4 py-2 bg-neon-cyan/20 hover:bg-neon-cyan/30 text-neon-cyan rounded-lg font-medium transition-all border border-neon-cyan/50 hover:shadow-glow-cyan disabled:opacity-50 disabled:cursor-not-allowed"
-          >
-            {getSubmitLabel(props)}
-          </button>
-        </div>
-        {props.hasExistingPresentation && (
-          <DeleteButton onDelete={() => { void props.handleDelete() }} deleting={props.deleting} />
-        )}
-      </div>
-    </form>
-  )
-}
-
-function getSubmitLabel(params: { loading: boolean; deleting: boolean; hasExistingPresentation: boolean }): string {
-  if (params.loading || params.deleting) {
-    return t('publish.publishing')
-  }
-  return params.hasExistingPresentation ? t('presentation.update.button') : t('publish.button')
-}
-
-function useAuthorPresentationState(pubkey: string | null, existingAuthorName?: string, existingPresentation?: Article | null): {
-  draft: AuthorPresentationDraft
-  setDraft: (next: AuthorPresentationDraft) => void
-  validationError: string | null
-  error: string | null
-  loading: boolean
-  handleSubmit: (e: FormEvent<HTMLFormElement>) => Promise<void>
-  deleting: boolean
-  handleDelete: () => Promise<void>
-  success: boolean
-} {
-  const { loading, error, success, publishPresentation, deletePresentation } = useAuthorPresentation(pubkey)
-  const router = useRouter()
-  const [draft, setDraft] = useState<AuthorPresentationDraft>(() => buildInitialDraft(existingPresentation, existingAuthorName))
-  const [validationError, setValidationError] = useState<string | null>(null)
-  const [deleting, setDeleting] = useState(false)
-
-  // Update authorName when profile changes
-  useEffect(() => {
-    syncAuthorNameIntoDraft({ existingAuthorName, draftAuthorName: draft.authorName, hasExistingPresentation: Boolean(existingPresentation), setDraft })
-  }, [existingAuthorName, existingPresentation, draft.authorName])
-
-  const handleSubmit = useCallback(
-    async (e: FormEvent<HTMLFormElement>) => {
-      e.preventDefault()
-      await submitPresentationDraft({ draft, setValidationError, publishPresentation })
-    },
-    [draft, publishPresentation]
-  )
-
-  const handleDelete = useCallback(async () => {
-    await deletePresentationFlow({
-      existingPresentationId: existingPresentation?.id,
-      deletePresentation,
-      router,
-      setDeleting,
-      setValidationError,
-    })
-  }, [existingPresentation, deletePresentation, router])
-
-  return { loading, error, success, draft, setDraft, validationError, handleSubmit, deleting, handleDelete }
-}
-
-function buildInitialDraft(existingPresentation: Article | null | undefined, existingAuthorName: string | undefined): AuthorPresentationDraft {
-  if (existingPresentation) {
-    const { presentation, contentDescription } = extractPresentationData(existingPresentation)
-    const authorName = existingPresentation.title.replace(/^Présentation de /, '') ?? existingAuthorName ?? ''
-    return {
-      authorName,
-      presentation,
-      contentDescription,
-      mainnetAddress: existingPresentation.mainnetAddress ?? '',
-      ...(existingPresentation.bannerUrl ? { pictureUrl: existingPresentation.bannerUrl } : {}),
-    }
-  }
-  return {
-    authorName: existingAuthorName ?? '',
-    presentation: '',
-    contentDescription: '',
-    mainnetAddress: '',
-  }
-}
-
-function syncAuthorNameIntoDraft(params: {
-  existingAuthorName: string | undefined
-  draftAuthorName: string
-  hasExistingPresentation: boolean
-  setDraft: (updater: (prev: AuthorPresentationDraft) => AuthorPresentationDraft) => void
-}): void {
-  if (!params.existingAuthorName || params.hasExistingPresentation || params.existingAuthorName === params.draftAuthorName) {
-    return
-  }
-  params.setDraft((prev) => ({ ...prev, authorName: params.existingAuthorName as string }))
-}
-
-async function submitPresentationDraft(params: {
-  draft: AuthorPresentationDraft
-  setValidationError: (value: string | null) => void
-  publishPresentation: (draft: AuthorPresentationDraft) => Promise<void>
-}): Promise<void> {
-  const error = validatePresentationDraft(params.draft)
-  if (error) {
-    params.setValidationError(error)
-    return
-  }
-  params.setValidationError(null)
-  await params.publishPresentation(params.draft)
-}
-
-function validatePresentationDraft(draft: AuthorPresentationDraft): string | null {
-  const address = draft.mainnetAddress.trim()
-  if (!ADDRESS_PATTERN.test(address)) {
-    return t('presentation.validation.invalidAddress')
-  }
-  if (!draft.authorName.trim()) {
-    return t('presentation.validation.authorNameRequired')
-  }
-  return null
-}
-
-async function deletePresentationFlow(params: {
-  existingPresentationId: string | undefined
-  deletePresentation: (articleId: string) => Promise<void>
-  router: ReturnType<typeof useRouter>
-  setDeleting: (value: boolean) => void
-  setValidationError: (value: string | null) => void
-}): Promise<void> {
-  if (!params.existingPresentationId) {
-    return
-  }
-  const confirmed = await userConfirm(t('presentation.delete.confirm'))
-  if (!confirmed) {
-    return
-  }
-  params.setDeleting(true)
-  params.setValidationError(null)
-  try {
-    await params.deletePresentation(params.existingPresentationId)
-    await params.router.push('/')
-  } catch (e) {
-    params.setValidationError(e instanceof Error ? e.message : t('presentation.delete.error'))
-  } finally {
-    params.setDeleting(false)
-  }
-}
-
-function NoAccountActionButtons({
-  onGenerate,
-  onImport,
-}: {
-  onGenerate: () => void
-  onImport: () => void
-}): React.ReactElement {
-  return (
-    <div className="flex flex-col gap-3 w-full max-w-xs">
-      <button
-        onClick={onGenerate}
-        className="px-6 py-2 bg-neon-cyan/20 hover:bg-neon-cyan/30 text-neon-cyan rounded-lg font-medium transition-all border border-neon-cyan/50 hover:shadow-glow-cyan"
-      >
-        {t('account.create.generateButton')}
-      </button>
-      <button
-        onClick={onImport}
-        className="px-6 py-2 bg-gray-100 hover:bg-gray-200 text-gray-700 rounded-lg font-medium transition-colors"
-      >
-        {t('account.create.importButton')}
-      </button>
-    </div>
-  )
-}
-
-function NoAccountView(): React.ReactElement {
-  const [showImportModal, setShowImportModal] = useState(false)
-  const [showRecoveryStep, setShowRecoveryStep] = useState(false)
-  const [showUnlockModal, setShowUnlockModal] = useState(false)
-  const [recoveryPhrase, setRecoveryPhrase] = useState<string[]>([])
-  const [npub, setNpub] = useState('')
-  const [generating, setGenerating] = useState(false)
-  const [error, setError] = useState<string | null>(null)
-
-  const handleGenerate = (): Promise<void> => generateNoAccount({ setGenerating, setError, setRecoveryPhrase, setNpub, setShowRecoveryStep })
-  const handleRecoveryContinue = (): void => transitionToUnlock({ setShowRecoveryStep, setShowUnlockModal })
-  const handleUnlockSuccess = (): void => resetNoAccountAfterUnlock({ setShowUnlockModal, setRecoveryPhrase, setNpub })
-  const handleImportSuccess = (): void => {
-    setShowImportModal(false)
-    setShowUnlockModal(true)
-  }
-
-  return (
-    <NoAccountCard
-      error={error}
-      generating={generating}
-      onGenerate={() => { void handleGenerate() }}
-      onImport={() => setShowImportModal(true)}
-      modals={
-        <NoAccountModals
-          showImportModal={showImportModal}
-          onCloseImport={() => setShowImportModal(false)}
-          onImportSuccess={handleImportSuccess}
-          showRecoveryStep={showRecoveryStep}
-          recoveryPhrase={recoveryPhrase}
-          npub={npub}
-          onRecoveryContinue={handleRecoveryContinue}
-          showUnlockModal={showUnlockModal}
-          onUnlockSuccess={handleUnlockSuccess}
-          onCloseUnlock={() => setShowUnlockModal(false)}
-        />
-      }
-    />
-  )
-}
-
-async function generateNoAccount(params: {
-  setGenerating: (value: boolean) => void
-  setError: (value: string | null) => void
-  setRecoveryPhrase: (value: string[]) => void
-  setNpub: (value: string) => void
-  setShowRecoveryStep: (value: boolean) => void
-}): Promise<void> {
-  params.setGenerating(true)
-  params.setError(null)
-  try {
-    const { nostrAuthService } = await import('@/lib/nostrAuth')
-    const result = await nostrAuthService.createAccount()
-    params.setRecoveryPhrase(result.recoveryPhrase)
-    params.setNpub(result.npub)
-    params.setShowRecoveryStep(true)
-  } catch (e) {
-    params.setError(e instanceof Error ? e.message : t('account.create.error.failed'))
-  } finally {
-    params.setGenerating(false)
-  }
-}
-
-function transitionToUnlock(params: { setShowRecoveryStep: (value: boolean) => void; setShowUnlockModal: (value: boolean) => void }): void {
-  params.setShowRecoveryStep(false)
-  params.setShowUnlockModal(true)
-}
-
-function resetNoAccountAfterUnlock(params: {
-  setShowUnlockModal: (value: boolean) => void
-  setRecoveryPhrase: (value: string[]) => void
-  setNpub: (value: string) => void
-}): void {
-  params.setShowUnlockModal(false)
-  params.setRecoveryPhrase([])
-  params.setNpub('')
-}
-
-function NoAccountCard(params: {
-  error: string | null
-  generating: boolean
-  onGenerate: () => void
-  onImport: () => void
-  modals: React.ReactElement
-}): React.ReactElement {
-  return (
-    <div className="border border-neon-cyan/20 rounded-lg p-6 bg-cyber-dark/50">
-      <div className="flex flex-col items-center gap-4">
-        <p className="text-center text-cyber-accent mb-2">Créez un compte ou importez votre clé secrète pour commencer</p>
-        {params.error && <p className="text-sm text-red-400">{params.error}</p>}
-        <NoAccountActionButtons onGenerate={params.onGenerate} onImport={params.onImport} />
-        {params.generating && <p className="text-cyber-accent text-sm">Génération du compte...</p>}
-        {params.modals}
-      </div>
-    </div>
-  )
-}
-
-function NoAccountModals(params: {
-  showImportModal: boolean
-  onImportSuccess: () => void
-  onCloseImport: () => void
-  showRecoveryStep: boolean
-  recoveryPhrase: string[]
-  npub: string
-  onRecoveryContinue: () => void
-  showUnlockModal: boolean
-  onUnlockSuccess: () => void
-  onCloseUnlock: () => void
-}): React.ReactElement {
-  return (
-    <>
-      {params.showImportModal && <CreateAccountModal onSuccess={params.onImportSuccess} onClose={params.onCloseImport} initialStep="import" />}
-      {params.showRecoveryStep && <RecoveryStep recoveryPhrase={params.recoveryPhrase} npub={params.npub} onContinue={params.onRecoveryContinue} />}
-      {params.showUnlockModal && <UnlockAccountModal onSuccess={params.onUnlockSuccess} onClose={params.onCloseUnlock} />}
-    </>
-  )
-}
-
-function AuthorPresentationFormView(props: {
-  pubkey: string | null
-  profile: { name?: string; pubkey: string } | null
-}): React.ReactElement {
-  const { checkPresentationExists } = useAuthorPresentation(props.pubkey)
-  const presentation = useExistingPresentation({ pubkey: props.pubkey, checkPresentationExists })
-  const state = useAuthorPresentationState(props.pubkey, props.profile?.name, presentation.existingPresentation)
-
-  if (!props.pubkey) {
-    return <NoAccountView />
-  }
-  if (presentation.loadingPresentation) {
-    return <LoadingNotice />
-  }
-  if (state.success) {
-    return <SuccessNotice pubkey={props.pubkey} />
-  }
-  return (
-    <PresentationForm
-      draft={state.draft}
-      setDraft={state.setDraft}
-      validationError={state.validationError}
-      error={state.error}
-      loading={state.loading}
-      handleSubmit={state.handleSubmit}
-      deleting={state.deleting}
-      handleDelete={() => { void state.handleDelete() }}
-      hasExistingPresentation={presentation.existingPresentation !== null}
-    />
-  )
-}
-
-function LoadingNotice(): React.ReactElement {
-  return (
-    <div className="text-center py-12">
-      <p className="text-cyber-accent/70">{t('common.loading')}</p>
-    </div>
-  )
-}
-
-function useExistingPresentation(params: {
-  pubkey: string | null
-  checkPresentationExists: () => Promise<Article | null>
-}): { existingPresentation: Article | null; loadingPresentation: boolean } {
-  const [existingPresentation, setExistingPresentation] = useState<Article | null>(null)
-  const [loadingPresentation, setLoadingPresentation] = useState(true)
-  const { pubkey, checkPresentationExists } = params
-
-  useEffect(() => {
-    void loadExistingPresentation({ pubkey, checkPresentationExists, setExistingPresentation, setLoadingPresentation })
-  }, [pubkey, checkPresentationExists])
-
-  return { existingPresentation, loadingPresentation }
-}
-
-async function loadExistingPresentation(params: {
-  pubkey: string | null
-  checkPresentationExists: () => Promise<Article | null>
-  setExistingPresentation: (value: Article | null) => void
-  setLoadingPresentation: (value: boolean) => void
-}): Promise<void> {
-  if (!params.pubkey) {
-    params.setLoadingPresentation(false)
-    return
-  }
-  try {
-    params.setExistingPresentation(await params.checkPresentationExists())
-  } catch (e) {
-    console.error('Error loading presentation:', e)
-  } finally {
-    params.setLoadingPresentation(false)
-  }
-}
-
-function useAutoLoadPubkey(accountExists: boolean | null, pubkey: string | null, connect: () => Promise<void>): void {
-  useEffect(() => {
-    if (accountExists === true && !pubkey) {
-      void connect()
-    }
-  }, [accountExists, pubkey, connect])
-}
-
-export function AuthorPresentationEditor(): React.ReactElement {
-  const { pubkey, profile, accountExists, connect } = useNostrAuth()
-  useAutoLoadPubkey(accountExists, pubkey ?? null, connect)
-  return <AuthorPresentationFormView pubkey={pubkey ?? null} profile={profile} />
-}
+export { AuthorPresentationEditor } from './authorPresentationEditor/AuthorPresentationEditor'
diff --git a/components/KeyManagementManager.tsx b/components/KeyManagementManager.tsx
index e2b6c6a..ed62ef0 100644
--- a/components/KeyManagementManager.tsx
+++ b/components/KeyManagementManager.tsx
@@ -1,559 +1 @@
-import { useState, useEffect } from 'react'
-import { nostrAuthService } from '@/lib/nostrAuth'
-import { keyManagementService } from '@/lib/keyManagement'
-import { nip19 } from 'nostr-tools'
-import { t } from '@/lib/i18n'
-import { SyncProgressBar } from './SyncProgressBar'
-
-interface PublicKeys {
-  publicKey: string
-  npub: string
-}
-
-export function KeyManagementManager(): React.ReactElement {
-  const [publicKeys, setPublicKeys] = useState<PublicKeys | null>(null)
-  const [accountExists, setAccountExists] = useState(false)
-  const [loading, setLoading] = useState(true)
-  const [error, setError] = useState<string | null>(null)
-  const [importKey, setImportKey] = useState('')
-  const [importing, setImporting] = useState(false)
-  const [showImportForm, setShowImportForm] = useState(false)
-  const [showReplaceWarning, setShowReplaceWarning] = useState(false)
-  const [recoveryPhrase, setRecoveryPhrase] = useState<string[] | null>(null)
-  const [newNpub, setNewNpub] = useState<string | null>(null)
-  const [copiedNpub, setCopiedNpub] = useState(false)
-  const [copiedPublicKey, setCopiedPublicKey] = useState(false)
-  const [copiedRecoveryPhrase, setCopiedRecoveryPhrase] = useState(false)
-
-  useEffect(() => {
-    void loadKeys()
-  }, [])
-
-  async function loadKeys(): Promise<void> {
-    try {
-      setLoading(true)
-      setError(null)
-      const exists = await nostrAuthService.accountExists()
-      setAccountExists(exists)
-
-      if (exists) {
-        const keys = await keyManagementService.getPublicKeys()
-        if (keys) {
-          setPublicKeys(keys)
-        }
-      }
-    } catch (e) {
-      const errorMessage = e instanceof Error ? e.message : t('settings.keyManagement.loading')
-      setError(errorMessage)
-      console.error('Error loading keys:', e)
-    } finally {
-      setLoading(false)
-    }
-  }
-
-  function extractKeyFromUrl(url: string): string | null {
-    try {
-      // Try to parse as URL
-      const urlObj = new URL(url)
-      // Check if it's a nostr:// URL with nsec
-      if (urlObj.protocol === 'nostr:' || urlObj.protocol === 'nostr://') {
-        const path = urlObj.pathname ?? urlObj.href.replace(/^nostr:?\/\//, '')
-        if (path.startsWith('nsec')) {
-          return path
-        }
-      }
-      // Check if URL contains nsec
-      const nsecMatch = url.match(/nsec1[a-z0-9]+/i)
-      if (nsecMatch) {
-        return nsecMatch[0]
-      }
-      return null
-    } catch {
-      return extractKeyFromText(url)
-    }
-  }
-
-  function extractKeyFromText(text: string): string {
-    const nsec = extractNsec(text)
-    if (nsec) {
-      return nsec
-    }
-    return text.trim()
-  }
-
-  function extractNsec(text: string): string | null {
-    const nsecMatch = text.match(/nsec1[a-z0-9]+/i)
-    return nsecMatch?.[0] ?? null
-  }
-
-  function isValidPrivateKeyFormat(key: string): boolean {
-    try {
-      const decoded = nip19.decode(key)
-      if (decoded.type !== 'nsec') {
-        return false
-      }
-      return typeof decoded.data === 'string' || decoded.data instanceof Uint8Array
-    } catch {
-      return /^[0-9a-f]{64}$/i.test(key)
-    }
-  }
-
-  async function handleImport(): Promise<void> {
-    if (!importKey.trim()) {
-      setError(t('settings.keyManagement.import.error.required'))
-      return
-    }
-
-    // Extract key from URL or text
-    const extractedKey = extractKeyFromUrl(importKey.trim())
-    if (!extractedKey) {
-      setError(t('settings.keyManagement.import.error.invalid'))
-      return
-    }
-
-    // Validate key format
-    if (!isValidPrivateKeyFormat(extractedKey)) {
-      setError(t('settings.keyManagement.import.error.invalid'))
-      return
-    }
-
-    // If account exists, show warning
-    if (accountExists) {
-      setShowReplaceWarning(true)
-      return
-    }
-
-    await performImport(extractedKey)
-  }
-
-  async function performImport(key: string): Promise<void> {
-    try {
-      setImporting(true)
-      setError(null)
-      setShowReplaceWarning(false)
-
-      // If account exists, delete it first
-      if (accountExists) {
-        await nostrAuthService.deleteAccount()
-      }
-
-      // Create new account with imported key
-      const result = await nostrAuthService.createAccount(key)
-      setRecoveryPhrase(result.recoveryPhrase)
-      setNewNpub(result.npub)
-      setImportKey('')
-      setShowImportForm(false)
-      await loadKeys()
-
-      // Sync user content via Service Worker
-      if (result.publicKey) {
-        const { swClient } = await import('@/lib/swClient')
-        const isReady = await swClient.isReady()
-        if (isReady) {
-          void swClient.startUserSync(result.publicKey)
-        }
-      }
-    } catch (e) {
-      const errorMessage = e instanceof Error ? e.message : t('settings.keyManagement.import.error.failed')
-      setError(errorMessage)
-      console.error('Error importing key:', e)
-    } finally {
-      setImporting(false)
-    }
-  }
-
-  async function handleCopyRecoveryPhrase(): Promise<void> {
-    if (!recoveryPhrase) {
-      return
-    }
-    try {
-      await navigator.clipboard.writeText(recoveryPhrase.join(' '))
-      setCopiedRecoveryPhrase(true)
-      setTimeout(() => {
-        setCopiedRecoveryPhrase(false)
-      }, 2000)
-    } catch (e) {
-      console.error('Error copying recovery phrase:', e)
-    }
-  }
-
-  async function handleCopyNpub(): Promise<void> {
-    if (!publicKeys?.npub) {
-      return
-    }
-    try {
-      await navigator.clipboard.writeText(publicKeys.npub)
-      setCopiedNpub(true)
-      setTimeout(() => {
-        setCopiedNpub(false)
-      }, 2000)
-    } catch (e) {
-      console.error('Error copying npub:', e)
-    }
-  }
-
-  async function handleCopyPublicKey(): Promise<void> {
-    if (!publicKeys?.publicKey) {
-      return
-    }
-    try {
-      await navigator.clipboard.writeText(publicKeys.publicKey)
-      setCopiedPublicKey(true)
-      setTimeout(() => {
-        setCopiedPublicKey(false)
-      }, 2000)
-    } catch (e) {
-      console.error('Error copying public key:', e)
-    }
-  }
-
-  if (loading) {
-    return (
-      <div className="bg-cyber-darker border border-neon-cyan/30 rounded-lg p-6">
-        <p className="text-cyber-accent">{t('settings.keyManagement.loading')}</p>
-      </div>
-    )
-  }
-
-  return (
-    <div className="space-y-6">
-      <div className="bg-cyber-darker border border-neon-cyan/30 rounded-lg p-6">
-        <h2 className="text-2xl font-bold text-neon-cyan mb-4">{t('settings.keyManagement.title')}</h2>
-
-        <KeyManagementErrorBanner error={error} />
-
-        <KeyManagementPublicKeysPanel
-          publicKeys={publicKeys}
-          copiedNpub={copiedNpub}
-          copiedPublicKey={copiedPublicKey}
-          onCopyNpub={handleCopyNpub}
-          onCopyPublicKey={handleCopyPublicKey}
-        />
-
-        {/* Sync Progress Bar - Always show if connected, even if publicKeys not loaded yet */}
-        <SyncProgressBar />
-
-        <KeyManagementNoAccountBanner publicKeys={publicKeys} accountExists={accountExists} />
-
-        <KeyManagementImportButton
-          accountExists={accountExists}
-          showImportForm={showImportForm}
-          onClick={() => {
-            setShowImportForm(true)
-            setError(null)
-          }}
-        />
-
-        <KeyManagementImportForm
-          accountExists={accountExists}
-          showImportForm={showImportForm}
-          showReplaceWarning={showReplaceWarning}
-          importing={importing}
-          importKey={importKey}
-          onChangeImportKey={(value) => {
-            setImportKey(value)
-            setError(null)
-          }}
-          onCancel={() => {
-            setShowImportForm(false)
-            setImportKey('')
-            setError(null)
-          }}
-          onImport={() => {
-            void handleImport()
-          }}
-          onDismissReplaceWarning={() => {
-            setShowReplaceWarning(false)
-          }}
-          onConfirmReplace={() => {
-            void performImport(extractKeyFromUrl(importKey.trim()) ?? importKey.trim())
-          }}
-        />
-
-        {/* Recovery Phrase Display (after import) */}
-        <KeyManagementRecoveryPanel
-          recoveryPhrase={recoveryPhrase}
-          newNpub={newNpub}
-          copiedRecoveryPhrase={copiedRecoveryPhrase}
-          onCopyRecoveryPhrase={handleCopyRecoveryPhrase}
-          onDone={() => {
-            setRecoveryPhrase(null)
-            setNewNpub(null)
-            void loadKeys()
-          }}
-        />
-      </div>
-    </div>
-  )
-}
-
-function KeyManagementErrorBanner(params: { error: string | null }): React.ReactElement | null {
-  if (!params.error) {
-    return null
-  }
-  return (
-    <div className="bg-red-900/20 border border-red-400/50 rounded-lg p-4 mb-4">
-      <p className="text-red-400">{params.error}</p>
-    </div>
-  )
-}
-
-function KeyManagementPublicKeysPanel(params: {
-  publicKeys: PublicKeys | null
-  copiedNpub: boolean
-  copiedPublicKey: boolean
-  onCopyNpub: () => Promise<void>
-  onCopyPublicKey: () => Promise<void>
-}): React.ReactElement | null {
-  if (!params.publicKeys) {
-    return null
-  }
-  return (
-    <div className="space-y-4 mb-6">
-      <KeyManagementKeyCard
-        label={t('settings.keyManagement.publicKey.npub')}
-        value={params.publicKeys.npub}
-        copied={params.copiedNpub}
-        onCopy={params.onCopyNpub}
-      />
-      <KeyManagementKeyCard
-        label={t('settings.keyManagement.publicKey.hex')}
-        value={params.publicKeys.publicKey}
-        copied={params.copiedPublicKey}
-        onCopy={params.onCopyPublicKey}
-      />
-    </div>
-  )
-}
-
-function KeyManagementKeyCard(params: {
-  label: string
-  value: string
-  copied: boolean
-  onCopy: () => Promise<void>
-}): React.ReactElement {
-  return (
-    <div className="bg-neon-blue/10 border border-neon-blue/30 rounded-lg p-4">
-      <div className="flex justify-between items-start mb-2">
-        <p className="text-neon-blue font-semibold">{params.label}</p>
-        <button
-          onClick={() => {
-            void params.onCopy()
-          }}
-          className="px-3 py-1 text-xs bg-cyber-light border border-neon-cyan/30 hover:border-neon-cyan/50 hover:bg-cyber-dark text-cyber-accent hover:text-neon-cyan rounded transition-colors"
-        >
-          {params.copied ? t('settings.keyManagement.copied') : t('settings.keyManagement.copy')}
-        </button>
-      </div>
-      <p className="text-neon-cyan text-sm font-mono break-all">{params.value}</p>
-    </div>
-  )
-}
-
-function KeyManagementNoAccountBanner(params: {
-  publicKeys: PublicKeys | null
-  accountExists: boolean
-}): React.ReactElement | null {
-  if (params.publicKeys || params.accountExists) {
-    return null
-  }
-  return (
-    <div className="bg-yellow-900/20 border border-yellow-400/50 rounded-lg p-4 mb-6">
-      <p className="text-yellow-400 font-semibold mb-2">{t('settings.keyManagement.noAccount.title')}</p>
-      <p className="text-yellow-300/90 text-sm">{t('settings.keyManagement.noAccount.description')}</p>
-    </div>
-  )
-}
-
-function KeyManagementImportButton(params: {
-  accountExists: boolean
-  showImportForm: boolean
-  onClick: () => void
-}): React.ReactElement | null {
-  if (params.showImportForm) {
-    return null
-  }
-  return (
-    <button
-      onClick={params.onClick}
-      className="w-full py-3 px-6 bg-neon-cyan/20 hover:bg-neon-cyan/30 text-neon-cyan rounded-lg font-medium transition-all border border-neon-cyan/50 hover:shadow-glow-cyan"
-    >
-      {params.accountExists ? t('settings.keyManagement.import.button.replace') : t('settings.keyManagement.import.button.new')}
-    </button>
-  )
-}
-
-function KeyManagementImportForm(params: {
-  accountExists: boolean
-  showImportForm: boolean
-  showReplaceWarning: boolean
-  importing: boolean
-  importKey: string
-  onChangeImportKey: (value: string) => void
-  onCancel: () => void
-  onImport: () => void
-  onDismissReplaceWarning: () => void
-  onConfirmReplace: () => void
-}): React.ReactElement | null {
-  if (!params.showImportForm) {
-    return null
-  }
-  return (
-    <div className="space-y-4">
-      <div className="bg-yellow-900/20 border border-yellow-400/50 rounded-lg p-4">
-        <p className="text-yellow-400 font-semibold mb-2">{t('settings.keyManagement.import.warning.title')}</p>
-        <p className="text-yellow-300/90 text-sm" dangerouslySetInnerHTML={{ __html: t('settings.keyManagement.import.warning.description') }} />
-        {params.accountExists && (
-          <p className="text-yellow-300/90 text-sm mt-2" dangerouslySetInnerHTML={{ __html: t('settings.keyManagement.import.warning.replace') }} />
-        )}
-      </div>
-
-      <div>
-        <label htmlFor="importKey" className="block text-sm font-medium text-cyber-accent mb-2">
-          {t('settings.keyManagement.import.label')}
-        </label>
-        <textarea
-          id="importKey"
-          value={params.importKey}
-          onChange={(e) => {
-            params.onChangeImportKey(e.target.value)
-          }}
-          placeholder={t('settings.keyManagement.import.placeholder')}
-          className="w-full px-3 py-2 bg-cyber-dark border border-neon-cyan/30 rounded-lg font-mono text-sm text-neon-cyan focus:border-neon-cyan focus:outline-none"
-          rows={4}
-        />
-        <p className="text-sm text-cyber-accent/70 mt-2">{t('settings.keyManagement.import.help')}</p>
-      </div>
-
-      <KeyManagementReplaceWarning
-        show={params.showReplaceWarning}
-        importing={params.importing}
-        onCancel={params.onDismissReplaceWarning}
-        onConfirm={params.onConfirmReplace}
-      />
-
-      <KeyManagementImportFormActions
-        show={!params.showReplaceWarning}
-        importing={params.importing}
-        onCancel={params.onCancel}
-        onImport={params.onImport}
-      />
-    </div>
-  )
-}
-
-function KeyManagementReplaceWarning(params: {
-  show: boolean
-  importing: boolean
-  onCancel: () => void
-  onConfirm: () => void
-}): React.ReactElement | null {
-  if (!params.show) {
-    return null
-  }
-  return (
-    <div className="bg-red-900/20 border border-red-400/50 rounded-lg p-4">
-      <p className="text-red-400 font-semibold mb-2">{t('settings.keyManagement.replace.warning.title')}</p>
-      <p className="text-red-300/90 text-sm mb-4">{t('settings.keyManagement.replace.warning.description')}</p>
-      <div className="flex gap-4">
-        <button
-          onClick={params.onCancel}
-          className="flex-1 py-2 px-4 bg-cyber-light border border-neon-cyan/30 hover:border-neon-cyan/50 hover:bg-cyber-dark text-cyber-accent hover:text-neon-cyan rounded-lg font-medium transition-colors"
-        >
-          {t('settings.keyManagement.replace.cancel')}
-        </button>
-        <button
-          onClick={params.onConfirm}
-          disabled={params.importing}
-          className="flex-1 py-2 px-4 bg-red-600/20 hover:bg-red-600/30 text-red-400 rounded-lg font-medium transition-all border border-red-400/50 hover:shadow-glow-red disabled:opacity-50"
-        >
-          {params.importing ? t('settings.keyManagement.replace.replacing') : t('settings.keyManagement.replace.confirm')}
-        </button>
-      </div>
-    </div>
-  )
-}
-
-function KeyManagementImportFormActions(params: {
-  show: boolean
-  importing: boolean
-  onCancel: () => void
-  onImport: () => void
-}): React.ReactElement | null {
-  if (!params.show) {
-    return null
-  }
-  return (
-    <div className="flex gap-4">
-      <button
-        onClick={params.onCancel}
-        className="flex-1 py-2 px-4 bg-cyber-light border border-neon-cyan/30 hover:border-neon-cyan/50 hover:bg-cyber-dark text-cyber-accent hover:text-neon-cyan rounded-lg font-medium transition-colors"
-      >
-        {t('settings.keyManagement.import.cancel')}
-      </button>
-      <button
-        onClick={params.onImport}
-        disabled={params.importing}
-        className="flex-1 py-2 px-4 bg-neon-cyan/20 hover:bg-neon-cyan/30 text-neon-cyan rounded-lg font-medium transition-all border border-neon-cyan/50 hover:shadow-glow-cyan disabled:opacity-50"
-      >
-        {params.importing ? t('settings.keyManagement.import.importing') : t('settings.keyManagement.import.import')}
-      </button>
-    </div>
-  )
-}
-
-function KeyManagementRecoveryPanel(params: {
-  recoveryPhrase: string[] | null
-  newNpub: string | null
-  copiedRecoveryPhrase: boolean
-  onCopyRecoveryPhrase: () => Promise<void>
-  onDone: () => void
-}): React.ReactElement | null {
-  if (!params.recoveryPhrase || !params.newNpub) {
-    return null
-  }
-  return (
-    <div className="mt-6 space-y-4">
-      <div className="bg-yellow-900/20 border border-yellow-400/50 rounded-lg p-4">
-        <p className="text-yellow-400 font-semibold mb-2">{t('settings.keyManagement.recovery.warning.title')}</p>
-        <p className="text-yellow-300/90 text-sm" dangerouslySetInnerHTML={{ __html: t('settings.keyManagement.recovery.warning.part1') }} />
-        <p className="text-yellow-300/90 text-sm mt-2" dangerouslySetInnerHTML={{ __html: t('settings.keyManagement.recovery.warning.part2') }} />
-        <p className="text-yellow-300/90 text-sm mt-2">{t('settings.keyManagement.recovery.warning.part3')}</p>
-      </div>
-
-      <div className="bg-cyber-darker border border-neon-cyan/30 rounded-lg p-6">
-        <div className="grid grid-cols-2 gap-4 mb-4">
-          {params.recoveryPhrase.map((word, index) => (
-            <div
-              key={`recovery-word-${index}-${word}`}
-              className="bg-cyber-dark border border-neon-cyan/30 rounded-lg p-3 text-center font-mono text-lg"
-            >
-              <span className="text-cyber-accent/70 text-sm mr-2">{index + 1}.</span>
-              <span className="font-semibold text-neon-cyan">{word}</span>
-            </div>
-          ))}
-        </div>
-        <button
-          onClick={() => {
-            void params.onCopyRecoveryPhrase()
-          }}
-          className="w-full py-2 px-4 bg-cyber-light border border-neon-cyan/30 hover:border-neon-cyan/50 hover:bg-cyber-dark text-cyber-accent hover:text-neon-cyan rounded-lg text-sm font-medium transition-colors"
-        >
-          {params.copiedRecoveryPhrase ? t('settings.keyManagement.recovery.copied') : t('settings.keyManagement.recovery.copy')}
-        </button>
-      </div>
-
-      <div className="bg-neon-blue/10 border border-neon-blue/30 rounded-lg p-4">
-        <p className="text-neon-blue font-semibold mb-2">{t('settings.keyManagement.recovery.newNpub')}</p>
-        <p className="text-neon-cyan text-sm font-mono break-all">{params.newNpub}</p>
-      </div>
-
-      <button
-        onClick={params.onDone}
-        className="w-full py-2 px-4 bg-neon-cyan/20 hover:bg-neon-cyan/30 text-neon-cyan rounded-lg font-medium transition-all border border-neon-cyan/50 hover:shadow-glow-cyan"
-      >
-        {t('settings.keyManagement.recovery.done')}
-      </button>
-    </div>
-  )
-}
+export { KeyManagementManager } from './keyManagement/KeyManagementManager'
diff --git a/components/MarkdownEditorTwoColumns.tsx b/components/MarkdownEditorTwoColumns.tsx
index 102b9e1..e513605 100644
--- a/components/MarkdownEditorTwoColumns.tsx
+++ b/components/MarkdownEditorTwoColumns.tsx
@@ -1,379 +1 @@
-import { useState } from 'react'
-import type { MediaRef, Page } from '@/types/nostr'
-import { uploadNip95Media } from '@/lib/nip95'
-import { t } from '@/lib/i18n'
-
-interface MarkdownEditorTwoColumnsProps {
-  value: string
-  onChange: (value: string) => void
-  pages?: Page[]
-  onPagesChange?: (pages: Page[]) => void
-  onMediaAdd?: (media: MediaRef) => void
-  onBannerChange?: (url: string) => void
-}
-
-export function MarkdownEditorTwoColumns(props: MarkdownEditorTwoColumnsProps): React.ReactElement {
-  const [uploading, setUploading] = useState(false)
-  const [error, setError] = useState<string | null>(null)
-
-  const pages = props.pages ?? []
-  const pagesHandlers = createPagesHandlers({ pages, onPagesChange: props.onPagesChange })
-  const handleImageUpload = createImageUploadHandler({
-    setError,
-    setUploading,
-    onMediaAdd: props.onMediaAdd,
-    onBannerChange: props.onBannerChange,
-    onSetPageImageUrl: pagesHandlers.setPageContent,
-  })
-
-  return (
-    <div className="space-y-4">
-      <MarkdownToolbar
-        onFileSelected={(file) => {
-          void handleImageUpload({ file })
-        }}
-        uploading={uploading}
-        error={error}
-        {...(props.onPagesChange ? { onAddPage: pagesHandlers.addPage } : {})}
-      />
-      <div className="grid grid-cols-2 gap-4">
-        <EditorColumn value={props.value} onChange={props.onChange} />
-        <PreviewColumn value={props.value} />
-      </div>
-      {props.onPagesChange && (
-        <PagesManager
-          pages={pages}
-          onPageContentChange={pagesHandlers.setPageContent}
-          onPageTypeChange={pagesHandlers.setPageType}
-          onRemovePage={pagesHandlers.removePage}
-          onImageUpload={async (file, pageNumber) => {
-            await handleImageUpload({ file, pageNumber })
-          }}
-        />
-      )}
-    </div>
-  )
-}
-
-function MarkdownToolbar({
-  onFileSelected,
-  uploading,
-  error,
-  onAddPage,
-}: {
-  onFileSelected: (file: File) => void
-  uploading: boolean
-  error: string | null
-  onAddPage?: (type: 'markdown' | 'image') => void
-}): React.ReactElement {
-  return (
-    <div className="flex items-center gap-2 flex-wrap">
-      <ToolbarUploadButton onFileSelected={onFileSelected} />
-      <ToolbarAddPageButtons onAddPage={onAddPage} />
-      <ToolbarStatus uploading={uploading} error={error} />
-    </div>
-  )
-}
-
-function MarkdownPreview({ value }: { value: string }): React.ReactElement {
-  return (
-    <div className="prose max-w-none border rounded p-3 bg-white h-96 overflow-y-auto whitespace-pre-wrap">
-      {value || <span className="text-gray-400">{t('markdown.preview.empty')}</span>}
-    </div>
-  )
-}
-
-function PagesManager({
-  pages,
-  onPageContentChange,
-  onPageTypeChange,
-  onRemovePage,
-  onImageUpload,
-}: {
-  pages: Page[]
-  onPageContentChange: (pageNumber: number, content: string) => void
-  onPageTypeChange: (pageNumber: number, type: 'markdown' | 'image') => void
-  onRemovePage: (pageNumber: number) => void
-  onImageUpload: (file: File, pageNumber: number) => Promise<void>
-}): React.ReactElement {
-  if (pages.length === 0) {
-    return <div className="text-sm text-gray-500">{t('page.empty')}</div>
-  }
-
-  return (
-    <div className="space-y-4">
-      <h3 className="text-lg font-semibold">{t('page.title')}</h3>
-      {pages.map((page) => (
-        <PageEditor
-          key={page.number}
-          page={page}
-          onContentChange={(content) => onPageContentChange(page.number, content)}
-          onTypeChange={(type) => onPageTypeChange(page.number, type)}
-          onRemove={() => onRemovePage(page.number)}
-          onImageUpload={async (file) => {
-            await onImageUpload(file, page.number)
-          }}
-        />
-      ))}
-    </div>
-  )
-}
-
-function PageEditor({
-  page,
-  onContentChange,
-  onTypeChange,
-  onRemove,
-  onImageUpload,
-}: {
-  page: Page
-  onContentChange: (content: string) => void
-  onTypeChange: (type: 'markdown' | 'image') => void
-  onRemove: () => void
-  onImageUpload: (file: File) => Promise<void>
-}): React.ReactElement {
-  return (
-    <div className="border rounded-lg p-4 space-y-3">
-      <PageEditorHeader page={page} onTypeChange={onTypeChange} onRemove={onRemove} />
-      <PageEditorBody page={page} onContentChange={onContentChange} onImageUpload={onImageUpload} />
-    </div>
-  )
-}
-
-function EditorColumn(params: { value: string; onChange: (value: string) => void }): React.ReactElement {
-  return (
-    <div className="space-y-2">
-      <label className="block text-sm font-semibold text-gray-800">{t('markdown.editor')}</label>
-      <textarea
-        className="w-full border rounded p-3 h-96 font-mono text-sm"
-        value={params.value}
-        onChange={(e) => params.onChange(e.target.value)}
-        placeholder={t('markdown.placeholder')}
-      />
-    </div>
-  )
-}
-
-function PreviewColumn(params: { value: string }): React.ReactElement {
-  return (
-    <div className="space-y-2">
-      <label className="block text-sm font-semibold text-gray-800">{t('markdown.preview')}</label>
-      <MarkdownPreview value={params.value} />
-    </div>
-  )
-}
-
-function ToolbarUploadButton(params: { onFileSelected: (file: File) => void }): React.ReactElement {
-  return (
-    <label className="px-3 py-1 text-sm rounded bg-blue-600 text-white cursor-pointer hover:bg-blue-700">
-      {t('markdown.upload.media')}
-      <input
-        type="file"
-        accept=".png,.jpg,.jpeg,.webp"
-        className="hidden"
-        onChange={(e) => {
-          const file = e.target.files?.[0]
-          if (file) {
-            params.onFileSelected(file)
-          }
-        }}
-      />
-    </label>
-  )
-}
-
-function ToolbarAddPageButtons(params: { onAddPage: ((type: 'markdown' | 'image') => void) | undefined }): React.ReactElement | null {
-  if (!params.onAddPage) {
-    return null
-  }
-  return (
-    <>
-      <button
-        type="button"
-        className="px-3 py-1 text-sm rounded bg-green-600 text-white hover:bg-green-700"
-        onClick={() => params.onAddPage?.('markdown')}
-      >
-        {t('page.add.markdown')}
-      </button>
-      <button
-        type="button"
-        className="px-3 py-1 text-sm rounded bg-purple-600 text-white hover:bg-purple-700"
-        onClick={() => params.onAddPage?.('image')}
-      >
-        {t('page.add.image')}
-      </button>
-    </>
-  )
-}
-
-function ToolbarStatus(params: { uploading: boolean; error: string | null }): React.ReactElement | null {
-  if (!params.uploading && !params.error) {
-    return null
-  }
-  return (
-    <>
-      {params.uploading ? <span className="text-sm text-gray-500">{t('markdown.upload.uploading')}</span> : null}
-      {params.error ? <span className="text-sm text-red-600">{params.error}</span> : null}
-    </>
-  )
-}
-
-function PageEditorHeader(params: {
-  page: Page
-  onTypeChange: (type: 'markdown' | 'image') => void
-  onRemove: () => void
-}): React.ReactElement {
-  return (
-    <div className="flex items-center justify-between">
-      <h4 className="font-semibold">
-        {t('page.number', { number: params.page.number })} - {t(`page.type.${params.page.type}`)}
-      </h4>
-      <div className="flex items-center gap-2">
-        <select
-          value={params.page.type}
-          onChange={(e) => params.onTypeChange(e.target.value as 'markdown' | 'image')}
-          className="text-sm border rounded px-2 py-1"
-        >
-          <option value="markdown">{t('page.type.markdown')}</option>
-          <option value="image">{t('page.type.image')}</option>
-        </select>
-        <button
-          type="button"
-          className="px-2 py-1 text-sm rounded bg-red-600 text-white hover:bg-red-700"
-          onClick={params.onRemove}
-        >
-          {t('page.remove')}
-        </button>
-      </div>
-    </div>
-  )
-}
-
-function PageEditorBody(params: {
-  page: Page
-  onContentChange: (content: string) => void
-  onImageUpload: (file: File) => Promise<void>
-}): React.ReactElement {
-  if (params.page.type === 'markdown') {
-    return (
-      <textarea
-        className="w-full border rounded p-2 h-48 font-mono text-sm"
-        value={params.page.content}
-        onChange={(e) => params.onContentChange(e.target.value)}
-        placeholder={t('page.markdown.placeholder')}
-      />
-    )
-  }
-
-  return <PageEditorImageBody page={params.page} onContentChange={params.onContentChange} onImageUpload={params.onImageUpload} />
-}
-
-function PageEditorImageBody(params: {
-  page: Page
-  onContentChange: (content: string) => void
-  onImageUpload: (file: File) => Promise<void>
-}): React.ReactElement {
-  return (
-    <div className="space-y-2">
-      {params.page.content ? (
-        <div className="relative">
-          <img src={params.page.content} alt={t('page.image.alt', { number: params.page.number })} className="max-w-full h-auto rounded" />
-          <button
-            type="button"
-            className="absolute top-2 right-2 px-2 py-1 text-sm rounded bg-red-600 text-white hover:bg-red-700"
-            onClick={() => params.onContentChange('')}
-          >
-            {t('page.image.remove')}
-          </button>
-        </div>
-      ) : (
-        <PageImageUploadButton onFileSelected={params.onImageUpload} />
-      )}
-    </div>
-  )
-}
-
-function PageImageUploadButton(params: { onFileSelected: (file: File) => Promise<void> }): React.ReactElement {
-  return (
-    <label className="block px-3 py-2 text-sm rounded bg-blue-600 text-white cursor-pointer hover:bg-blue-700 text-center">
-      {t('page.image.upload')}
-      <input
-        type="file"
-        accept=".png,.jpg,.jpeg,.webp"
-        className="hidden"
-        onChange={(e) => {
-          const file = e.target.files?.[0]
-          if (file) {
-            void params.onFileSelected(file)
-          }
-        }}
-      />
-    </label>
-  )
-}
-
-function createPagesHandlers(params: {
-  pages: Page[]
-  onPagesChange: ((pages: Page[]) => void) | undefined
-}): { addPage: (type: 'markdown' | 'image') => void; setPageContent: (pageNumber: number, content: string) => void; setPageType: (pageNumber: number, type: 'markdown' | 'image') => void; removePage: (pageNumber: number) => void } {
-  const update = (next: Page[]): void => {
-    params.onPagesChange?.(next)
-  }
-
-  return {
-    addPage: (type) => {
-      if (!params.onPagesChange) {
-        return
-      }
-      const newPage: Page = { number: params.pages.length + 1, type, content: '' }
-      update([...params.pages, newPage])
-    },
-    setPageContent: (pageNumber, content) => {
-      if (!params.onPagesChange) {
-        return
-      }
-      update(params.pages.map((p) => (p.number === pageNumber ? { ...p, content } : p)))
-    },
-    setPageType: (pageNumber, type) => {
-      if (!params.onPagesChange) {
-        return
-      }
-      update(params.pages.map((p) => (p.number === pageNumber ? { ...p, type, content: '' } : p)))
-    },
-    removePage: (pageNumber) => {
-      if (!params.onPagesChange) {
-        return
-      }
-      update(params.pages.filter((p) => p.number !== pageNumber).map((p, idx) => ({ ...p, number: idx + 1 })))
-    },
-  }
-}
-
-function createImageUploadHandler(params: {
-  setError: (value: string | null) => void
-  setUploading: (value: boolean) => void
-  onMediaAdd: ((media: MediaRef) => void) | undefined
-  onBannerChange: ((url: string) => void) | undefined
-  onSetPageImageUrl: (pageNumber: number, url: string) => void
-}): (args: { file: File; pageNumber?: number }) => Promise<void> {
-  return async (args): Promise<void> => {
-    params.setError(null)
-    params.setUploading(true)
-    try {
-      const media = await uploadNip95Media(args.file)
-      if (media.type !== 'image') {
-        return
-      }
-      if (args.pageNumber !== undefined) {
-        params.onSetPageImageUrl(args.pageNumber, media.url)
-      } else {
-        params.onBannerChange?.(media.url)
-      }
-      params.onMediaAdd?.(media)
-    } catch (e) {
-      params.setError(e instanceof Error ? e.message : t('upload.error.failed'))
-    } finally {
-      params.setUploading(false)
-    }
-  }
-}
+export { MarkdownEditorTwoColumns } from './markdownEditorTwoColumns/MarkdownEditorTwoColumns'
diff --git a/components/Nip95ConfigManager.tsx b/components/Nip95ConfigManager.tsx
index 58e55a4..c8e85dc 100644
--- a/components/Nip95ConfigManager.tsx
+++ b/components/Nip95ConfigManager.tsx
@@ -1,367 +1 @@
-import { useState, useEffect } from 'react'
-import { configStorage } from '@/lib/configStorage'
-import type { Nip95Config } from '@/lib/configStorageTypes'
-import { t } from '@/lib/i18n'
-import { userConfirm } from '@/lib/userConfirm'
-import { DragHandle } from './DragHandle'
-
-interface Nip95ConfigManagerProps {
-  onConfigChange?: () => void
-}
-
-export function Nip95ConfigManager({ onConfigChange }: Nip95ConfigManagerProps): React.ReactElement {
-  const [apis, setApis] = useState<Nip95Config[]>([])
-  const [loading, setLoading] = useState(true)
-  const [error, setError] = useState<string | null>(null)
-  const [editingId, setEditingId] = useState<string | null>(null)
-  const [newUrl, setNewUrl] = useState('')
-  const [showAddForm, setShowAddForm] = useState(false)
-  const [draggedId, setDraggedId] = useState<string | null>(null)
-  const [dragOverId, setDragOverId] = useState<string | null>(null)
-
-  useEffect(() => {
-    void loadApis()
-  }, [])
-
-  async function loadApis(): Promise<void> {
-    try {
-      setLoading(true)
-      setError(null)
-      const config = await configStorage.getConfig()
-      setApis(config.nip95Apis.sort((a, b) => a.priority - b.priority))
-    } catch (e) {
-      const errorMessage = e instanceof Error ? e.message : t('settings.nip95.error.loadFailed')
-      setError(errorMessage)
-      console.error('Error loading NIP-95 APIs:', e)
-    } finally {
-      setLoading(false)
-    }
-  }
-
-  async function handleToggleEnabled(id: string, enabled: boolean): Promise<void> {
-    try {
-      await configStorage.updateNip95Api(id, { enabled })
-      await loadApis()
-      onConfigChange?.()
-    } catch (e) {
-      const errorMessage = e instanceof Error ? e.message : t('settings.nip95.error.updateFailed')
-      setError(errorMessage)
-      console.error('Error updating NIP-95 API:', e)
-    }
-  }
-
-  async function handleUpdatePriorities(newOrder: Nip95Config[]): Promise<void> {
-    try {
-      // Update priorities based on new order (priority = index + 1, lower number = higher priority)
-      const updatePromises = newOrder.map((api, index) => {
-        const newPriority = index + 1
-        if (api.priority !== newPriority) {
-          return configStorage.updateNip95Api(api.id, { priority: newPriority })
-        }
-        return Promise.resolve()
-      })
-
-      await Promise.all(updatePromises)
-      await loadApis()
-      onConfigChange?.()
-    } catch (e) {
-      const errorMessage = e instanceof Error ? e.message : t('settings.nip95.error.priorityFailed')
-      setError(errorMessage)
-      console.error('Error updating priorities:', e)
-    }
-  }
-
-  function handleDragStart(e: React.DragEvent<HTMLDivElement>, id: string): void {
-    setDraggedId(id)
-    const { dataTransfer } = e
-    dataTransfer.effectAllowed = 'move'
-    dataTransfer.setData('text/plain', id)
-  }
-
-  function handleDragOver(e: React.DragEvent<HTMLDivElement>, id: string): void {
-    e.preventDefault()
-    const { dataTransfer } = e
-    dataTransfer.dropEffect = 'move'
-    setDragOverId(id)
-  }
-
-  function handleDragLeave(): void {
-    setDragOverId(null)
-  }
-
-  function handleDrop(e: React.DragEvent<HTMLDivElement>, targetId: string): void {
-    e.preventDefault()
-    setDragOverId(null)
-
-    if (!draggedId || draggedId === targetId) {
-      setDraggedId(null)
-      return
-    }
-
-    const draggedIndex = apis.findIndex((api) => api.id === draggedId)
-    const targetIndex = apis.findIndex((api) => api.id === targetId)
-
-    if (draggedIndex === -1 || targetIndex === -1) {
-      setDraggedId(null)
-      return
-    }
-
-    // Reorder the array
-    const newApis = [...apis]
-    const removed = newApis[draggedIndex]
-    if (!removed) {
-      setDraggedId(null)
-      return
-    }
-    newApis.splice(draggedIndex, 1)
-    newApis.splice(targetIndex, 0, removed)
-
-    setApis(newApis)
-    setDraggedId(null)
-
-    // Update priorities based on new order
-    void handleUpdatePriorities(newApis)
-  }
-
-  async function handleUpdateUrl(id: string, url: string): Promise<void> {
-    try {
-      await configStorage.updateNip95Api(id, { url })
-      await loadApis()
-      setEditingId(null)
-      onConfigChange?.()
-    } catch (e) {
-      const errorMessage = e instanceof Error ? e.message : t('settings.nip95.error.urlFailed')
-      setError(errorMessage)
-      console.error('Error updating URL:', e)
-    }
-  }
-
-  async function handleAddApi(): Promise<void> {
-    if (!newUrl.trim()) {
-      setError(t('settings.nip95.error.urlRequired'))
-      return
-    }
-
-    try {
-      // Validate URL format - throws if invalid
-      void new URL(newUrl)
-      await configStorage.addNip95Api(newUrl.trim(), false)
-      setNewUrl('')
-      setShowAddForm(false)
-      await loadApis()
-      onConfigChange?.()
-    } catch (e) {
-      if (e instanceof TypeError && e.message.includes('Invalid URL')) {
-        setError(t('settings.nip95.error.invalidUrl'))
-      } else {
-        const errorMessage = e instanceof Error ? e.message : t('settings.nip95.error.addFailed')
-        setError(errorMessage)
-      }
-      console.error('Error adding NIP-95 API:', e)
-    }
-  }
-
-  async function handleRemoveApi(id: string): Promise<void> {
-    const confirmed = await userConfirm(t('settings.nip95.remove.confirm'))
-    if (!confirmed) {
-      return
-    }
-
-    try {
-      await configStorage.removeNip95Api(id)
-      await loadApis()
-      onConfigChange?.()
-    } catch (e) {
-      const errorMessage = e instanceof Error ? e.message : t('settings.nip95.error.removeFailed')
-      setError(errorMessage)
-      console.error('Error removing NIP-95 API:', e)
-    }
-  }
-
-  if (loading) {
-    return (
-      <div className="text-center py-8 text-neon-cyan">
-        <div>{t('settings.nip95.loading')}</div>
-      </div>
-    )
-  }
-
-  return (
-    <div className="space-y-6">
-      {error && (
-        <div className="bg-red-900/30 border border-red-500/50 rounded p-4 text-red-300">
-          {error}
-          <button
-            onClick={() => setError(null)}
-            className="ml-4 text-red-400 hover:text-red-200"
-          >
-            ×
-          </button>
-        </div>
-      )}
-
-      <div className="flex justify-between items-center">
-        <h2 className="text-2xl font-bold text-neon-cyan">{t('settings.nip95.title')}</h2>
-        <button
-          onClick={() => setShowAddForm(!showAddForm)}
-          className="px-4 py-2 bg-neon-cyan/20 hover:bg-neon-cyan/30 text-neon-cyan border border-neon-cyan/50 rounded transition-colors"
-        >
-          {showAddForm ? t('settings.nip95.add.cancel') : t('settings.nip95.addButton')}
-        </button>
-      </div>
-
-      {showAddForm && (
-        <div className="bg-cyber-dark border border-neon-cyan/30 rounded p-4 space-y-4">
-          <div>
-            <label className="block text-sm font-medium text-cyber-accent mb-2">
-              {t('settings.nip95.add.url')}
-            </label>
-            <input
-              type="url"
-              value={newUrl}
-              onChange={(e) => setNewUrl(e.target.value)}
-              placeholder={t('settings.nip95.add.placeholder')}
-              className="w-full px-4 py-2 bg-cyber-darker border border-cyber-accent/30 rounded text-cyber-light focus:border-neon-cyan focus:outline-none"
-            />
-          </div>
-          <div className="flex gap-2">
-            <button
-              onClick={() => void handleAddApi()}
-              className="px-4 py-2 bg-neon-cyan/20 hover:bg-neon-cyan/30 text-neon-cyan border border-neon-cyan/50 rounded transition-colors"
-            >
-              {t('settings.nip95.add.add')}
-            </button>
-            <button
-              onClick={() => {
-                setShowAddForm(false)
-                setNewUrl('')
-                setError(null)
-              }}
-              className="px-4 py-2 bg-cyber-accent/20 hover:bg-cyber-accent/30 text-cyber-accent border border-cyber-accent/50 rounded transition-colors"
-            >
-              {t('settings.nip95.add.cancel')}
-            </button>
-          </div>
-        </div>
-      )}
-
-      <div className="space-y-4">
-        {apis.length === 0 ? (
-          <div className="text-center py-8 text-cyber-accent">
-            {t('settings.nip95.empty')}
-          </div>
-        ) : (
-          apis.map((api, index) => (
-            <div
-              key={api.id}
-              onDragOver={(e) => {
-                handleDragOver(e, api.id)
-              }}
-              onDragLeave={handleDragLeave}
-              onDrop={(e) => {
-                handleDrop(e, api.id)
-              }}
-              className={`bg-cyber-dark border rounded p-4 space-y-3 transition-all ${getApiCardClassName(api.id, draggedId, dragOverId)}`}
-            >
-              <div className="flex items-start justify-between gap-4">
-                <div className="flex items-center gap-3 flex-1">
-                  <div
-                    className="drag-handle cursor-grab active:cursor-grabbing"
-                    draggable
-                    onDragStart={(e) => {
-                      handleDragStart(e, api.id)
-                      e.stopPropagation()
-                    }}
-                    onMouseDown={(e) => {
-                      e.stopPropagation()
-                    }}
-                  >
-                    <DragHandle />
-                  </div>
-                  <div className="flex-1">
-                  {editingId === api.id ? (
-                    <div className="space-y-2">
-                      <input
-                        type="url"
-                        defaultValue={api.url}
-                        onBlur={(e) => {
-                          if (e.target.value !== api.url) {
-                            void handleUpdateUrl(api.id, e.target.value)
-                          } else {
-                            setEditingId(null)
-                          }
-                        }}
-                        onKeyDown={(e) => {
-                          if (e.key === 'Enter') {
-                            e.currentTarget.blur()
-                          } else if (e.key === 'Escape') {
-                            setEditingId(null)
-                          }
-                        }}
-                        className="w-full px-3 py-2 bg-cyber-darker border border-neon-cyan/50 rounded text-cyber-light focus:border-neon-cyan focus:outline-none"
-                        autoFocus
-                      />
-                    </div>
-                  ) : (
-                    <div
-                      className="text-neon-cyan cursor-pointer hover:text-neon-green transition-colors"
-                      onClick={() => setEditingId(api.id)}
-                      title={t('settings.nip95.list.editUrl')}
-                    >
-                      {api.url}
-                    </div>
-                  )}
-                  </div>
-                </div>
-                <div className="flex items-center gap-2">
-                  <label className="flex items-center gap-2 cursor-pointer">
-                    <input
-                      type="checkbox"
-                      checked={api.enabled}
-                      onChange={(e) => void handleToggleEnabled(api.id, e.target.checked)}
-                      className="w-4 h-4 text-neon-cyan bg-cyber-darker border-cyber-accent rounded focus:ring-neon-cyan"
-                    />
-                    <span className="text-sm text-cyber-accent">
-                      {api.enabled ? t('settings.nip95.list.enabled') : t('settings.nip95.list.disabled')}
-                    </span>
-                  </label>
-                  <button
-                    onClick={() => void handleRemoveApi(api.id)}
-                    className="px-3 py-1 text-sm bg-red-900/30 hover:bg-red-900/50 text-red-300 border border-red-500/50 rounded transition-colors"
-                    title={t('settings.nip95.list.remove')}
-                  >
-                    {t('settings.nip95.list.remove')}
-                  </button>
-                </div>
-              </div>
-              <div className="flex items-center gap-2 text-xs text-cyber-accent/70">
-                <span>
-                  {t('settings.nip95.list.priorityLabel', { priority: index + 1, id: api.id })}
-                </span>
-              </div>
-            </div>
-          ))
-        )}
-      </div>
-
-      <div className="text-sm text-cyber-accent space-y-2">
-        <p>
-          <strong>{t('settings.nip95.note.title')}</strong> {t('settings.nip95.note.priority')}
-        </p>
-        <p>
-          {t('settings.nip95.note.fallback')}
-        </p>
-      </div>
-    </div>
-  )
-}
-
-function getApiCardClassName(apiId: string, draggedId: string | null, dragOverId: string | null): string {
-  if (draggedId === apiId) {
-    return 'opacity-50 border-neon-cyan'
-  }
-  if (dragOverId === apiId) {
-    return 'border-neon-green shadow-lg'
-  }
-  return 'border-neon-cyan/30'
-}
+export { Nip95ConfigManager } from './nip95Config/Nip95ConfigManager'
diff --git a/components/RelayManager.tsx b/components/RelayManager.tsx
index 6971a7e..d96bf14 100644
--- a/components/RelayManager.tsx
+++ b/components/RelayManager.tsx
@@ -1,412 +1 @@
-import { useState, useEffect } from 'react'
-import { configStorage } from '@/lib/configStorage'
-import type { RelayConfig } from '@/lib/configStorageTypes'
-import { t } from '@/lib/i18n'
-import { userConfirm } from '@/lib/userConfirm'
-import { relaySessionManager } from '@/lib/relaySessionManager'
-import { DragHandle } from './DragHandle'
-
-interface RelayManagerProps {
-  onConfigChange?: () => void
-}
-
-export function RelayManager({ onConfigChange }: RelayManagerProps): React.ReactElement {
-  const [relays, setRelays] = useState<RelayConfig[]>([])
-  const [loading, setLoading] = useState(true)
-  const [error, setError] = useState<string | null>(null)
-  const [editingId, setEditingId] = useState<string | null>(null)
-  const [newUrl, setNewUrl] = useState('')
-  const [showAddForm, setShowAddForm] = useState(false)
-  const [draggedId, setDraggedId] = useState<string | null>(null)
-  const [dragOverId, setDragOverId] = useState<string | null>(null)
-
-  useEffect(() => {
-    void loadRelays()
-  }, [])
-
-  async function loadRelays(): Promise<void> {
-    try {
-      setLoading(true)
-      setError(null)
-      const config = await configStorage.getConfig()
-
-      // Get failed relays from session manager and disable them in config
-      const failedRelays = relaySessionManager.getFailedRelays()
-      if (failedRelays.length > 0) {
-        let hasChanges = false
-        for (const relayUrl of failedRelays) {
-          // Find the relay config by URL
-          const relayConfig = config.relays.find((r) => r.url === relayUrl)
-          if (relayConfig?.enabled) {
-            // Disable the failed relay
-            await configStorage.updateRelay(relayConfig.id, { enabled: false })
-            hasChanges = true
-          }
-        }
-        // Reload config if we made changes
-        if (hasChanges) {
-          const updatedConfig = await configStorage.getConfig()
-          setRelays(updatedConfig.relays.sort((a, b) => a.priority - b.priority))
-        } else {
-          setRelays(config.relays.sort((a, b) => a.priority - b.priority))
-        }
-      } else {
-        setRelays(config.relays.sort((a, b) => a.priority - b.priority))
-      }
-    } catch (e) {
-      const errorMessage = e instanceof Error ? e.message : t('settings.relay.error.loadFailed')
-      setError(errorMessage)
-      console.error('Error loading relays:', e)
-    } finally {
-      setLoading(false)
-    }
-  }
-
-  async function handleToggleEnabled(id: string, enabled: boolean): Promise<void> {
-    try {
-      await configStorage.updateRelay(id, { enabled })
-      await loadRelays()
-      onConfigChange?.()
-    } catch (e) {
-      const errorMessage = e instanceof Error ? e.message : t('settings.relay.error.updateFailed')
-      setError(errorMessage)
-      console.error('Error updating relay:', e)
-    }
-  }
-
-  async function handleUpdatePriorities(newOrder: RelayConfig[]): Promise<void> {
-    try {
-      const updatePromises = newOrder.map((relay, index) => {
-        const newPriority = index + 1
-        if (relay.priority !== newPriority) {
-          return configStorage.updateRelay(relay.id, { priority: newPriority })
-        }
-        return Promise.resolve()
-      })
-
-      await Promise.all(updatePromises)
-      await loadRelays()
-      onConfigChange?.()
-    } catch (e) {
-      const errorMessage = e instanceof Error ? e.message : t('settings.relay.error.priorityFailed')
-      setError(errorMessage)
-      console.error('Error updating priorities:', e)
-    }
-  }
-
-  function handleDragStart(e: React.DragEvent<HTMLDivElement>, id: string): void {
-    setDraggedId(id)
-    const { dataTransfer } = e
-    dataTransfer.effectAllowed = 'move'
-    dataTransfer.setData('text/plain', id)
-  }
-
-  function handleDragOver(e: React.DragEvent<HTMLDivElement>, id: string): void {
-    e.preventDefault()
-    const { dataTransfer } = e
-    dataTransfer.dropEffect = 'move'
-    setDragOverId(id)
-  }
-
-  function handleDragLeave(): void {
-    setDragOverId(null)
-  }
-
-  function handleDrop(e: React.DragEvent<HTMLDivElement>, targetId: string): void {
-    e.preventDefault()
-    setDragOverId(null)
-
-    if (!draggedId || draggedId === targetId) {
-      setDraggedId(null)
-      return
-    }
-
-    const draggedIndex = relays.findIndex((relay) => relay.id === draggedId)
-    const targetIndex = relays.findIndex((relay) => relay.id === targetId)
-
-    if (draggedIndex === -1 || targetIndex === -1) {
-      setDraggedId(null)
-      return
-    }
-
-    const newRelays = [...relays]
-    const removed = newRelays[draggedIndex]
-    if (!removed) {
-      setDraggedId(null)
-      return
-    }
-    newRelays.splice(draggedIndex, 1)
-    newRelays.splice(targetIndex, 0, removed)
-
-    setRelays(newRelays)
-    setDraggedId(null)
-
-    void handleUpdatePriorities(newRelays)
-  }
-
-  function handleDragEnd(): void {
-    setDraggedId(null)
-  }
-
-  async function handleUpdateUrl(id: string, url: string): Promise<void> {
-    try {
-      await configStorage.updateRelay(id, { url })
-      await loadRelays()
-      setEditingId(null)
-      onConfigChange?.()
-    } catch (e) {
-      const errorMessage = e instanceof Error ? e.message : t('settings.relay.error.urlFailed')
-      setError(errorMessage)
-      console.error('Error updating URL:', e)
-    }
-  }
-
-  async function handleAddRelay(): Promise<void> {
-    if (!newUrl.trim()) {
-      setError(t('settings.relay.error.urlRequired'))
-      return
-    }
-
-    try {
-      // Normalize URL (add wss:// if missing)
-      let normalizedUrl = newUrl.trim()
-      if (!normalizedUrl.startsWith('ws://') && !normalizedUrl.startsWith('wss://')) {
-        normalizedUrl = `wss://${normalizedUrl}`
-      }
-
-      // Validate URL format - throws if invalid
-      void new URL(normalizedUrl)
-      await configStorage.addRelay(normalizedUrl, true)
-      setNewUrl('')
-      setShowAddForm(false)
-      await loadRelays()
-      onConfigChange?.()
-    } catch (e) {
-      if (e instanceof TypeError && e.message.includes('Invalid URL')) {
-        setError(t('settings.relay.error.invalidUrl'))
-      } else {
-        const errorMessage = e instanceof Error ? e.message : t('settings.relay.error.addFailed')
-        setError(errorMessage)
-      }
-      console.error('Error adding relay:', e)
-    }
-  }
-
-  async function handleRemoveRelay(id: string): Promise<void> {
-    const confirmed = await userConfirm(t('settings.relay.remove.confirm'))
-    if (!confirmed) {
-      return
-    }
-
-    try {
-      await configStorage.removeRelay(id)
-      await loadRelays()
-      onConfigChange?.()
-    } catch (e) {
-      const errorMessage = e instanceof Error ? e.message : t('settings.relay.error.removeFailed')
-      setError(errorMessage)
-      console.error('Error removing relay:', e)
-    }
-  }
-
-  if (loading) {
-    return (
-      <div className="text-center py-8 text-neon-cyan">
-        <div>{t('settings.relay.loading')}</div>
-      </div>
-    )
-  }
-
-  return (
-    <div className="space-y-6">
-      {error && (
-        <div className="bg-red-900/30 border border-red-500/50 rounded p-4 text-red-300">
-          {error}
-          <button
-            onClick={() => {
-              setError(null)
-            }}
-            className="ml-4 text-red-400 hover:text-red-200"
-          >
-            ×
-          </button>
-        </div>
-      )}
-
-      <div className="flex justify-between items-center">
-        <h2 className="text-2xl font-bold text-neon-cyan">{t('settings.relay.title')}</h2>
-        <button
-          onClick={() => {
-            setShowAddForm(!showAddForm)
-          }}
-          className="px-4 py-2 bg-neon-cyan/20 hover:bg-neon-cyan/30 text-neon-cyan border border-neon-cyan/50 rounded transition-colors"
-        >
-          {showAddForm ? t('settings.relay.add.cancel') : t('settings.relay.addButton')}
-        </button>
-      </div>
-
-      {showAddForm && (
-        <div className="bg-cyber-dark border border-neon-cyan/30 rounded p-4 space-y-4">
-          <div>
-            <label className="block text-sm font-medium text-cyber-accent mb-2">
-              {t('settings.relay.add.url')}
-            </label>
-            <input
-              type="text"
-              value={newUrl}
-              onChange={(e) => {
-                setNewUrl(e.target.value)
-              }}
-              placeholder={t('settings.relay.add.placeholder')}
-              className="w-full px-4 py-2 bg-cyber-darker border border-cyber-accent/30 rounded text-cyber-light focus:border-neon-cyan focus:outline-none"
-            />
-          </div>
-          <div className="flex gap-2">
-            <button
-              onClick={() => {
-                void handleAddRelay()
-              }}
-              className="px-4 py-2 bg-neon-cyan/20 hover:bg-neon-cyan/30 text-neon-cyan border border-neon-cyan/50 rounded transition-colors"
-            >
-              {t('settings.relay.add.add')}
-            </button>
-            <button
-              onClick={() => {
-                setShowAddForm(false)
-                setNewUrl('')
-                setError(null)
-              }}
-              className="px-4 py-2 bg-cyber-accent/20 hover:bg-cyber-accent/30 text-cyber-accent border border-cyber-accent/50 rounded transition-colors"
-            >
-              {t('settings.relay.add.cancel')}
-            </button>
-          </div>
-        </div>
-      )}
-
-      <div className="space-y-4">
-        {relays.length === 0 ? (
-          <div className="text-center py-8 text-cyber-accent">
-            {t('settings.relay.empty')}
-          </div>
-        ) : (
-          relays.map((relay) => (
-            <div
-              key={relay.id}
-              onDragOver={(e) => {
-                handleDragOver(e, relay.id)
-              }}
-              onDragLeave={handleDragLeave}
-              onDrop={(e) => {
-                handleDrop(e, relay.id)
-              }}
-              className={`bg-cyber-dark border rounded p-4 space-y-3 transition-all ${
-                (() => {
-                  if (draggedId === relay.id) {
-                    return 'opacity-50 border-neon-cyan'
-                  }
-                  if (dragOverId === relay.id) {
-                    return 'border-neon-green shadow-lg'
-                  }
-                  return 'border-neon-cyan/30'
-                })()
-              }`}
-            >
-              <div className="flex items-start justify-between gap-4">
-                <div className="flex items-center gap-3 flex-1">
-                  <div
-                    className="drag-handle cursor-grab active:cursor-grabbing"
-                    draggable
-                    onDragStart={(e) => {
-                      handleDragStart(e, relay.id)
-                    }}
-                    onDragEnd={handleDragEnd}
-                    onMouseDown={(e) => {
-                      e.stopPropagation()
-                    }}
-                  >
-                    <DragHandle />
-                  </div>
-                  <div className="flex-1">
-                    {editingId === relay.id ? (
-                      <div className="space-y-2">
-                        <input
-                          type="text"
-                          defaultValue={relay.url}
-                          onBlur={(e) => {
-                            if (e.target.value !== relay.url) {
-                              void handleUpdateUrl(relay.id, e.target.value)
-                            } else {
-                              setEditingId(null)
-                            }
-                          }}
-                          onKeyDown={(e) => {
-                            if (e.key === 'Enter') {
-                              e.currentTarget.blur()
-                            } else if (e.key === 'Escape') {
-                              setEditingId(null)
-                            }
-                          }}
-                          className="w-full px-3 py-2 bg-cyber-darker border border-neon-cyan/50 rounded text-cyber-light focus:border-neon-cyan focus:outline-none"
-                          autoFocus
-                        />
-                      </div>
-                    ) : (
-                      <div
-                        className="text-neon-cyan cursor-pointer hover:text-neon-green transition-colors"
-                        onClick={() => {
-                          setEditingId(relay.id)
-                        }}
-                        title={t('settings.relay.list.editUrl')}
-                      >
-                        {relay.url}
-                      </div>
-                    )}
-                  </div>
-                  {relay.lastSyncDate && (
-                    <div className="text-xs text-cyber-accent/70 mt-1">
-                      {t('settings.relay.list.lastSync')}: {new Date(relay.lastSyncDate).toLocaleString()}
-                    </div>
-                  )}
-                </div>
-                <div className="flex items-center gap-2">
-                  <label className="flex items-center gap-2 cursor-pointer">
-                    <input
-                      type="checkbox"
-                      checked={relay.enabled}
-                      onChange={(e) => {
-                        void handleToggleEnabled(relay.id, e.target.checked)
-                      }}
-                      className="w-4 h-4 text-neon-cyan bg-cyber-darker border-cyber-accent rounded focus:ring-neon-cyan"
-                    />
-                    <span className="text-sm text-cyber-accent">
-                      {relay.enabled ? t('settings.relay.list.enabled') : t('settings.relay.list.disabled')}
-                    </span>
-                  </label>
-                  <button
-                    onClick={() => {
-                      void handleRemoveRelay(relay.id)
-                    }}
-                    className="px-3 py-1 text-sm bg-red-900/30 hover:bg-red-900/50 text-red-300 border border-red-500/50 rounded transition-colors"
-                    title={t('settings.relay.list.remove')}
-                  >
-                    {t('settings.relay.list.remove')}
-                  </button>
-                </div>
-              </div>
-            </div>
-          ))
-        )}
-      </div>
-
-      <div className="text-sm text-cyber-accent space-y-2">
-        <p>
-          <strong>{t('settings.relay.note.title')}</strong> {t('settings.relay.note.priority')}
-        </p>
-        <p>
-          {t('settings.relay.note.rotation')}
-        </p>
-      </div>
-    </div>
-  )
-}
+export { RelayManager } from './relayManager/RelayManager'
diff --git a/components/SponsoringForm.tsx b/components/SponsoringForm.tsx
index 239e09f..ee59ad5 100644
--- a/components/SponsoringForm.tsx
+++ b/components/SponsoringForm.tsx
@@ -13,190 +13,189 @@ interface SponsoringFormProps {
 
 export function SponsoringForm({ author, onSuccess, onCancel }: SponsoringFormProps): React.ReactElement {
   const { pubkey, connect } = useNostrAuth()
-  const [text, setText] = useState('')
-  const [loading, setLoading] = useState(false)
-  const [error, setError] = useState<string | null>(null)
-  const [instructions, setInstructions] = useState<{
-    authorAddress: string
-    platformAddress: string
-    authorBtc: string
-    platformBtc: string
-  } | null>(null)
-
-  const handleSubmit = async (e: React.FormEvent): Promise<void> => {
+  const state = useSponsoringFormState()
+  const onSubmit = (e: React.FormEvent): void => {
     e.preventDefault()
-    if (!pubkey) {
-      await connect()
-      return
-    }
-
-    if (!author.mainnetAddress) {
-      setError(t('sponsoring.form.error.noAddress'))
-      return
-    }
-
-    setLoading(true)
-    setError(null)
-
-    try {
-      const privateKey = nostrService.getPrivateKey()
-      if (!privateKey) {
-        setError(t('sponsoring.form.error.noPrivateKey'))
-        return
-      }
-
-      // Create sponsoring payment request
-      const result = await sponsoringPaymentService.createSponsoringPayment({
-        authorPubkey: author.pubkey,
-        authorMainnetAddress: author.mainnetAddress,
-        amount: 0.046, // Fixed amount for sponsoring
-      })
-
-      if (!result.success) {
-        setError(result.error ?? t('sponsoring.form.error.paymentFailed'))
-        return
-      }
-
-      // Note: Sponsoring is done via Bitcoin mainnet, not Lightning zap
-      // The user needs to create a Bitcoin transaction with two outputs:
-      // 1. Author address: result.split.authorSats
-      // 2. Platform address: result.split.platformSats
-      // After the transaction is confirmed, we can create a zap receipt for tracking
-
-      // Store payment info for later verification
-      // The user will need to provide the transaction ID after payment
-      console.warn('Sponsoring payment info:', {
-        authorAddress: result.authorAddress,
-        platformAddress: result.platformAddress,
-        authorAmount: result.split.authorSats,
-        platformAmount: result.split.platformSats,
-        totalAmount: result.split.totalSats,
-      })
-
-      // Show instructions inline (no-alert)
-      setInstructions({
-        authorAddress: result.authorAddress,
-        platformAddress: result.platformAddress,
-        authorBtc: (result.split.authorSats / 100_000_000).toFixed(8),
-        platformBtc: (result.split.platformSats / 100_000_000).toFixed(8),
-      })
-
-      setText('')
-    } catch (submitError) {
-      setError(submitError instanceof Error ? submitError.message : t('sponsoring.form.error.paymentFailed'))
-    } finally {
-      setLoading(false)
-    }
+    void handleSubmit({ pubkey, author, setInstructions: state.setInstructions, setError: state.setError, setLoading: state.setLoading })
   }
 
   if (!pubkey) {
-    return (
-      <div className="border border-neon-cyan/30 rounded-lg p-4 bg-cyber-dark">
-        <p className="text-cyber-accent mb-4">{t('sponsoring.form.connectRequired')}</p>
-        <button
-          onClick={() => {
-            void connect()
-          }}
-          className="px-4 py-2 bg-neon-green/20 hover:bg-neon-green/30 text-neon-green rounded-lg font-medium transition-all border border-neon-green/50"
-        >
-          {t('connect.connect')}
-        </button>
-      </div>
-    )
+    return <SponsoringConnectRequired onConnect={() => { void connect() }} />
   }
 
   if (!author.mainnetAddress) {
-    return (
-      <div className="border border-neon-cyan/30 rounded-lg p-4 bg-cyber-dark">
-        <p className="text-cyber-accent">{t('sponsoring.form.error.noAddress')}</p>
-      </div>
-    )
+    return <SponsoringNoAddress />
   }
 
-  if (instructions) {
+  if (state.instructions) {
     return (
-      <div className="border border-neon-cyan/30 rounded-lg p-4 bg-cyber-dark space-y-4" role="dialog" aria-modal="true">
-        <h3 className="text-lg font-semibold text-neon-cyan">{t('sponsoring.form.title')}</h3>
-        <p className="text-sm text-cyber-accent/70">
-          {t('sponsoring.form.instructions', {
-            authorAddress: instructions.authorAddress,
-            platformAddress: instructions.platformAddress,
-            authorAmount: instructions.authorBtc,
-            platformAmount: instructions.platformBtc,
-          })}
-        </p>
-        <div className="flex gap-3">
-          <button
-            type="button"
-            onClick={() => {
-              setInstructions(null)
-              onSuccess?.()
-            }}
-            className="px-4 py-2 bg-neon-green/20 hover:bg-neon-green/30 text-neon-green rounded-lg font-medium transition-all border border-neon-green/50"
-          >
-            {t('common.close')}
-          </button>
-          <button
-            type="button"
-            onClick={() => {
-              setInstructions(null)
-              onCancel?.()
-            }}
-            className="px-4 py-2 bg-neon-cyan/10 hover:bg-neon-cyan/20 text-neon-cyan rounded-lg font-medium transition-all border border-neon-cyan/30"
-          >
-            {t('common.cancel')}
-          </button>
-        </div>
-      </div>
+      <SponsoringInstructions
+        instructions={state.instructions}
+        onClose={() => {
+          state.setInstructions(null)
+          onSuccess?.()
+        }}
+        onCancel={() => {
+          state.setInstructions(null)
+          onCancel?.()
+        }}
+      />
     )
   }
 
   return (
-    <form onSubmit={(e) => {
-      void handleSubmit(e)
-    }} className="border border-neon-cyan/30 rounded-lg p-4 bg-cyber-dark space-y-4">
-      <h3 className="text-lg font-semibold text-neon-cyan">{t('sponsoring.form.title')}</h3>
-      <p className="text-sm text-cyber-accent/70">
-        {t('sponsoring.form.description', { amount: '0.046' })}
-      </p>
+    <SponsoringFormView
+      text={state.text}
+      setText={state.setText}
+      loading={state.loading}
+      error={state.error}
+      onSubmit={onSubmit}
+      {...(onCancel ? { onCancel } : {})}
+    />
+  )
+}
 
+async function handleSubmit(params: {
+  pubkey: string | null
+  author: AuthorPresentationArticle
+  setInstructions: (value: SponsoringInstructionsState) => void
+  setError: (value: string | null) => void
+  setLoading: (value: boolean) => void
+}): Promise<void> {
+  if (!params.pubkey || !params.author.mainnetAddress) {
+    return
+  }
+  await submitSponsoring({
+    pubkey: params.pubkey,
+    author: params.author,
+    setInstructions: params.setInstructions,
+    setError: params.setError,
+    setLoading: params.setLoading,
+  })
+}
+
+type SponsoringInstructionsState = {
+  authorAddress: string
+  platformAddress: string
+  authorBtc: string
+  platformBtc: string
+}
+
+function useSponsoringFormState(): {
+  text: string
+  setText: (value: string) => void
+  loading: boolean
+  setLoading: (value: boolean) => void
+  error: string | null
+  setError: (value: string | null) => void
+  instructions: SponsoringInstructionsState | null
+  setInstructions: (value: SponsoringInstructionsState | null) => void
+} {
+  const [text, setText] = useState('')
+  const [loading, setLoading] = useState(false)
+  const [error, setError] = useState<string | null>(null)
+  const [instructions, setInstructions] = useState<SponsoringInstructionsState | null>(null)
+  return { text, setText, loading, setLoading, error, setError, instructions, setInstructions }
+}
+
+async function submitSponsoring(params: {
+  pubkey: string
+  author: AuthorPresentationArticle
+  setInstructions: (value: SponsoringInstructionsState) => void
+  setError: (value: string | null) => void
+  setLoading: (value: boolean) => void
+}): Promise<void> {
+  params.setLoading(true)
+  params.setError(null)
+  try {
+    const privateKey = nostrService.getPrivateKey()
+    if (!privateKey) {
+      params.setError(t('sponsoring.form.error.noPrivateKey'))
+      return
+    }
+    const result = await sponsoringPaymentService.createSponsoringPayment({ authorPubkey: params.author.pubkey, authorMainnetAddress: params.author.mainnetAddress ?? '', amount: 0.046 })
+    if (!result.success) {
+      params.setError(result.error ?? t('sponsoring.form.error.paymentFailed'))
+      return
+    }
+    console.warn('Sponsoring payment info:', { authorAddress: result.authorAddress, platformAddress: result.platformAddress, authorAmount: result.split.authorSats, platformAmount: result.split.platformSats, totalAmount: result.split.totalSats })
+    params.setInstructions({ authorAddress: result.authorAddress, platformAddress: result.platformAddress, authorBtc: (result.split.authorSats / 100_000_000).toFixed(8), platformBtc: (result.split.platformSats / 100_000_000).toFixed(8) })
+  } catch (submitError) {
+    params.setError(submitError instanceof Error ? submitError.message : t('sponsoring.form.error.paymentFailed'))
+  } finally {
+    params.setLoading(false)
+  }
+}
+
+function SponsoringConnectRequired(params: { onConnect: () => void }): React.ReactElement {
+  return (
+    <div className="border border-neon-cyan/30 rounded-lg p-4 bg-cyber-dark">
+      <p className="text-cyber-accent mb-4">{t('sponsoring.form.connectRequired')}</p>
+      <button onClick={params.onConnect} className="px-4 py-2 bg-neon-green/20 hover:bg-neon-green/30 text-neon-green rounded-lg font-medium transition-all border border-neon-green/50">
+        {t('connect.connect')}
+      </button>
+    </div>
+  )
+}
+
+function SponsoringNoAddress(): React.ReactElement {
+  return (
+    <div className="border border-neon-cyan/30 rounded-lg p-4 bg-cyber-dark">
+      <p className="text-cyber-accent">{t('sponsoring.form.error.noAddress')}</p>
+    </div>
+  )
+}
+
+function SponsoringInstructions(params: { instructions: SponsoringInstructionsState; onClose: () => void; onCancel: () => void }): React.ReactElement {
+  return (
+    <div className="border border-neon-cyan/30 rounded-lg p-4 bg-cyber-dark space-y-4" role="dialog" aria-modal="true">
+      <h3 className="text-lg font-semibold text-neon-cyan">{t('sponsoring.form.title')}</h3>
+      <p className="text-sm text-cyber-accent/70">{t('sponsoring.form.instructions', { authorAddress: params.instructions.authorAddress, platformAddress: params.instructions.platformAddress, authorAmount: params.instructions.authorBtc, platformAmount: params.instructions.platformBtc })}</p>
+      <div className="flex gap-3">
+        <button type="button" onClick={params.onClose} className="px-4 py-2 bg-neon-green/20 hover:bg-neon-green/30 text-neon-green rounded-lg font-medium transition-all border border-neon-green/50">
+          {t('common.close')}
+        </button>
+        <button type="button" onClick={params.onCancel} className="px-4 py-2 bg-neon-cyan/10 hover:bg-neon-cyan/20 text-neon-cyan rounded-lg font-medium transition-all border border-neon-cyan/30">
+          {t('common.cancel')}
+        </button>
+      </div>
+    </div>
+  )
+}
+
+function SponsoringFormView(params: {
+  text: string
+  setText: (value: string) => void
+  loading: boolean
+  error: string | null
+  onSubmit: (e: React.FormEvent) => void
+  onCancel?: () => void
+}): React.ReactElement {
+  return (
+    <form onSubmit={params.onSubmit} className="border border-neon-cyan/30 rounded-lg p-4 bg-cyber-dark space-y-4">
+      <h3 className="text-lg font-semibold text-neon-cyan">{t('sponsoring.form.title')}</h3>
+      <p className="text-sm text-cyber-accent/70">{t('sponsoring.form.description', { amount: '0.046' })}</p>
       <div>
         <label htmlFor="sponsoring-text" className="block text-sm font-medium text-cyber-accent mb-1">
           {t('sponsoring.form.text.label')} <span className="text-cyber-accent/50">({t('common.optional')})</span>
         </label>
         <textarea
           id="sponsoring-text"
-          value={text}
-          onChange={(e) => {
-            setText(e.target.value)
-          }}
+          value={params.text}
+          onChange={(e) => params.setText(e.target.value)}
           placeholder={t('sponsoring.form.text.placeholder')}
           rows={3}
           className="w-full px-3 py-2 bg-cyber-darker border border-neon-cyan/30 rounded text-cyber-accent focus:border-neon-cyan focus:outline-none"
         />
         <p className="text-xs text-cyber-accent/70 mt-1">{t('sponsoring.form.text.help')}</p>
       </div>
-
-      {error && (
-        <div className="p-3 bg-red-900/20 border border-red-500/50 rounded text-red-400 text-sm">
-          {error}
-        </div>
-      )}
-
+      {params.error && <div className="p-3 bg-red-900/20 border border-red-500/50 rounded text-red-400 text-sm">{params.error}</div>}
       <div className="flex gap-2">
-        <button
-          type="submit"
-          disabled={loading}
-          className="px-4 py-2 bg-neon-green/20 hover:bg-neon-green/30 text-neon-green rounded-lg font-medium transition-all border border-neon-green/50 hover:shadow-glow-green disabled:opacity-50"
-        >
-          {loading ? t('common.loading') : t('sponsoring.form.submit')}
+        <button type="submit" disabled={params.loading} className="px-4 py-2 bg-neon-green/20 hover:bg-neon-green/30 text-neon-green rounded-lg font-medium transition-all border border-neon-green/50 hover:shadow-glow-green disabled:opacity-50">
+          {params.loading ? t('common.loading') : t('sponsoring.form.submit')}
         </button>
-        {onCancel && (
-          <button
-            type="button"
-            onClick={onCancel}
-            className="px-4 py-2 bg-cyber-darker hover:bg-cyber-dark text-cyber-accent rounded-lg font-medium transition-all border border-neon-cyan/30"
-          >
+        {params.onCancel && (
+          <button type="button" onClick={params.onCancel} className="px-4 py-2 bg-cyber-darker hover:bg-cyber-dark text-cyber-accent rounded-lg font-medium transition-all border border-neon-cyan/30">
             {t('common.cancel')}
           </button>
         )}
diff --git a/components/SyncProgressBar.tsx b/components/SyncProgressBar.tsx
index edb50b6..cccf195 100644
--- a/components/SyncProgressBar.tsx
+++ b/components/SyncProgressBar.tsx
@@ -1,346 +1 @@
-import { useState, useEffect, useCallback } from 'react'
-import { nostrAuthService } from '@/lib/nostrAuth'
-import { getLastSyncDate, setLastSyncDate as setLastSyncDateStorage, getCurrentTimestamp, calculateDaysBetween } from '@/lib/syncStorage'
-import { MIN_EVENT_DATE } from '@/lib/platformConfig'
-import { objectCache } from '@/lib/objectCache'
-import { t } from '@/lib/i18n'
-import { useSyncProgress } from '@/lib/hooks/useSyncProgress'
-
-export function SyncProgressBar(): React.ReactElement | null {
-  const [lastSyncDate, setLastSyncDate] = useState<number | null>(null)
-  const [totalDays, setTotalDays] = useState<number>(0)
-  const [isInitialized, setIsInitialized] = useState(false)
-  const [connectionState, setConnectionState] = useState<{ connected: boolean; pubkey: string | null }>({ connected: false, pubkey: null })
-  const [error, setError] = useState<string | null>(null)
-
-  const loadSyncStatus = useCallback(async (): Promise<void> => {
-    try {
-      const state = nostrAuthService.getState()
-      if (!state.connected || !state.pubkey) {
-        return
-      }
-
-      const storedLastSyncDate = await getLastSyncDate()
-      const currentTimestamp = getCurrentTimestamp()
-      const days = calculateDaysBetween(storedLastSyncDate, currentTimestamp)
-
-      setLastSyncDate(storedLastSyncDate)
-      setTotalDays(days)
-    } catch (loadError) {
-      console.error('Error loading sync status:', loadError)
-    }
-  }, [])
-
-  const { syncProgress, isSyncing, startMonitoring, stopMonitoring } = useSyncProgress({
-    onComplete: loadSyncStatus,
-  })
-
-  useEffect(() => {
-    // Check connection state
-    const checkConnection = (): void => {
-      const state = nostrAuthService.getState()
-      console.warn('[SyncProgressBar] Initial connection check:', { connected: state.connected, pubkey: state.pubkey })
-      setConnectionState({ connected: state.connected ?? false, pubkey: state.pubkey ?? null })
-      setIsInitialized(true)
-    }
-
-    // Initial check
-    checkConnection()
-
-    // Listen to connection changes
-    const unsubscribe = nostrAuthService.subscribe((state) => {
-      console.warn('[SyncProgressBar] Connection state changed:', { connected: state.connected, pubkey: state.pubkey })
-      setConnectionState({ connected: state.connected ?? false, pubkey: state.pubkey ?? null })
-    })
-
-    return () => {
-      unsubscribe()
-    }
-  }, [])
-
-  useEffect(() => {
-    console.warn('[SyncProgressBar] Effect triggered:', { isInitialized, connected: connectionState.connected, pubkey: connectionState.pubkey, isSyncing })
-
-    if (!isInitialized) {
-      console.warn('[SyncProgressBar] Not initialized yet')
-      return
-    }
-
-    if (!connectionState.connected) {
-      console.warn('[SyncProgressBar] Not connected')
-      return
-    }
-
-    if (!connectionState.pubkey) {
-      console.warn('[SyncProgressBar] No pubkey')
-      return
-    }
-
-    void runAutoSyncCheck({
-      connection: { connected: connectionState.connected, pubkey: connectionState.pubkey },
-      isSyncing,
-      loadSyncStatus,
-      startMonitoring,
-      stopMonitoring,
-      setError,
-    })
-  }, [isInitialized, connectionState.connected, connectionState.pubkey, isSyncing, loadSyncStatus, startMonitoring, stopMonitoring])
-
-  async function resynchronize(): Promise<void> {
-    try {
-      const state = nostrAuthService.getState()
-      if (!state.connected || !state.pubkey) {
-        return
-      }
-
-      // Clear cache for user content (but keep other data)
-      await Promise.all([
-        objectCache.clear('author'),
-        objectCache.clear('series'),
-        objectCache.clear('publication'),
-        objectCache.clear('review'),
-        objectCache.clear('purchase'),
-        objectCache.clear('sponsoring'),
-        objectCache.clear('review_tip'),
-      ])
-
-      // Reset last sync date to force full resync
-      await setLastSyncDateStorage(MIN_EVENT_DATE)
-
-      // Reload sync status
-      await loadSyncStatus()
-
-      // Start full resynchronization via Service Worker
-      if (state.pubkey !== null) {
-        const { swClient } = await import('@/lib/swClient')
-        const isReady = await swClient.isReady()
-        if (isReady) {
-          await swClient.startUserSync(state.pubkey)
-          startMonitoring()
-        } else {
-          stopMonitoring()
-        }
-      }
-    } catch (resyncError) {
-      console.error('Error resynchronizing:', resyncError)
-      stopMonitoring()
-    }
-  }
-
-  // Don't show if not initialized or not connected
-  if (!isInitialized || !connectionState.connected || !connectionState.pubkey) {
-    return null
-  }
-
-  // Check if sync is recently completed (within last hour)
-  const isRecentlySynced = lastSyncDate !== null && lastSyncDate >= getCurrentTimestamp() - 3600
-
-  const progressPercentage = computeProgressPercentage(syncProgress)
-
-  const formatDate = (timestamp: number): string => {
-    const date = new Date(timestamp * 1000)
-    const locale = typeof window !== 'undefined' ? navigator.language : 'fr-FR'
-    return date.toLocaleDateString(locale, { day: '2-digit', month: '2-digit', year: 'numeric' })
-  }
-
-  const getStartDate = (): number => {
-    if (lastSyncDate !== null) {
-      return lastSyncDate
-    }
-    return MIN_EVENT_DATE
-  }
-
-  const startDate = getStartDate()
-  const endDate = getCurrentTimestamp()
-
-  return (
-    <div className="bg-cyber-darker border border-neon-cyan/30 rounded-lg p-4 mt-6">
-      <SyncErrorBanner
-        error={error}
-        onDismiss={() => {
-          setError(null)
-        }}
-      />
-      <div className="flex items-center justify-between mb-2">
-        <h3 className="text-lg font-semibold text-neon-cyan">
-          {t('settings.sync.title')}
-        </h3>
-        <SyncResyncButton
-          isSyncing={isSyncing}
-          onClick={() => {
-            void resynchronize()
-          }}
-        />
-      </div>
-
-      <SyncDateRange
-        totalDays={totalDays}
-        startDate={formatDate(startDate)}
-        endDate={formatDate(endDate)}
-      />
-
-      <SyncProgressSection
-        isSyncing={isSyncing}
-        syncProgress={syncProgress}
-        progressPercentage={progressPercentage}
-      />
-
-      <SyncStatusMessage
-        isSyncing={isSyncing}
-        totalDays={totalDays}
-        isRecentlySynced={isRecentlySynced}
-      />
-    </div>
-  )
-}
-
-function computeProgressPercentage(syncProgress: ReturnType<typeof useSyncProgress>['syncProgress']): number {
-  if (!syncProgress || syncProgress.totalSteps <= 0) {
-    return 0
-  }
-  return Math.min(100, (syncProgress.currentStep / syncProgress.totalSteps) * 100)
-}
-
-function SyncErrorBanner(params: { error: string | null; onDismiss: () => void }): React.ReactElement | null {
-  if (!params.error) {
-    return null
-  }
-  return (
-    <div className="mb-4 bg-red-900/30 border border-red-500/50 rounded p-3 text-red-300 text-sm">
-      {params.error}
-      <button onClick={params.onDismiss} className="ml-2 text-red-400 hover:text-red-200">
-        ×
-      </button>
-    </div>
-  )
-}
-
-function SyncResyncButton(params: { isSyncing: boolean; onClick: () => void }): React.ReactElement | null {
-  if (params.isSyncing) {
-    return null
-  }
-  return (
-    <button
-      onClick={params.onClick}
-      className="px-3 py-1 text-xs bg-neon-cyan/20 hover:bg-neon-cyan/30 text-neon-cyan rounded border border-neon-cyan/50 hover:border-neon-cyan transition-colors"
-    >
-      {t('settings.sync.resync')}
-    </button>
-  )
-}
-
-function SyncDateRange(params: { totalDays: number; startDate: string; endDate: string }): React.ReactElement | null {
-  if (params.totalDays <= 0) {
-    return null
-  }
-  return (
-    <div className="mb-2">
-      <p className="text-sm text-cyber-accent">
-        {t('settings.sync.daysRange', {
-          startDate: params.startDate,
-          endDate: params.endDate,
-          days: params.totalDays,
-        })}
-      </p>
-    </div>
-  )
-}
-
-function SyncProgressSection(params: {
-  isSyncing: boolean
-  syncProgress: ReturnType<typeof useSyncProgress>['syncProgress']
-  progressPercentage: number
-}): React.ReactElement | null {
-  if (!params.isSyncing || !params.syncProgress) {
-    return null
-  }
-  return (
-    <div className="space-y-2">
-      <div className="flex items-center justify-between text-sm">
-        <span className="text-cyber-accent">
-          {t('settings.sync.progress', {
-            current: params.syncProgress.currentStep,
-            total: params.syncProgress.totalSteps,
-          })}
-        </span>
-        <span className="text-neon-cyan font-semibold">{Math.round(params.progressPercentage)}%</span>
-      </div>
-      <div className="w-full bg-cyber-dark rounded-full h-2 overflow-hidden">
-        <div className="bg-neon-cyan h-full transition-all duration-300" style={{ width: `${params.progressPercentage}%` }} />
-      </div>
-    </div>
-  )
-}
-
-function SyncStatusMessage(params: { isSyncing: boolean; totalDays: number; isRecentlySynced: boolean }): React.ReactElement | null {
-  if (params.isSyncing || params.totalDays !== 0) {
-    return null
-  }
-  if (params.isRecentlySynced) {
-    return <p className="text-sm text-green-400">{t('settings.sync.completed')}</p>
-  }
-  return <p className="text-sm text-cyber-accent">{t('settings.sync.ready')}</p>
-}
-
-async function runAutoSyncCheck(params: {
-  connection: { connected: boolean; pubkey: string | null }
-  isSyncing: boolean
-  loadSyncStatus: () => Promise<void>
-  startMonitoring: () => void
-  stopMonitoring: () => void
-  setError: (value: string | null) => void
-}): Promise<void> {
-  console.warn('[SyncProgressBar] Starting sync check...')
-  await params.loadSyncStatus()
-
-  const shouldStart = await shouldAutoStartSync({
-    isSyncing: params.isSyncing,
-    pubkey: params.connection.pubkey,
-  })
-
-  if (!shouldStart || !params.connection.pubkey) {
-    console.warn('[SyncProgressBar] Skipping auto-sync:', { shouldStart, isSyncing: params.isSyncing, hasPubkey: Boolean(params.connection.pubkey) })
-    return
-  }
-
-  console.warn('[SyncProgressBar] Starting auto-sync...')
-  await startAutoSync({
-    pubkey: params.connection.pubkey,
-    startMonitoring: params.startMonitoring,
-    stopMonitoring: params.stopMonitoring,
-    setError: params.setError,
-  })
-}
-
-async function shouldAutoStartSync(params: { isSyncing: boolean; pubkey: string | null }): Promise<boolean> {
-  if (params.isSyncing || !params.pubkey) {
-    return false
-  }
-  const storedLastSyncDate = await getLastSyncDate()
-  const currentTimestamp = getCurrentTimestamp()
-  const isRecentlySynced = storedLastSyncDate >= currentTimestamp - 3600
-  console.warn('[SyncProgressBar] Sync status:', { storedLastSyncDate, currentTimestamp, isRecentlySynced })
-  return !isRecentlySynced
-}
-
-async function startAutoSync(params: {
-  pubkey: string
-  startMonitoring: () => void
-  stopMonitoring: () => void
-  setError: (value: string | null) => void
-}): Promise<void> {
-  try {
-    const { swClient } = await import('@/lib/swClient')
-    const isReady = await swClient.isReady()
-    if (!isReady) {
-      params.stopMonitoring()
-      return
-    }
-    await swClient.startUserSync(params.pubkey)
-    params.startMonitoring()
-  } catch (autoSyncError) {
-    console.error('[SyncProgressBar] Error during auto-sync:', autoSyncError)
-    params.stopMonitoring()
-    params.setError(autoSyncError instanceof Error ? autoSyncError.message : 'Erreur de synchronisation')
-  }
-}
+export { SyncProgressBar } from './syncProgressBar/SyncProgressBar'
diff --git a/components/UnlockAccountModal.tsx b/components/UnlockAccountModal.tsx
index 0b4c8b3..ada18c2 100644
--- a/components/UnlockAccountModal.tsx
+++ b/components/UnlockAccountModal.tsx
@@ -1,274 +1 @@
-import { useState, useRef, useMemo } from 'react'
-import { nostrAuthService } from '@/lib/nostrAuth'
-import { getWordSuggestions } from '@/lib/keyManagementBIP39'
-
-interface UnlockAccountModalProps {
-  onSuccess: () => void
-  onClose: () => void
-}
-
-function WordInputWithAutocomplete({
-  index,
-  value,
-  onChange,
-  onFocus,
-  onBlur,
-}: {
-  index: number
-  value: string
-  onChange: (value: string) => void
-  onFocus: () => void
-  onBlur: () => void
-}): React.ReactElement {
-  const [showSuggestions, setShowSuggestions] = useState(false)
-  const [selectedIndex, setSelectedIndex] = useState(-1)
-  const inputRef = useRef<HTMLInputElement>(null)
-  const suggestionsRef = useRef<HTMLDivElement>(null)
-
-  const suggestions = useMemo((): string[] => {
-    if (value.length === 0) {
-      return []
-    }
-    return getWordSuggestions(value, 5)
-  }, [value])
-
-  const handleChange = (event: React.ChangeEvent<HTMLInputElement>): void => {
-    const newValue = event.target.value.trim().toLowerCase()
-    setSelectedIndex(-1)
-    if (newValue.length === 0) {
-      setShowSuggestions(false)
-    }
-    onChange(newValue)
-  }
-
-  const handleKeyDown = (event: React.KeyboardEvent<HTMLInputElement>): void => {
-    if (event.key === 'ArrowDown') {
-      event.preventDefault()
-      setSelectedIndex((prev) => (prev < suggestions.length - 1 ? prev + 1 : prev))
-    } else if (event.key === 'ArrowUp') {
-      event.preventDefault()
-      setSelectedIndex((prev) => (prev > 0 ? prev - 1 : -1))
-    } else if (event.key === 'Enter' && selectedIndex >= 0 && suggestions[selectedIndex]) {
-      event.preventDefault()
-      onChange(suggestions[selectedIndex] ?? '')
-      setShowSuggestions(false)
-      inputRef.current?.blur()
-    } else if (event.key === 'Escape') {
-      setShowSuggestions(false)
-      inputRef.current?.blur()
-    }
-  }
-
-  const handleSuggestionClick = (suggestion: string): void => {
-    onChange(suggestion)
-    setShowSuggestions(false)
-    inputRef.current?.blur()
-  }
-
-  return (
-    <div className="relative">
-      <label htmlFor={`word-${index}`} className="block text-sm font-medium text-gray-700 mb-2">
-        Mot {index + 1}
-      </label>
-      <input
-        ref={inputRef}
-        id={`word-${index}`}
-        type="text"
-        value={value}
-        onChange={handleChange}
-        onKeyDown={handleKeyDown}
-        onFocus={onFocus}
-        onBlur={() => {
-          // Delay to allow click on suggestion
-          setTimeout(() => {
-            setShowSuggestions(false)
-            onBlur()
-          }, 200)
-        }}
-        className="w-full px-3 py-2 border border-gray-300 rounded-lg font-mono text-lg text-center"
-        autoComplete="off"
-        autoCapitalize="off"
-        autoCorrect="off"
-        spellCheck="false"
-      />
-      {showSuggestions && suggestions.length > 0 && (
-        <div
-          ref={suggestionsRef}
-          className="absolute z-10 w-full mt-1 bg-white border border-gray-300 rounded-lg shadow-lg max-h-40 overflow-y-auto"
-        >
-          {suggestions.map((suggestion, idx) => (
-            <button
-              key={suggestion}
-              type="button"
-              onClick={() => handleSuggestionClick(suggestion)}
-              className={`w-full text-left px-3 py-2 hover:bg-gray-100 ${
-                idx === selectedIndex ? 'bg-gray-100' : ''
-              }`}
-            >
-              {suggestion}
-            </button>
-          ))}
-        </div>
-      )}
-    </div>
-  )
-}
-
-function WordInputs({
-  words,
-  onWordChange,
-}: {
-  words: string[]
-  onWordChange: (index: number, value: string) => void
-}): React.ReactElement {
-  const [, setFocusedIndex] = useState<number | null>(null)
-
-  return (
-    <div className="grid grid-cols-2 gap-4">
-      {words.map((word, index) => (
-        <WordInputWithAutocomplete
-          key={`word-input-${index}-${word}`}
-          index={index}
-          value={word}
-          onChange={(value) => onWordChange(index, value)}
-          onFocus={() => setFocusedIndex(index)}
-          onBlur={() => setFocusedIndex(null)}
-        />
-      ))}
-    </div>
-  )
-}
-
-function useUnlockAccount(words: string[], setWords: (words: string[]) => void, setError: (error: string | null) => void): {
-  handleWordChange: (index: number, value: string) => void
-  handlePaste: () => void
-} {
-  const handleWordChange = (index: number, value: string): void => {
-    const newWords = [...words]
-    newWords[index] = value.trim().toLowerCase()
-    setWords(newWords)
-    setError(null)
-  }
-
-  const handlePasteAsync = async (): Promise<void> => {
-    try {
-      const text = await navigator.clipboard.readText()
-      const pastedWords = text.trim().split(/\s+/).slice(0, 4)
-      if (pastedWords.length === 4) {
-        setWords(pastedWords.map((w) => w.toLowerCase()))
-        setError(null)
-      }
-    } catch {
-      // Ignore clipboard errors
-    }
-  }
-
-  const handlePaste = (): void => {
-    void handlePasteAsync()
-  }
-
-  return { handleWordChange, handlePaste }
-}
-
-function UnlockAccountButtons({
-  loading,
-  words,
-  onUnlock,
-  onClose,
-}: {
-  loading: boolean
-  words: string[]
-  onUnlock: () => void
-  onClose: () => void
-}): React.ReactElement {
-  return (
-    <div className="flex gap-4">
-      <button
-        onClick={onClose}
-        className="flex-1 py-2 px-4 bg-gray-200 hover:bg-gray-300 rounded-lg font-medium transition-colors"
-      >
-        Annuler
-      </button>
-      <button
-        onClick={() => {
-          void onUnlock()
-        }}
-        disabled={loading || words.some((word) => !word)}
-        className="flex-1 py-2 px-4 bg-neon-cyan/20 hover:bg-neon-cyan/30 text-neon-cyan rounded-lg font-medium transition-all border border-neon-cyan/50 hover:shadow-glow-cyan disabled:opacity-50"
-      >
-        {loading ? 'Déverrouillage...' : 'Déverrouiller'}
-      </button>
-    </div>
-  )
-}
-
-function UnlockAccountForm({
-  words,
-  handleWordChange,
-  handlePaste,
-}: {
-  words: string[]
-  handleWordChange: (index: number, value: string) => void
-  handlePaste: () => void
-}): React.ReactElement {
-  return (
-    <div className="mb-4">
-      <WordInputs words={words} onWordChange={handleWordChange} />
-      <button
-        type="button"
-        onClick={() => {
-          void handlePaste()
-        }}
-        className="mt-2 text-sm text-gray-600 hover:text-gray-800 underline"
-      >
-        Coller depuis le presse-papiers
-      </button>
-    </div>
-  )
-}
-
-export function UnlockAccountModal({ onSuccess, onClose }: UnlockAccountModalProps): React.ReactElement {
-  const [words, setWords] = useState(['', '', '', ''])
-  const [loading, setLoading] = useState(false)
-  const [error, setError] = useState<string | null>(null)
-
-  const { handleWordChange, handlePaste } = useUnlockAccount(words, setWords, setError)
-
-  const handleUnlock = async (): Promise<void> => {
-    if (words.some((word) => !word)) {
-      setError('Veuillez remplir tous les mots-clés')
-      return
-    }
-
-    setLoading(true)
-    setError(null)
-    try {
-      await nostrAuthService.unlockAccount(words)
-      onSuccess()
-      onClose()
-    } catch (unlockError) {
-      setError(unlockError instanceof Error ? unlockError.message : 'Échec du déverrouillage. Vérifiez vos mots-clés.')
-    } finally {
-      setLoading(false)
-    }
-  }
-
-  const onUnlock = (): void => {
-    void handleUnlock()
-  }
-
-  return (
-    <div className="fixed inset-0 bg-black bg-opacity-50 flex items-center justify-center z-50">
-      <div className="bg-white rounded-lg p-6 max-w-md w-full mx-4">
-        <h2 className="text-2xl font-bold mb-4">Déverrouiller votre compte</h2>
-        <p className="text-gray-600 mb-6">
-          Entrez vos 4 mots-clés de récupération (dictionnaire BIP39) pour déverrouiller votre compte.
-          Ces mots déchiffrent la clé de chiffrement (KEK) stockée dans l&apos;API Credentials, qui déchiffre ensuite votre clé privée.
-        </p>
-        <UnlockAccountForm words={words} handleWordChange={handleWordChange} handlePaste={handlePaste} />
-        {error && <p className="text-sm text-red-600 mb-4">{error}</p>}
-        <UnlockAccountButtons loading={loading} words={words} onUnlock={onUnlock} onClose={onClose} />
-      </div>
-    </div>
-  )
-}
+export { UnlockAccountModal } from './unlockAccount/UnlockAccountModal'
diff --git a/components/UserArticles.tsx b/components/UserArticles.tsx
index 7cc9841..9854e07 100644
--- a/components/UserArticles.tsx
+++ b/components/UserArticles.tsx
@@ -1,325 +1 @@
-import { useMemo, useState, type Dispatch, type SetStateAction } from 'react'
-import type { Article } from '@/types/nostr'
-import type { ArticleDraft } from '@/lib/articlePublisherTypes'
-import { useArticleEditing } from '@/hooks/useArticleEditing'
-import { UserArticlesView } from './UserArticlesList'
-import { EditPanel } from './UserArticlesEditPanel'
-
-interface UserArticlesProps {
-  articles: Article[]
-  loading: boolean
-  error: string | null
-  onLoadContent: (articleId: string, authorPubkey: string) => Promise<Article | null>
-  showEmptyMessage?: boolean
-  currentPubkey: string | null
-  onSelectSeries?: ((seriesId: string | undefined) => void) | undefined
-}
-
-type UserArticlesController = {
-  localArticles: Article[]
-  unlockedArticles: Set<string>
-  pendingDeleteId: string | null
-  requestDelete: (id: string) => void
-  handleUnlock: (article: Article) => Promise<void>
-  handleDelete: (article: Article) => Promise<void>
-  handleEditSubmit: () => Promise<void>
-  editingDraft: ArticleDraft | null
-  editingArticleId: string | null
-  loading: boolean
-  error: string | null
-  updateDraft: (draft: ArticleDraft) => void
-  startEditing: (article: Article) => Promise<void>
-  cancelEditing: () => void
-  submitEdit: () => Promise<import('@/lib/articleMutations').ArticleUpdateResult | null>
-  deleteArticle: (id: string) => Promise<boolean>
-}
-
-export function UserArticles({
-  articles,
-  loading,
-  error,
-  onLoadContent,
-  showEmptyMessage = true,
-  currentPubkey,
-  onSelectSeries,
-}: UserArticlesProps): React.ReactElement {
-  const controller = useUserArticlesController({ articles, onLoadContent, currentPubkey })
-  return (
-    <UserArticlesLayout
-      controller={controller}
-      loading={loading}
-      error={error}
-      showEmptyMessage={showEmptyMessage ?? true}
-      currentPubkey={currentPubkey}
-      onSelectSeries={onSelectSeries}
-    />
-  )
-}
-
-function useUserArticlesController({
-  articles,
-  onLoadContent,
-  currentPubkey,
-}: {
-  articles: Article[]
-  onLoadContent: (articleId: string, authorPubkey: string) => Promise<Article | null>
-  currentPubkey: string | null
-}): UserArticlesController {
-  const [deletedArticleIds, setDeletedArticleIds] = useState<Set<string>>(new Set())
-  const [articleOverridesById, setArticleOverridesById] = useState<Map<string, Article>>(new Map())
-  const [unlockedArticles, setUnlockedArticles] = useState<Set<string>>(new Set())
-  const [pendingDeleteId, setPendingDeleteId] = useState<string | null>(null)
-  const editingCtx = useArticleEditing(currentPubkey)
-
-  const localArticles = useMemo((): Article[] => {
-    return articles
-      .filter((a) => !deletedArticleIds.has(a.id))
-      .map((a) => articleOverridesById.get(a.id) ?? a)
-  }, [articles, articleOverridesById, deletedArticleIds])
-
-  return {
-    localArticles,
-    unlockedArticles,
-    pendingDeleteId,
-    requestDelete: (id: string) => setPendingDeleteId(id),
-    handleUnlock: createHandleUnlock(onLoadContent, setUnlockedArticles),
-    handleDelete: createHandleDelete(editingCtx.deleteArticle, setDeletedArticleIds, setPendingDeleteId),
-    handleEditSubmit: createHandleEditSubmit(
-      editingCtx.submitEdit,
-      editingCtx.editingDraft,
-      currentPubkey,
-      setArticleOverridesById
-    ),
-    ...editingCtx,
-  }
-}
-
-function createHandleUnlock(
-  onLoadContent: (id: string, pubkey: string) => Promise<Article | null>,
-  setUnlocked: Dispatch<SetStateAction<Set<string>>>
-): (article: Article) => Promise<void> {
-  return async (article: Article): Promise<void> => {
-    const full = await onLoadContent(article.id, article.pubkey)
-    if (full?.paid) {
-      setUnlocked((prev) => new Set([...prev, article.id]))
-    }
-  }
-}
-
-function createHandleDelete(
-  deleteArticle: (id: string) => Promise<boolean>,
-  setDeletedArticleIds: Dispatch<SetStateAction<Set<string>>>,
-  setPendingDeleteId: Dispatch<SetStateAction<string | null>>
-): (article: Article) => Promise<void> {
-  return async (article: Article): Promise<void> => {
-    const ok = await deleteArticle(article.id)
-    if (ok) {
-      setDeletedArticleIds((prev) => new Set([...prev, article.id]))
-    }
-    setPendingDeleteId(null)
-  }
-}
-
-function createHandleEditSubmit(
-  submitEdit: () => Promise<import('@/lib/articleMutations').ArticleUpdateResult | null>,
-  draft: ReturnType<typeof useArticleEditing>['editingDraft'],
-  currentPubkey: string | null,
-  setArticleOverridesById: Dispatch<SetStateAction<Map<string, Article>>>
-): () => Promise<void> {
-  return async (): Promise<void> => {
-    const result = await submitEdit()
-    if (result && draft) {
-      const updated = buildUpdatedArticle(draft, currentPubkey ?? '', result.articleId)
-      setArticleOverridesById((prev) => {
-        const next = new Map(prev)
-        next.set(result.originalArticleId, { ...updated, id: result.originalArticleId })
-        return next
-      })
-    }
-  }
-}
-
-function buildUpdatedArticle(
-  draft: NonNullable<ReturnType<typeof useArticleEditing>['editingDraft']>,
-  pubkey: string,
-  newId: string
-): Article {
-  const hash = newId.split('_')[0] ?? ''
-  const index = Number.parseInt(newId.split('_')[1] ?? '0', 10)
-  const version = Number.parseInt(newId.split('_')[2] ?? '0', 10)
-  return {
-    id: newId,
-    hash,
-    version,
-    index,
-    pubkey,
-    title: draft.title,
-    preview: draft.preview,
-    content: '',
-    description: draft.preview,
-    contentDescription: draft.preview,
-    createdAt: Math.floor(Date.now() / 1000),
-    zapAmount: draft.zapAmount,
-    paid: false,
-    thumbnailUrl: draft.bannerUrl ?? '',
-    ...(draft.category ? { category: draft.category } : {}),
-    ...(draft.seriesId ? { seriesId: draft.seriesId } : {}),
-    ...(draft.bannerUrl ? { bannerUrl: draft.bannerUrl } : {}),
-    ...(draft.media ? { media: draft.media } : {}),
-    ...(draft.pages ? { pages: draft.pages } : {}),
-  }
-}
-
-function UserArticlesLayout({
-  controller,
-  loading,
-  error,
-  showEmptyMessage,
-  currentPubkey,
-  onSelectSeries,
-}: {
-  controller: ReturnType<typeof useUserArticlesController>
-  loading: boolean
-  error: string | null
-  showEmptyMessage: boolean
-  currentPubkey: string | null
-  onSelectSeries?: ((seriesId: string | undefined) => void) | undefined
-}): React.ReactElement {
-  const { editPanelProps, listProps } = createLayoutProps(controller, {
-    loading,
-    error,
-    showEmptyMessage,
-    currentPubkey,
-    onSelectSeries,
-  })
-
-  return (
-    <div className="space-y-4">
-      <EditPanel {...editPanelProps} />
-      <UserArticlesView {...listProps} />
-    </div>
-  )
-}
-
-function createLayoutProps(
-  controller: UserArticlesController,
-  view: {
-    loading: boolean
-    error: string | null
-    showEmptyMessage: boolean
-    currentPubkey: string | null
-    onSelectSeries?: ((seriesId: string | undefined) => void) | undefined
-  }
-): {
-  editPanelProps: {
-    draft: ArticleDraft | null
-    editingArticleId: string | null
-    loading: boolean
-    error: string | null
-    onCancel: () => void
-    onDraftChange: (draft: ArticleDraft) => void
-    onSubmit: () => Promise<void>
-  }
-  listProps: {
-    articles: Article[]
-    loading: boolean
-    error: string | null
-    showEmptyMessage: boolean
-    unlockedArticles: Set<string>
-    onUnlock: (article: Article) => void
-    onEdit: (article: Article) => void
-    onDelete: (article: Article) => void
-    editingArticleId: string | null
-    currentPubkey: string | null
-    pendingDeleteId: string | null
-    requestDelete: (articleId: string) => void
-    onSelectSeries?: ((seriesId: string | undefined) => void) | undefined
-  }
-} {
-  return {
-    editPanelProps: buildEditPanelProps(controller),
-    listProps: buildListProps(controller, view),
-  }
-}
-
-function buildEditPanelProps(controller: UserArticlesController): {
-  draft: ArticleDraft | null
-  editingArticleId: string | null
-  loading: boolean
-  error: string | null
-  onCancel: () => void
-  onDraftChange: (draft: ArticleDraft) => void
-  onSubmit: () => Promise<void>
-} {
-  return {
-    draft: controller.editingDraft,
-    editingArticleId: controller.editingArticleId,
-    loading: controller.loading,
-    error: controller.error,
-    onCancel: controller.cancelEditing,
-    onDraftChange: controller.updateDraft,
-    onSubmit: controller.handleEditSubmit,
-  }
-}
-
-type UserArticlesListProps = {
-  articles: Article[]
-  loading: boolean
-  error: string | null
-  showEmptyMessage: boolean
-  unlockedArticles: Set<string>
-  onUnlock: (article: Article) => void
-  onEdit: (article: Article) => void
-  onDelete: (article: Article) => void
-  editingArticleId: string | null
-  currentPubkey: string | null
-  pendingDeleteId: string | null
-  requestDelete: (articleId: string) => void
-  onSelectSeries?: ((seriesId: string | undefined) => void) | undefined
-}
-
-function buildListProps(
-  controller: UserArticlesController,
-  view: {
-    loading: boolean
-    error: string | null
-    showEmptyMessage: boolean
-    currentPubkey: string | null
-    onSelectSeries?: ((seriesId: string | undefined) => void) | undefined
-  }
-): UserArticlesListProps {
-  const handlers = buildUserArticlesHandlers(controller)
-  return {
-    articles: controller.localArticles,
-    loading: view.loading,
-    error: view.error,
-    showEmptyMessage: view.showEmptyMessage,
-    unlockedArticles: controller.unlockedArticles,
-    onUnlock: handlers.onUnlock,
-    onEdit: handlers.onEdit,
-    onDelete: handlers.onDelete,
-    editingArticleId: controller.editingArticleId,
-    currentPubkey: view.currentPubkey,
-    pendingDeleteId: controller.pendingDeleteId,
-    requestDelete: controller.requestDelete,
-    ...(view.onSelectSeries ? { onSelectSeries: view.onSelectSeries } : {}),
-  }
-}
-
-function buildUserArticlesHandlers(controller: UserArticlesController): {
-  onUnlock: (article: Article) => void
-  onEdit: (article: Article) => void
-  onDelete: (article: Article) => void
-} {
-  return {
-    onUnlock: (a: Article): void => {
-      void controller.handleUnlock(a)
-    },
-    onEdit: (a: Article): void => {
-      void controller.startEditing(a)
-    },
-    onDelete: (a: Article): void => {
-      void controller.handleDelete(a)
-    },
-  }
-}
+export { UserArticles } from './userArticles/UserArticles'
diff --git a/components/authorPresentationEditor/AuthorPresentationEditor.tsx b/components/authorPresentationEditor/AuthorPresentationEditor.tsx
new file mode 100644
index 0000000..6872240
--- /dev/null
+++ b/components/authorPresentationEditor/AuthorPresentationEditor.tsx
@@ -0,0 +1,80 @@
+import { useEffect } from 'react'
+import { useNostrAuth } from '@/hooks/useNostrAuth'
+import { useAuthorPresentation } from '@/hooks/useAuthorPresentation'
+import { t } from '@/lib/i18n'
+import { NoAccountView } from './NoAccountView'
+import { PresentationForm } from './PresentationForm'
+import { useExistingPresentation } from './useExistingPresentation'
+import { useAuthorPresentationState } from './useAuthorPresentationState'
+
+function SuccessNotice(params: { pubkey: string | null }): React.ReactElement {
+  return (
+    <div className="border border-neon-green/50 rounded-lg p-6 bg-neon-green/10">
+      <h3 className="text-lg font-semibold text-neon-green mb-2">{t('presentation.success')}</h3>
+      <p className="text-cyber-accent mb-4">{t('presentation.successMessage')}</p>
+      {params.pubkey ? (
+        <div className="mt-4">
+          <a
+            href={`/author/${params.pubkey}`}
+            className="inline-block px-4 py-2 bg-neon-cyan/20 hover:bg-neon-cyan/30 text-neon-cyan rounded-lg font-medium transition-all border border-neon-cyan/50 hover:shadow-glow-cyan"
+          >
+            {t('presentation.manageSeries')}
+          </a>
+        </div>
+      ) : null}
+    </div>
+  )
+}
+
+function LoadingNotice(): React.ReactElement {
+  return (
+    <div className="text-center py-12">
+      <p className="text-cyber-accent/70">{t('common.loading')}</p>
+    </div>
+  )
+}
+
+function AuthorPresentationFormView(props: { pubkey: string | null; profile: { name?: string; pubkey: string } | null }): React.ReactElement {
+  const { checkPresentationExists } = useAuthorPresentation(props.pubkey)
+  const presentation = useExistingPresentation({ pubkey: props.pubkey, checkPresentationExists })
+  const state = useAuthorPresentationState(props.pubkey, props.profile?.name, presentation.existingPresentation)
+
+  if (!props.pubkey) {
+    return <NoAccountView />
+  }
+  if (presentation.loadingPresentation) {
+    return <LoadingNotice />
+  }
+  if (state.success) {
+    return <SuccessNotice pubkey={props.pubkey} />
+  }
+  return (
+    <PresentationForm
+      draft={state.draft}
+      setDraft={state.setDraft}
+      validationError={state.validationError}
+      error={state.error}
+      loading={state.loading}
+      handleSubmit={state.handleSubmit}
+      deleting={state.deleting}
+      handleDelete={() => {
+        void state.handleDelete()
+      }}
+      hasExistingPresentation={presentation.existingPresentation !== null}
+    />
+  )
+}
+
+function useAutoLoadPubkey(accountExists: boolean | null, pubkey: string | null, connect: () => Promise<void>): void {
+  useEffect(() => {
+    if (accountExists === true && !pubkey) {
+      void connect()
+    }
+  }, [accountExists, pubkey, connect])
+}
+
+export function AuthorPresentationEditor(): React.ReactElement {
+  const { pubkey, profile, accountExists, connect } = useNostrAuth()
+  useAutoLoadPubkey(accountExists, pubkey ?? null, connect)
+  return <AuthorPresentationFormView pubkey={pubkey ?? null} profile={profile} />
+}
diff --git a/components/authorPresentationEditor/NoAccountView.tsx b/components/authorPresentationEditor/NoAccountView.tsx
new file mode 100644
index 0000000..39a9a84
--- /dev/null
+++ b/components/authorPresentationEditor/NoAccountView.tsx
@@ -0,0 +1,147 @@
+import { useState } from 'react'
+import { CreateAccountModal } from '../CreateAccountModal'
+import { RecoveryStep } from '../CreateAccountModalSteps'
+import { UnlockAccountModal } from '../UnlockAccountModal'
+import { t } from '@/lib/i18n'
+
+export function NoAccountView(): React.ReactElement {
+  const [showImportModal, setShowImportModal] = useState(false)
+  const [showRecoveryStep, setShowRecoveryStep] = useState(false)
+  const [showUnlockModal, setShowUnlockModal] = useState(false)
+  const [recoveryPhrase, setRecoveryPhrase] = useState<string[]>([])
+  const [npub, setNpub] = useState('')
+  const [generating, setGenerating] = useState(false)
+  const [error, setError] = useState<string | null>(null)
+
+  const handleGenerate = (): void => {
+    void generateNoAccount({ setGenerating, setError, setRecoveryPhrase, setNpub, setShowRecoveryStep })
+  }
+  const handleRecoveryContinue = (): void => transitionToUnlock({ setShowRecoveryStep, setShowUnlockModal })
+  const handleUnlockSuccess = (): void => resetNoAccountAfterUnlock({ setShowUnlockModal, setRecoveryPhrase, setNpub })
+  const handleImportSuccess = (): void => {
+    setShowImportModal(false)
+    setShowUnlockModal(true)
+  }
+
+  return (
+    <NoAccountCard
+      error={error}
+      generating={generating}
+      onGenerate={handleGenerate}
+      onImport={() => setShowImportModal(true)}
+      modals={
+        <NoAccountModals
+          showImportModal={showImportModal}
+          onCloseImport={() => setShowImportModal(false)}
+          onImportSuccess={handleImportSuccess}
+          showRecoveryStep={showRecoveryStep}
+          recoveryPhrase={recoveryPhrase}
+          npub={npub}
+          onRecoveryContinue={handleRecoveryContinue}
+          showUnlockModal={showUnlockModal}
+          onUnlockSuccess={handleUnlockSuccess}
+          onCloseUnlock={() => setShowUnlockModal(false)}
+        />
+      }
+    />
+  )
+}
+
+function NoAccountActionButtons(params: { onGenerate: () => void; onImport: () => void }): React.ReactElement {
+  return (
+    <div className="flex flex-col gap-3 w-full max-w-xs">
+      <button
+        type="button"
+        onClick={params.onGenerate}
+        className="px-6 py-2 bg-neon-cyan/20 hover:bg-neon-cyan/30 text-neon-cyan rounded-lg font-medium transition-all border border-neon-cyan/50 hover:shadow-glow-cyan"
+      >
+        {t('account.create.generateButton')}
+      </button>
+      <button
+        type="button"
+        onClick={params.onImport}
+        className="px-6 py-2 bg-gray-100 hover:bg-gray-200 text-gray-700 rounded-lg font-medium transition-colors"
+      >
+        {t('account.create.importButton')}
+      </button>
+    </div>
+  )
+}
+
+function NoAccountCard(params: {
+  error: string | null
+  generating: boolean
+  onGenerate: () => void
+  onImport: () => void
+  modals: React.ReactElement
+}): React.ReactElement {
+  return (
+    <div className="border border-neon-cyan/20 rounded-lg p-6 bg-cyber-dark/50">
+      <div className="flex flex-col items-center gap-4">
+        <p className="text-center text-cyber-accent mb-2">Créez un compte ou importez votre clé secrète pour commencer</p>
+        {params.error ? <p className="text-sm text-red-400">{params.error}</p> : null}
+        <NoAccountActionButtons onGenerate={params.onGenerate} onImport={params.onImport} />
+        {params.generating ? <p className="text-cyber-accent text-sm">Génération du compte...</p> : null}
+        {params.modals}
+      </div>
+    </div>
+  )
+}
+
+function NoAccountModals(params: {
+  showImportModal: boolean
+  onImportSuccess: () => void
+  onCloseImport: () => void
+  showRecoveryStep: boolean
+  recoveryPhrase: string[]
+  npub: string
+  onRecoveryContinue: () => void
+  showUnlockModal: boolean
+  onUnlockSuccess: () => void
+  onCloseUnlock: () => void
+}): React.ReactElement {
+  return (
+    <>
+      {params.showImportModal ? <CreateAccountModal onSuccess={params.onImportSuccess} onClose={params.onCloseImport} initialStep="import" /> : null}
+      {params.showRecoveryStep ? <RecoveryStep recoveryPhrase={params.recoveryPhrase} npub={params.npub} onContinue={params.onRecoveryContinue} /> : null}
+      {params.showUnlockModal ? <UnlockAccountModal onSuccess={params.onUnlockSuccess} onClose={params.onCloseUnlock} /> : null}
+    </>
+  )
+}
+
+async function generateNoAccount(params: {
+  setGenerating: (value: boolean) => void
+  setError: (value: string | null) => void
+  setRecoveryPhrase: (value: string[]) => void
+  setNpub: (value: string) => void
+  setShowRecoveryStep: (value: boolean) => void
+}): Promise<void> {
+  params.setGenerating(true)
+  params.setError(null)
+  try {
+    const { nostrAuthService } = await import('@/lib/nostrAuth')
+    const result = await nostrAuthService.createAccount()
+    params.setRecoveryPhrase(result.recoveryPhrase)
+    params.setNpub(result.npub)
+    params.setShowRecoveryStep(true)
+  } catch (e) {
+    params.setError(e instanceof Error ? e.message : t('account.create.error.failed'))
+  } finally {
+    params.setGenerating(false)
+  }
+}
+
+function transitionToUnlock(params: { setShowRecoveryStep: (value: boolean) => void; setShowUnlockModal: (value: boolean) => void }): void {
+  params.setShowRecoveryStep(false)
+  params.setShowUnlockModal(true)
+}
+
+function resetNoAccountAfterUnlock(params: {
+  setShowUnlockModal: (value: boolean) => void
+  setRecoveryPhrase: (value: string[]) => void
+  setNpub: (value: string) => void
+}): void {
+  params.setShowUnlockModal(false)
+  params.setRecoveryPhrase([])
+  params.setNpub('')
+}
diff --git a/components/authorPresentationEditor/PresentationForm.tsx b/components/authorPresentationEditor/PresentationForm.tsx
new file mode 100644
index 0000000..33d24a0
--- /dev/null
+++ b/components/authorPresentationEditor/PresentationForm.tsx
@@ -0,0 +1,75 @@
+import type { FormEvent } from 'react'
+import { PresentationFormHeader } from '../PresentationFormHeader'
+import { t } from '@/lib/i18n'
+import { PresentationFields } from './fields'
+import type { AuthorPresentationDraft } from './types'
+
+export interface PresentationFormProps {
+  draft: AuthorPresentationDraft
+  setDraft: (next: AuthorPresentationDraft) => void
+  validationError: string | null
+  error: string | null
+  loading: boolean
+  handleSubmit: (e: FormEvent<HTMLFormElement>) => Promise<void>
+  deleting: boolean
+  handleDelete: () => void
+  hasExistingPresentation: boolean
+}
+
+export function PresentationForm(props: PresentationFormProps): React.ReactElement {
+  return (
+    <form
+      onSubmit={(e: FormEvent<HTMLFormElement>) => {
+        void props.handleSubmit(e)
+      }}
+      className="border border-neon-cyan/20 rounded-lg p-6 bg-cyber-dark space-y-4"
+    >
+      <PresentationFormHeader />
+      <PresentationFields draft={props.draft} onChange={props.setDraft} />
+      <ValidationError message={props.validationError ?? props.error} />
+      <div className="flex items-center gap-4">
+        <div className="flex-1">
+          <button
+            type="submit"
+            disabled={props.loading || props.deleting}
+            className="w-full px-4 py-2 bg-neon-cyan/20 hover:bg-neon-cyan/30 text-neon-cyan rounded-lg font-medium transition-all border border-neon-cyan/50 hover:shadow-glow-cyan disabled:opacity-50 disabled:cursor-not-allowed"
+          >
+            {getSubmitLabel({ loading: props.loading, deleting: props.deleting, hasExistingPresentation: props.hasExistingPresentation })}
+          </button>
+        </div>
+        {props.hasExistingPresentation ? <DeleteButton onDelete={props.handleDelete} deleting={props.deleting} /> : null}
+      </div>
+    </form>
+  )
+}
+
+function ValidationError(params: { message: string | null }): React.ReactElement | null {
+  if (!params.message) {
+    return null
+  }
+  return (
+    <div className="bg-red-500/10 border border-red-500/50 rounded-lg p-3">
+      <p className="text-sm text-red-400">{params.message}</p>
+    </div>
+  )
+}
+
+function DeleteButton(params: { onDelete: () => void; deleting: boolean }): React.ReactElement {
+  return (
+    <button
+      type="button"
+      onClick={params.onDelete}
+      disabled={params.deleting}
+      className="px-4 py-2 bg-red-500/20 hover:bg-red-500/30 text-red-400 rounded-lg text-sm font-medium transition-all border border-red-500/50 hover:shadow-glow-red disabled:opacity-50"
+    >
+      {params.deleting ? t('presentation.delete.deleting') : t('presentation.delete.button')}
+    </button>
+  )
+}
+
+function getSubmitLabel(params: { loading: boolean; deleting: boolean; hasExistingPresentation: boolean }): string {
+  if (params.loading || params.deleting) {
+    return t('publish.publishing')
+  }
+  return params.hasExistingPresentation ? t('presentation.update.button') : t('publish.button')
+}
diff --git a/components/authorPresentationEditor/fields.tsx b/components/authorPresentationEditor/fields.tsx
new file mode 100644
index 0000000..dadf89a
--- /dev/null
+++ b/components/authorPresentationEditor/fields.tsx
@@ -0,0 +1,88 @@
+import { ArticleField } from '../ArticleField'
+import { ImageUploadField } from '../ImageUploadField'
+import { t } from '@/lib/i18n'
+import type { AuthorPresentationDraft } from './types'
+
+export function PresentationFields(params: {
+  draft: AuthorPresentationDraft
+  onChange: (next: AuthorPresentationDraft) => void
+}): React.ReactElement {
+  return (
+    <div className="space-y-4">
+      <AuthorNameField draft={params.draft} onChange={params.onChange} />
+      <PictureField draft={params.draft} onChange={params.onChange} />
+      <PresentationField draft={params.draft} onChange={params.onChange} />
+      <ContentDescriptionField draft={params.draft} onChange={params.onChange} />
+      <MainnetAddressField draft={params.draft} onChange={params.onChange} />
+    </div>
+  )
+}
+
+function PresentationField(params: { draft: AuthorPresentationDraft; onChange: (next: AuthorPresentationDraft) => void }): React.ReactElement {
+  return (
+    <ArticleField
+      id="presentation"
+      label={t('presentation.field.presentation')}
+      value={params.draft.presentation}
+      onChange={(value) => params.onChange({ ...params.draft, presentation: value as string })}
+      required
+      type="textarea"
+      rows={6}
+      placeholder={t('presentation.field.presentation.placeholder')}
+      helpText={t('presentation.field.presentation.help')}
+    />
+  )
+}
+
+function ContentDescriptionField(params: {
+  draft: AuthorPresentationDraft
+  onChange: (next: AuthorPresentationDraft) => void
+}): React.ReactElement {
+  return (
+    <ArticleField
+      id="contentDescription"
+      label={t('presentation.field.contentDescription')}
+      value={params.draft.contentDescription}
+      onChange={(value) => params.onChange({ ...params.draft, contentDescription: value as string })}
+      required
+      type="textarea"
+      rows={6}
+      placeholder={t('presentation.field.contentDescription.placeholder')}
+      helpText={t('presentation.field.contentDescription.help')}
+    />
+  )
+}
+
+function MainnetAddressField(params: { draft: AuthorPresentationDraft; onChange: (next: AuthorPresentationDraft) => void }): React.ReactElement {
+  return (
+    <ArticleField
+      id="mainnetAddress"
+      label={t('presentation.field.mainnetAddress')}
+      value={params.draft.mainnetAddress}
+      onChange={(value) => params.onChange({ ...params.draft, mainnetAddress: value as string })}
+      required
+      type="text"
+      placeholder={t('presentation.field.mainnetAddress.placeholder')}
+      helpText={t('presentation.field.mainnetAddress.help')}
+    />
+  )
+}
+
+function AuthorNameField(params: { draft: AuthorPresentationDraft; onChange: (next: AuthorPresentationDraft) => void }): React.ReactElement {
+  return (
+    <ArticleField
+      id="authorName"
+      label={t('presentation.field.authorName')}
+      value={params.draft.authorName}
+      onChange={(value) => params.onChange({ ...params.draft, authorName: value as string })}
+      required
+      type="text"
+      placeholder={t('presentation.field.authorName.placeholder')}
+      helpText={t('presentation.field.authorName.help')}
+    />
+  )
+}
+
+function PictureField(params: { draft: AuthorPresentationDraft; onChange: (next: AuthorPresentationDraft) => void }): React.ReactElement {
+  return <ImageUploadField id="picture" value={params.draft.pictureUrl} onChange={(url) => params.onChange({ ...params.draft, pictureUrl: url })} />
+}
diff --git a/components/authorPresentationEditor/types.ts b/components/authorPresentationEditor/types.ts
new file mode 100644
index 0000000..58d5b40
--- /dev/null
+++ b/components/authorPresentationEditor/types.ts
@@ -0,0 +1,7 @@
+export interface AuthorPresentationDraft {
+  authorName: string
+  presentation: string
+  contentDescription: string
+  mainnetAddress: string
+  pictureUrl?: string
+}
diff --git a/components/authorPresentationEditor/useAuthorPresentationState.ts b/components/authorPresentationEditor/useAuthorPresentationState.ts
new file mode 100644
index 0000000..6cd654a
--- /dev/null
+++ b/components/authorPresentationEditor/useAuthorPresentationState.ts
@@ -0,0 +1,124 @@
+import { useCallback, useEffect, useState, type Dispatch, type FormEvent, type SetStateAction } from 'react'
+import { useRouter } from 'next/router'
+import { useAuthorPresentation } from '@/hooks/useAuthorPresentation'
+import { extractPresentationData } from '@/lib/presentationParsing'
+import { userConfirm } from '@/lib/userConfirm'
+import { t } from '@/lib/i18n'
+import type { Article } from '@/types/nostr'
+import type { AuthorPresentationDraft } from './types'
+import { validatePresentationDraft } from './validation'
+
+export interface AuthorPresentationState {
+  draft: AuthorPresentationDraft
+  setDraft: (next: AuthorPresentationDraft) => void
+  validationError: string | null
+  error: string | null
+  loading: boolean
+  handleSubmit: (e: FormEvent<HTMLFormElement>) => Promise<void>
+  deleting: boolean
+  handleDelete: () => Promise<void>
+  success: boolean
+}
+
+export function useAuthorPresentationState(
+  pubkey: string | null,
+  existingAuthorName: string | undefined,
+  existingPresentation: Article | null | undefined,
+): AuthorPresentationState {
+  const { loading, error, success, publishPresentation, deletePresentation } = useAuthorPresentation(pubkey)
+  const router = useRouter()
+  const [draft, setDraft] = useState<AuthorPresentationDraft>(() => buildInitialDraft(existingPresentation, existingAuthorName))
+  const [validationError, setValidationError] = useState<string | null>(null)
+  const [deleting, setDeleting] = useState(false)
+
+  useEffect(() => {
+    syncAuthorNameIntoDraft({ existingAuthorName, draftAuthorName: draft.authorName, hasExistingPresentation: Boolean(existingPresentation), setDraft })
+  }, [existingAuthorName, existingPresentation, draft.authorName])
+
+  const handleSubmit = useCallback(
+    async (e: FormEvent<HTMLFormElement>) => {
+      e.preventDefault()
+      await submitPresentationDraft({ draft, setValidationError, publishPresentation })
+    },
+    [draft, publishPresentation],
+  )
+
+  const handleDelete = useCallback(async () => {
+    await deletePresentationFlow({
+      existingPresentationId: existingPresentation?.id,
+      deletePresentation,
+      router,
+      setDeleting,
+      setValidationError,
+    })
+  }, [existingPresentation, deletePresentation, router])
+
+  return { loading, error, success, draft, setDraft, validationError, handleSubmit, deleting, handleDelete }
+}
+
+function buildInitialDraft(existingPresentation: Article | null | undefined, existingAuthorName: string | undefined): AuthorPresentationDraft {
+  if (existingPresentation) {
+    const { presentation, contentDescription } = extractPresentationData(existingPresentation)
+    const authorName = existingPresentation.title.replace(/^Présentation de /, '') ?? existingAuthorName ?? ''
+    return {
+      authorName,
+      presentation,
+      contentDescription,
+      mainnetAddress: existingPresentation.mainnetAddress ?? '',
+      ...(existingPresentation.bannerUrl ? { pictureUrl: existingPresentation.bannerUrl } : {}),
+    }
+  }
+  return { authorName: existingAuthorName ?? '', presentation: '', contentDescription: '', mainnetAddress: '' }
+}
+
+function syncAuthorNameIntoDraft(params: {
+  existingAuthorName: string | undefined
+  draftAuthorName: string
+  hasExistingPresentation: boolean
+  setDraft: Dispatch<SetStateAction<AuthorPresentationDraft>>
+}): void {
+  if (!params.existingAuthorName || params.hasExistingPresentation || params.existingAuthorName === params.draftAuthorName) {
+    return
+  }
+  params.setDraft((prev) => ({ ...prev, authorName: params.existingAuthorName as string }))
+}
+
+async function submitPresentationDraft(params: {
+  draft: AuthorPresentationDraft
+  setValidationError: (value: string | null) => void
+  publishPresentation: (draft: AuthorPresentationDraft) => Promise<void>
+}): Promise<void> {
+  const validationError = validatePresentationDraft(params.draft)
+  if (validationError) {
+    params.setValidationError(validationError)
+    return
+  }
+  params.setValidationError(null)
+  await params.publishPresentation(params.draft)
+}
+
+async function deletePresentationFlow(params: {
+  existingPresentationId: string | undefined
+  deletePresentation: (articleId: string) => Promise<void>
+  router: ReturnType<typeof useRouter>
+  setDeleting: (value: boolean) => void
+  setValidationError: (value: string | null) => void
+}): Promise<void> {
+  if (!params.existingPresentationId) {
+    return
+  }
+  const confirmed = await userConfirm(t('presentation.delete.confirm'))
+  if (!confirmed) {
+    return
+  }
+  params.setDeleting(true)
+  params.setValidationError(null)
+  try {
+    await params.deletePresentation(params.existingPresentationId)
+    await params.router.push('/')
+  } catch (e) {
+    params.setValidationError(e instanceof Error ? e.message : t('presentation.delete.error'))
+  } finally {
+    params.setDeleting(false)
+  }
+}
diff --git a/components/authorPresentationEditor/useExistingPresentation.ts b/components/authorPresentationEditor/useExistingPresentation.ts
new file mode 100644
index 0000000..2d2c1a8
--- /dev/null
+++ b/components/authorPresentationEditor/useExistingPresentation.ts
@@ -0,0 +1,40 @@
+import { useEffect, useState } from 'react'
+import type { Article } from '@/types/nostr'
+
+export function useExistingPresentation(params: {
+  pubkey: string | null
+  checkPresentationExists: () => Promise<Article | null>
+}): { existingPresentation: Article | null; loadingPresentation: boolean } {
+  const [existingPresentation, setExistingPresentation] = useState<Article | null>(null)
+  const [loadingPresentation, setLoadingPresentation] = useState(true)
+
+  useEffect(() => {
+    void loadExistingPresentation({
+      pubkey: params.pubkey,
+      checkPresentationExists: params.checkPresentationExists,
+      setExistingPresentation,
+      setLoadingPresentation,
+    })
+  }, [params.pubkey, params.checkPresentationExists])
+
+  return { existingPresentation, loadingPresentation }
+}
+
+async function loadExistingPresentation(params: {
+  pubkey: string | null
+  checkPresentationExists: () => Promise<Article | null>
+  setExistingPresentation: (value: Article | null) => void
+  setLoadingPresentation: (value: boolean) => void
+}): Promise<void> {
+  if (!params.pubkey) {
+    params.setLoadingPresentation(false)
+    return
+  }
+  try {
+    params.setExistingPresentation(await params.checkPresentationExists())
+  } catch (e) {
+    console.error('[AuthorPresentationEditor] Error loading presentation:', e)
+  } finally {
+    params.setLoadingPresentation(false)
+  }
+}
diff --git a/components/authorPresentationEditor/validation.ts b/components/authorPresentationEditor/validation.ts
new file mode 100644
index 0000000..cb51c43
--- /dev/null
+++ b/components/authorPresentationEditor/validation.ts
@@ -0,0 +1,15 @@
+import { t } from '@/lib/i18n'
+import type { AuthorPresentationDraft } from './types'
+
+const ADDRESS_PATTERN = /^(1|3|bc1)[a-zA-Z0-9]{25,62}$/
+
+export function validatePresentationDraft(draft: AuthorPresentationDraft): string | null {
+  const address = draft.mainnetAddress.trim()
+  if (!ADDRESS_PATTERN.test(address)) {
+    return t('presentation.validation.invalidAddress')
+  }
+  if (!draft.authorName.trim()) {
+    return t('presentation.validation.authorNameRequired')
+  }
+  return null
+}
diff --git a/components/keyManagement/KeyManagementImportForm.tsx b/components/keyManagement/KeyManagementImportForm.tsx
new file mode 100644
index 0000000..4beab47
--- /dev/null
+++ b/components/keyManagement/KeyManagementImportForm.tsx
@@ -0,0 +1,130 @@
+import { t } from '@/lib/i18n'
+import type { KeyManagementManagerActions } from './useKeyManagementManager'
+import type { KeyManagementManagerState } from './keyManagementController'
+
+export function KeyManagementImportForm(params: {
+  state: KeyManagementManagerState
+  actions: KeyManagementManagerActions
+}): React.ReactElement | null {
+  if (!params.state.showImportForm) {
+    return null
+  }
+  return (
+    <div className="space-y-4">
+      <KeyManagementImportWarning accountExists={params.state.accountExists} />
+      <KeyManagementImportTextarea importKey={params.state.importKey} onChangeImportKey={params.actions.onChangeImportKey} />
+      <KeyManagementReplaceWarning
+        show={params.state.showReplaceWarning}
+        importing={params.state.importing}
+        onCancel={params.actions.onDismissReplaceWarning}
+        onConfirm={params.actions.onConfirmReplace}
+      />
+      <KeyManagementImportFormActions
+        show={!params.state.showReplaceWarning}
+        importing={params.state.importing}
+        onCancel={params.actions.onCancelImport}
+        onImport={params.actions.onImport}
+      />
+    </div>
+  )
+}
+
+function KeyManagementImportWarning(params: { accountExists: boolean }): React.ReactElement {
+  return (
+    <div className="bg-yellow-900/20 border border-yellow-400/50 rounded-lg p-4">
+      <p className="text-yellow-400 font-semibold mb-2">{t('settings.keyManagement.import.warning.title')}</p>
+      <p className="text-yellow-300/90 text-sm" dangerouslySetInnerHTML={{ __html: t('settings.keyManagement.import.warning.description') }} />
+      {params.accountExists ? (
+        <p className="text-yellow-300/90 text-sm mt-2" dangerouslySetInnerHTML={{ __html: t('settings.keyManagement.import.warning.replace') }} />
+      ) : null}
+    </div>
+  )
+}
+
+function KeyManagementImportTextarea(params: {
+  importKey: string
+  onChangeImportKey: (value: string) => void
+}): React.ReactElement {
+  return (
+    <div>
+      <label htmlFor="importKey" className="block text-sm font-medium text-cyber-accent mb-2">
+        {t('settings.keyManagement.import.label')}
+      </label>
+      <textarea
+        id="importKey"
+        value={params.importKey}
+        onChange={(e) => {
+          params.onChangeImportKey(e.target.value)
+        }}
+        placeholder={t('settings.keyManagement.import.placeholder')}
+        className="w-full px-3 py-2 bg-cyber-dark border border-neon-cyan/30 rounded-lg font-mono text-sm text-neon-cyan focus:border-neon-cyan focus:outline-none"
+        rows={4}
+      />
+      <p className="text-sm text-cyber-accent/70 mt-2">{t('settings.keyManagement.import.help')}</p>
+    </div>
+  )
+}
+
+function KeyManagementReplaceWarning(params: {
+  show: boolean
+  importing: boolean
+  onCancel: () => void
+  onConfirm: () => void
+}): React.ReactElement | null {
+  if (!params.show) {
+    return null
+  }
+  return (
+    <div className="bg-red-900/20 border border-red-400/50 rounded-lg p-4">
+      <p className="text-red-400 font-semibold mb-2">{t('settings.keyManagement.replace.warning.title')}</p>
+      <p className="text-red-300/90 text-sm mb-4">{t('settings.keyManagement.replace.warning.description')}</p>
+      <div className="flex gap-4">
+        <button
+          type="button"
+          onClick={params.onCancel}
+          className="flex-1 py-2 px-4 bg-cyber-light border border-neon-cyan/30 hover:border-neon-cyan/50 hover:bg-cyber-dark text-cyber-accent hover:text-neon-cyan rounded-lg font-medium transition-colors"
+        >
+          {t('settings.keyManagement.replace.cancel')}
+        </button>
+        <button
+          type="button"
+          onClick={params.onConfirm}
+          disabled={params.importing}
+          className="flex-1 py-2 px-4 bg-red-600/20 hover:bg-red-600/30 text-red-400 rounded-lg font-medium transition-all border border-red-400/50 hover:shadow-glow-red disabled:opacity-50"
+        >
+          {params.importing ? t('settings.keyManagement.replace.replacing') : t('settings.keyManagement.replace.confirm')}
+        </button>
+      </div>
+    </div>
+  )
+}
+
+function KeyManagementImportFormActions(params: {
+  show: boolean
+  importing: boolean
+  onCancel: () => void
+  onImport: () => void
+}): React.ReactElement | null {
+  if (!params.show) {
+    return null
+  }
+  return (
+    <div className="flex gap-4">
+      <button
+        type="button"
+        onClick={params.onCancel}
+        className="flex-1 py-2 px-4 bg-cyber-light border border-neon-cyan/30 hover:border-neon-cyan/50 hover:bg-cyber-dark text-cyber-accent hover:text-neon-cyan rounded-lg font-medium transition-colors"
+      >
+        {t('settings.keyManagement.import.cancel')}
+      </button>
+      <button
+        type="button"
+        onClick={params.onImport}
+        disabled={params.importing}
+        className="flex-1 py-2 px-4 bg-neon-cyan/20 hover:bg-neon-cyan/30 text-neon-cyan rounded-lg font-medium transition-all border border-neon-cyan/50 hover:shadow-glow-cyan disabled:opacity-50"
+      >
+        {params.importing ? t('settings.keyManagement.import.importing') : t('settings.keyManagement.import.import')}
+      </button>
+    </div>
+  )
+}
diff --git a/components/keyManagement/KeyManagementImportSection.tsx b/components/keyManagement/KeyManagementImportSection.tsx
new file mode 100644
index 0000000..2cc4985
--- /dev/null
+++ b/components/keyManagement/KeyManagementImportSection.tsx
@@ -0,0 +1,125 @@
+import { t } from '@/lib/i18n'
+import type { KeyManagementManagerActions } from './useKeyManagementManager'
+import type { KeyManagementManagerState } from './keyManagementController'
+import { KeyManagementImportForm } from './KeyManagementImportForm'
+
+export function KeyManagementImportSection(params: {
+  state: KeyManagementManagerState
+  actions: KeyManagementManagerActions
+}): React.ReactElement {
+  return (
+    <>
+      <KeyManagementErrorBanner error={params.state.error} />
+      <KeyManagementPublicKeysPanel
+        publicKeys={params.state.publicKeys}
+        copiedNpub={params.state.copiedNpub}
+        copiedPublicKey={params.state.copiedPublicKey}
+        onCopyNpub={params.actions.onCopyNpub}
+        onCopyPublicKey={params.actions.onCopyPublicKey}
+      />
+      <KeyManagementNoAccountBanner publicKeys={params.state.publicKeys} accountExists={params.state.accountExists} />
+      <KeyManagementImportButton
+        accountExists={params.state.accountExists}
+        showImportForm={params.state.showImportForm}
+        onClick={params.actions.onShowImportForm}
+      />
+      <KeyManagementImportForm state={params.state} actions={params.actions} />
+    </>
+  )
+}
+
+function KeyManagementErrorBanner(params: { error: string | null }): React.ReactElement | null {
+  if (!params.error) {
+    return null
+  }
+  return (
+    <div className="bg-red-900/20 border border-red-400/50 rounded-lg p-4 mb-4">
+      <p className="text-red-400">{params.error}</p>
+    </div>
+  )
+}
+
+function KeyManagementPublicKeysPanel(params: {
+  publicKeys: KeyManagementManagerState['publicKeys']
+  copiedNpub: boolean
+  copiedPublicKey: boolean
+  onCopyNpub: () => void
+  onCopyPublicKey: () => void
+}): React.ReactElement | null {
+  if (!params.publicKeys) {
+    return null
+  }
+  return (
+    <div className="space-y-4 mb-6">
+      <KeyManagementKeyCard
+        label={t('settings.keyManagement.publicKey.npub')}
+        value={params.publicKeys.npub}
+        copied={params.copiedNpub}
+        onCopy={params.onCopyNpub}
+      />
+      <KeyManagementKeyCard
+        label={t('settings.keyManagement.publicKey.hex')}
+        value={params.publicKeys.publicKey}
+        copied={params.copiedPublicKey}
+        onCopy={params.onCopyPublicKey}
+      />
+    </div>
+  )
+}
+
+function KeyManagementKeyCard(params: {
+  label: string
+  value: string
+  copied: boolean
+  onCopy: () => void
+}): React.ReactElement {
+  return (
+    <div className="bg-neon-blue/10 border border-neon-blue/30 rounded-lg p-4">
+      <div className="flex justify-between items-start mb-2">
+        <p className="text-neon-blue font-semibold">{params.label}</p>
+        <button
+          type="button"
+          onClick={params.onCopy}
+          className="px-3 py-1 text-xs bg-cyber-light border border-neon-cyan/30 hover:border-neon-cyan/50 hover:bg-cyber-dark text-cyber-accent hover:text-neon-cyan rounded transition-colors"
+        >
+          {params.copied ? t('settings.keyManagement.copied') : t('settings.keyManagement.copy')}
+        </button>
+      </div>
+      <p className="text-neon-cyan text-sm font-mono break-all">{params.value}</p>
+    </div>
+  )
+}
+
+function KeyManagementNoAccountBanner(params: {
+  publicKeys: KeyManagementManagerState['publicKeys']
+  accountExists: boolean
+}): React.ReactElement | null {
+  if (params.publicKeys || params.accountExists) {
+    return null
+  }
+  return (
+    <div className="bg-yellow-900/20 border border-yellow-400/50 rounded-lg p-4 mb-6">
+      <p className="text-yellow-400 font-semibold mb-2">{t('settings.keyManagement.noAccount.title')}</p>
+      <p className="text-yellow-300/90 text-sm">{t('settings.keyManagement.noAccount.description')}</p>
+    </div>
+  )
+}
+
+function KeyManagementImportButton(params: {
+  accountExists: boolean
+  showImportForm: boolean
+  onClick: () => void
+}): React.ReactElement | null {
+  if (params.showImportForm) {
+    return null
+  }
+  return (
+    <button
+      type="button"
+      onClick={params.onClick}
+      className="w-full py-3 px-6 bg-neon-cyan/20 hover:bg-neon-cyan/30 text-neon-cyan rounded-lg font-medium transition-all border border-neon-cyan/50 hover:shadow-glow-cyan"
+    >
+      {params.accountExists ? t('settings.keyManagement.import.button.replace') : t('settings.keyManagement.import.button.new')}
+    </button>
+  )
+}
diff --git a/components/keyManagement/KeyManagementManager.tsx b/components/keyManagement/KeyManagementManager.tsx
new file mode 100644
index 0000000..5a4728e
--- /dev/null
+++ b/components/keyManagement/KeyManagementManager.tsx
@@ -0,0 +1,28 @@
+import { t } from '@/lib/i18n'
+import { SyncProgressBar } from '../SyncProgressBar'
+import { KeyManagementImportSection } from './KeyManagementImportSection'
+import { KeyManagementRecoverySection } from './KeyManagementRecoverySection'
+import { useKeyManagementManager } from './useKeyManagementManager'
+
+export function KeyManagementManager(): React.ReactElement {
+  const { state, actions } = useKeyManagementManager()
+
+  if (state.loading) {
+    return (
+      <div className="bg-cyber-darker border border-neon-cyan/30 rounded-lg p-6">
+        <p className="text-cyber-accent">{t('settings.keyManagement.loading')}</p>
+      </div>
+    )
+  }
+
+  return (
+    <div className="space-y-6">
+      <div className="bg-cyber-darker border border-neon-cyan/30 rounded-lg p-6">
+        <h2 className="text-2xl font-bold text-neon-cyan mb-4">{t('settings.keyManagement.title')}</h2>
+        <KeyManagementImportSection state={state} actions={actions} />
+        <SyncProgressBar />
+        <KeyManagementRecoverySection state={state} actions={actions} />
+      </div>
+    </div>
+  )
+}
diff --git a/components/keyManagement/KeyManagementRecoverySection.tsx b/components/keyManagement/KeyManagementRecoverySection.tsx
new file mode 100644
index 0000000..b56f72a
--- /dev/null
+++ b/components/keyManagement/KeyManagementRecoverySection.tsx
@@ -0,0 +1,98 @@
+import { t } from '@/lib/i18n'
+import type { KeyManagementManagerActions } from './useKeyManagementManager'
+import type { KeyManagementManagerState } from './keyManagementController'
+
+export function KeyManagementRecoverySection(params: {
+  state: KeyManagementManagerState
+  actions: KeyManagementManagerActions
+}): React.ReactElement | null {
+  if (!params.state.recoveryPhrase || !params.state.newNpub) {
+    return null
+  }
+  return (
+    <div className="mt-6 space-y-4">
+      <KeyManagementRecoveryWarning />
+      <div className="bg-cyber-darker border border-neon-cyan/30 rounded-lg p-6">
+        <RecoveryWordsGrid recoveryPhrase={params.state.recoveryPhrase} />
+        <button
+          type="button"
+          onClick={params.actions.onCopyRecoveryPhrase}
+          className="w-full py-2 px-4 bg-cyber-light border border-neon-cyan/30 hover:border-neon-cyan/50 hover:bg-cyber-dark text-cyber-accent hover:text-neon-cyan rounded-lg text-sm font-medium transition-colors"
+        >
+          {params.state.copiedRecoveryPhrase ? t('settings.keyManagement.recovery.copied') : t('settings.keyManagement.recovery.copy')}
+        </button>
+      </div>
+      <KeyManagementNewNpubCard newNpub={params.state.newNpub} />
+      <KeyManagementDoneButton onDone={params.actions.onDoneRecovery} />
+    </div>
+  )
+}
+
+function KeyManagementRecoveryWarning(): React.ReactElement {
+  return (
+    <div className="bg-yellow-900/20 border border-yellow-400/50 rounded-lg p-4">
+      <p className="text-yellow-400 font-semibold mb-2">{t('settings.keyManagement.recovery.warning.title')}</p>
+      <p className="text-yellow-300/90 text-sm" dangerouslySetInnerHTML={{ __html: t('settings.keyManagement.recovery.warning.part1') }} />
+      <p className="text-yellow-300/90 text-sm mt-2" dangerouslySetInnerHTML={{ __html: t('settings.keyManagement.recovery.warning.part2') }} />
+      <p className="text-yellow-300/90 text-sm mt-2">{t('settings.keyManagement.recovery.warning.part3')}</p>
+    </div>
+  )
+}
+
+function KeyManagementNewNpubCard(params: { newNpub: string }): React.ReactElement {
+  return (
+    <div className="bg-neon-blue/10 border border-neon-blue/30 rounded-lg p-4">
+      <p className="text-neon-blue font-semibold mb-2">{t('settings.keyManagement.recovery.newNpub')}</p>
+      <p className="text-neon-cyan text-sm font-mono break-all">{params.newNpub}</p>
+    </div>
+  )
+}
+
+function KeyManagementDoneButton(params: { onDone: () => void }): React.ReactElement {
+  return (
+    <button
+      type="button"
+      onClick={params.onDone}
+      className="w-full py-2 px-4 bg-neon-cyan/20 hover:bg-neon-cyan/30 text-neon-cyan rounded-lg font-medium transition-all border border-neon-cyan/50 hover:shadow-glow-cyan"
+    >
+      {t('settings.keyManagement.recovery.done')}
+    </button>
+  )
+}
+
+function RecoveryWordsGrid(params: { recoveryPhrase: string[] }): React.ReactElement {
+  const items = buildRecoveryWordItems(params.recoveryPhrase)
+  return (
+    <div className="grid grid-cols-2 gap-4 mb-4">
+      {items.map((item) => (
+        <div
+          key={item.id}
+          className="bg-cyber-dark border border-neon-cyan/30 rounded-lg p-3 text-center font-mono text-lg"
+        >
+          <span className="text-cyber-accent/70 text-sm mr-2">{item.position}.</span>
+          <span className="font-semibold text-neon-cyan">{item.word}</span>
+        </div>
+      ))}
+    </div>
+  )
+}
+
+interface RecoveryWordItem {
+  id: string
+  position: number
+  word: string
+}
+
+function buildRecoveryWordItems(recoveryPhrase: readonly string[]): RecoveryWordItem[] {
+  const occurrences = new Map<string, number>()
+  const items: RecoveryWordItem[] = []
+  let position = 1
+  for (const word of recoveryPhrase) {
+    const current = occurrences.get(word) ?? 0
+    const next = current + 1
+    occurrences.set(word, next)
+    items.push({ id: `${word}-${next}`, position, word })
+    position += 1
+  }
+  return items
+}
diff --git a/components/keyManagement/keyImportParsing.ts b/components/keyManagement/keyImportParsing.ts
new file mode 100644
index 0000000..2ffcca9
--- /dev/null
+++ b/components/keyManagement/keyImportParsing.ts
@@ -0,0 +1,53 @@
+import { nip19 } from 'nostr-tools'
+
+export function extractKeyFromInput(rawInput: string): string | null {
+  const trimmed = rawInput.trim()
+  if (trimmed.length === 0) {
+    return null
+  }
+  const fromUrl = extractKeyFromUrl(trimmed)
+  return fromUrl ?? extractKeyFromText(trimmed)
+}
+
+function extractKeyFromUrl(url: string): string | null {
+  try {
+    const urlObj = new URL(url)
+    const {protocol} = urlObj
+    if (protocol === 'nostr:' || protocol === 'nostr://') {
+      const path = urlObj.pathname ?? urlObj.href.replace(/^nostr:?\/\//, '')
+      if (path.startsWith('nsec')) {
+        return path
+      }
+    }
+    const nsecMatch = url.match(/nsec1[a-z0-9]+/i)
+    return nsecMatch?.[0] ?? null
+  } catch {
+    return null
+  }
+}
+
+function extractKeyFromText(text: string): string | null {
+  const nsec = extractNsec(text)
+  if (nsec) {
+    return nsec
+  }
+  const trimmed = text.trim()
+  return trimmed.length > 0 ? trimmed : null
+}
+
+function extractNsec(text: string): string | null {
+  const nsecMatch = text.match(/nsec1[a-z0-9]+/i)
+  return nsecMatch?.[0] ?? null
+}
+
+export function isValidPrivateKeyFormat(key: string): boolean {
+  try {
+    const decoded = nip19.decode(key)
+    if (decoded.type !== 'nsec') {
+      return false
+    }
+    return typeof decoded.data === 'string' || decoded.data instanceof Uint8Array
+  } catch {
+    return /^[0-9a-f]{64}$/i.test(key)
+  }
+}
diff --git a/components/keyManagement/keyManagementController.ts b/components/keyManagement/keyManagementController.ts
new file mode 100644
index 0000000..6e74502
--- /dev/null
+++ b/components/keyManagement/keyManagementController.ts
@@ -0,0 +1,154 @@
+import { nostrAuthService } from '@/lib/nostrAuth'
+import { keyManagementService } from '@/lib/keyManagement'
+import { t } from '@/lib/i18n'
+import type { PublicKeys } from './types'
+import { extractKeyFromInput, isValidPrivateKeyFormat } from './keyImportParsing'
+
+export interface KeyManagementManagerState {
+  publicKeys: PublicKeys | null
+  accountExists: boolean
+  loading: boolean
+  error: string | null
+  importKey: string
+  importing: boolean
+  showImportForm: boolean
+  showReplaceWarning: boolean
+  recoveryPhrase: string[] | null
+  newNpub: string | null
+  copiedNpub: boolean
+  copiedPublicKey: boolean
+  copiedRecoveryPhrase: boolean
+}
+
+export type PatchState = (patch: Partial<KeyManagementManagerState>) => void
+
+export const INITIAL_KEY_MANAGEMENT_STATE: KeyManagementManagerState = {
+  publicKeys: null,
+  accountExists: false,
+  loading: true,
+  error: null,
+  importKey: '',
+  importing: false,
+  showImportForm: false,
+  showReplaceWarning: false,
+  recoveryPhrase: null,
+  newNpub: null,
+  copiedNpub: false,
+  copiedPublicKey: false,
+  copiedRecoveryPhrase: false,
+}
+
+export async function loadKeys(params: { patchState: PatchState }): Promise<void> {
+  try {
+    params.patchState({ loading: true, error: null })
+    const exists = await nostrAuthService.accountExists()
+    params.patchState({ accountExists: exists })
+    if (!exists) {
+      params.patchState({ publicKeys: null })
+      return
+    }
+    const keys = await keyManagementService.getPublicKeys()
+    params.patchState({ publicKeys: keys ?? null })
+  } catch (e) {
+    const errorMessage = e instanceof Error ? e.message : t('settings.keyManagement.loading')
+    params.patchState({ error: errorMessage })
+    console.error('[KeyManagement] Error loading keys:', e)
+  } finally {
+    params.patchState({ loading: false })
+  }
+}
+
+export async function handleImport(params: {
+  state: KeyManagementManagerState
+  patchState: PatchState
+}): Promise<void> {
+  const extractedKey = validateAndExtractImportKey({ importKey: params.state.importKey, patchState: params.patchState })
+  if (!extractedKey) {
+    return
+  }
+  if (params.state.accountExists) {
+    params.patchState({ showReplaceWarning: true })
+    return
+  }
+  await performImport({ key: extractedKey, accountExists: false, patchState: params.patchState })
+}
+
+export async function confirmReplace(params: {
+  state: KeyManagementManagerState
+  patchState: PatchState
+}): Promise<void> {
+  const extractedKey = validateAndExtractImportKey({ importKey: params.state.importKey, patchState: params.patchState })
+  if (!extractedKey) {
+    return
+  }
+  await performImport({ key: extractedKey, accountExists: true, patchState: params.patchState })
+}
+
+function validateAndExtractImportKey(params: { importKey: string; patchState: PatchState }): string | null {
+  if (!params.importKey.trim()) {
+    params.patchState({ error: t('settings.keyManagement.import.error.required') })
+    return null
+  }
+  const extractedKey = extractKeyFromInput(params.importKey)
+  if (!extractedKey) {
+    params.patchState({ error: t('settings.keyManagement.import.error.invalid') })
+    return null
+  }
+  if (!isValidPrivateKeyFormat(extractedKey)) {
+    params.patchState({ error: t('settings.keyManagement.import.error.invalid') })
+    return null
+  }
+  return extractedKey
+}
+
+async function performImport(params: {
+  key: string
+  accountExists: boolean
+  patchState: PatchState
+}): Promise<void> {
+  try {
+    params.patchState({ importing: true, error: null, showReplaceWarning: false })
+    if (params.accountExists) {
+      await nostrAuthService.deleteAccount()
+    }
+    const result = await nostrAuthService.createAccount(params.key)
+    params.patchState({
+      recoveryPhrase: result.recoveryPhrase,
+      newNpub: result.npub,
+      importKey: '',
+      showImportForm: false,
+    })
+    await loadKeys({ patchState: params.patchState })
+    await maybeStartUserSync({ publicKey: result.publicKey })
+  } catch (e) {
+    const errorMessage = e instanceof Error ? e.message : t('settings.keyManagement.import.error.failed')
+    params.patchState({ error: errorMessage })
+    console.error('[KeyManagement] Error importing key:', e)
+  } finally {
+    params.patchState({ importing: false })
+  }
+}
+
+async function maybeStartUserSync(params: { publicKey: string | undefined }): Promise<void> {
+  if (!params.publicKey) {
+    return
+  }
+  const { swClient } = await import('@/lib/swClient')
+  const isReady = await swClient.isReady()
+  if (isReady) {
+    void swClient.startUserSync(params.publicKey)
+  }
+}
+
+export async function copyToClipboard(params: {
+  text: string
+  onCopied: () => void
+  onCopyFailed: (error: unknown) => void
+}): Promise<void> {
+  try {
+    await navigator.clipboard.writeText(params.text)
+    params.onCopied()
+  } catch (e) {
+    params.onCopyFailed(e)
+  }
+}
diff --git a/components/keyManagement/types.ts b/components/keyManagement/types.ts
new file mode 100644
index 0000000..ccf1ff0
--- /dev/null
+++ b/components/keyManagement/types.ts
@@ -0,0 +1,4 @@
+export interface PublicKeys {
+  publicKey: string
+  npub: string
+}
diff --git a/components/keyManagement/useKeyManagementManager.ts b/components/keyManagement/useKeyManagementManager.ts
new file mode 100644
index 0000000..dafad1e
--- /dev/null
+++ b/components/keyManagement/useKeyManagementManager.ts
@@ -0,0 +1,140 @@
+import { useEffect, useMemo, useState } from 'react'
+import {
+  INITIAL_KEY_MANAGEMENT_STATE,
+  confirmReplace,
+  copyToClipboard,
+  handleImport,
+  loadKeys,
+  type KeyManagementManagerState,
+  type PatchState,
+} from './keyManagementController'
+
+export interface KeyManagementManagerActions {
+  onChangeImportKey: (value: string) => void
+  onShowImportForm: () => void
+  onCancelImport: () => void
+  onImport: () => void
+  onDismissReplaceWarning: () => void
+  onConfirmReplace: () => void
+  onCopyNpub: () => void
+  onCopyPublicKey: () => void
+  onCopyRecoveryPhrase: () => void
+  onDoneRecovery: () => void
+}
+
+export interface UseKeyManagementManagerResult {
+  state: KeyManagementManagerState
+  actions: KeyManagementManagerActions
+}
+
+export function useKeyManagementManager(): UseKeyManagementManagerResult {
+  const [state, setState] = useState<KeyManagementManagerState>(INITIAL_KEY_MANAGEMENT_STATE)
+  const patchState = useMemo((): PatchState => createPatchState(setState), [])
+
+  useEffect(() => {
+    void loadKeys({ patchState })
+  }, [patchState])
+
+  const actions = useMemo((): KeyManagementManagerActions => createActions({ state, patchState }), [state, patchState])
+
+  return { state, actions }
+}
+
+function createPatchState(setState: React.Dispatch<React.SetStateAction<KeyManagementManagerState>>): PatchState {
+  return (patch: Partial<KeyManagementManagerState>): void => {
+    setState((previous) => ({ ...previous, ...patch }))
+  }
+}
+
+function createActions(params: { state: KeyManagementManagerState; patchState: PatchState }): KeyManagementManagerActions {
+  return {
+    onChangeImportKey: (value: string): void => {
+      params.patchState({ importKey: value, error: null })
+    },
+    onShowImportForm: (): void => {
+      params.patchState({ showImportForm: true, error: null })
+    },
+    onCancelImport: (): void => {
+      params.patchState({ showImportForm: false, importKey: '', error: null, showReplaceWarning: false })
+    },
+    onImport: (): void => {
+      void handleImport({ state: params.state, patchState: params.patchState })
+    },
+    onDismissReplaceWarning: (): void => {
+      params.patchState({ showReplaceWarning: false })
+    },
+    onConfirmReplace: (): void => {
+      void confirmReplace({ state: params.state, patchState: params.patchState })
+    },
+    onCopyNpub: (): void => {
+      void copyNpub({ state: params.state, patchState: params.patchState })
+    },
+    onCopyPublicKey: (): void => {
+      void copyPublicKey({ state: params.state, patchState: params.patchState })
+    },
+    onCopyRecoveryPhrase: (): void => {
+      void copyRecoveryPhrase({ state: params.state, patchState: params.patchState })
+    },
+    onDoneRecovery: (): void => {
+      params.patchState({ recoveryPhrase: null, newNpub: null })
+      void loadKeys({ patchState: params.patchState })
+    },
+  }
+}
+
+async function copyNpub(params: { state: KeyManagementManagerState; patchState: PatchState }): Promise<void> {
+  const npub = params.state.publicKeys?.npub
+  if (!npub) {
+    return
+  }
+  await copyToClipboard({
+    text: npub,
+    onCopied: () => {
+      params.patchState({ copiedNpub: true })
+      scheduleResetCopiedFlag(() => params.patchState({ copiedNpub: false }))
+    },
+    onCopyFailed: (e) => {
+      console.error('[KeyManagement] Error copying npub:', e)
+    },
+  })
+}
+
+async function copyPublicKey(params: { state: KeyManagementManagerState; patchState: PatchState }): Promise<void> {
+  const publicKey = params.state.publicKeys?.publicKey
+  if (!publicKey) {
+    return
+  }
+  await copyToClipboard({
+    text: publicKey,
+    onCopied: () => {
+      params.patchState({ copiedPublicKey: true })
+      scheduleResetCopiedFlag(() => params.patchState({ copiedPublicKey: false }))
+    },
+    onCopyFailed: (e) => {
+      console.error('[KeyManagement] Error copying public key:', e)
+    },
+  })
+}
+
+async function copyRecoveryPhrase(params: { state: KeyManagementManagerState; patchState: PatchState }): Promise<void> {
+  const {recoveryPhrase} = params.state
+  if (!recoveryPhrase) {
+    return
+  }
+  await copyToClipboard({
+    text: recoveryPhrase.join(' '),
+    onCopied: () => {
+      params.patchState({ copiedRecoveryPhrase: true })
+      scheduleResetCopiedFlag(() => params.patchState({ copiedRecoveryPhrase: false }))
+    },
+    onCopyFailed: (e) => {
+      console.error('[KeyManagement] Error copying recovery phrase:', e)
+    },
+  })
+}
+
+function scheduleResetCopiedFlag(reset: () => void): void {
+  setTimeout(() => {
+    reset()
+  }, 2000)
+}
diff --git a/components/markdownEditorTwoColumns/MarkdownEditorTwoColumns.tsx b/components/markdownEditorTwoColumns/MarkdownEditorTwoColumns.tsx
new file mode 100644
index 0000000..fd47233
--- /dev/null
+++ b/components/markdownEditorTwoColumns/MarkdownEditorTwoColumns.tsx
@@ -0,0 +1,158 @@
+import { useState } from 'react'
+import type { MediaRef, Page } from '@/types/nostr'
+import { t } from '@/lib/i18n'
+import { createPagesHandlers, PagesManager } from './PagesManager'
+import { createImageUploadHandler } from './imageUpload'
+
+export interface MarkdownEditorTwoColumnsProps {
+  value: string
+  onChange: (value: string) => void
+  pages?: Page[]
+  onPagesChange?: (pages: Page[]) => void
+  onMediaAdd?: (media: MediaRef) => void
+  onBannerChange?: (url: string) => void
+}
+
+export function MarkdownEditorTwoColumns(props: MarkdownEditorTwoColumnsProps): React.ReactElement {
+  const [uploading, setUploading] = useState(false)
+  const [error, setError] = useState<string | null>(null)
+
+  const pages = props.pages ?? []
+  const pagesHandlers = createPagesHandlers({ pages, onPagesChange: props.onPagesChange })
+  const handleImageUpload = createImageUploadHandler({
+    setError,
+    setUploading,
+    onMediaAdd: props.onMediaAdd,
+    onBannerChange: props.onBannerChange,
+    onSetPageImageUrl: pagesHandlers.setPageContent,
+  })
+
+  return (
+    <div className="space-y-4">
+      <MarkdownToolbar
+        onFileSelected={(file) => {
+          void handleImageUpload({ file })
+        }}
+        uploading={uploading}
+        error={error}
+        {...(props.onPagesChange ? { onAddPage: pagesHandlers.addPage } : {})}
+      />
+      <div className="grid grid-cols-2 gap-4">
+        <EditorColumn value={props.value} onChange={props.onChange} />
+        <PreviewColumn value={props.value} />
+      </div>
+      {props.onPagesChange ? (
+        <PagesManager
+          pages={pages}
+          onPageContentChange={pagesHandlers.setPageContent}
+          onPageTypeChange={pagesHandlers.setPageType}
+          onRemovePage={pagesHandlers.removePage}
+          onImageUpload={async (file, pageNumber) => {
+            await handleImageUpload({ file, pageNumber })
+          }}
+        />
+      ) : null}
+    </div>
+  )
+}
+
+function MarkdownToolbar(params: {
+  onFileSelected: (file: File) => void
+  uploading: boolean
+  error: string | null
+  onAddPage?: (type: 'markdown' | 'image') => void
+}): React.ReactElement {
+  return (
+    <div className="flex items-center gap-2 flex-wrap">
+      <ToolbarUploadButton onFileSelected={params.onFileSelected} />
+      <ToolbarAddPageButtons onAddPage={params.onAddPage} />
+      <ToolbarStatus uploading={params.uploading} error={params.error} />
+    </div>
+  )
+}
+
+function EditorColumn(params: { value: string; onChange: (value: string) => void }): React.ReactElement {
+  return (
+    <div className="space-y-2">
+      <label className="block text-sm font-semibold text-gray-800">{t('markdown.editor')}</label>
+      <textarea
+        className="w-full border rounded p-3 h-96 font-mono text-sm"
+        value={params.value}
+        onChange={(e) => params.onChange(e.target.value)}
+        placeholder={t('markdown.placeholder')}
+      />
+    </div>
+  )
+}
+
+function PreviewColumn(params: { value: string }): React.ReactElement {
+  return (
+    <div className="space-y-2">
+      <label className="block text-sm font-semibold text-gray-800">{t('markdown.preview')}</label>
+      <MarkdownPreview value={params.value} />
+    </div>
+  )
+}
+
+function MarkdownPreview(params: { value: string }): React.ReactElement {
+  return (
+    <div className="prose max-w-none border rounded p-3 bg-white h-96 overflow-y-auto whitespace-pre-wrap">
+      {params.value || <span className="text-gray-400">{t('markdown.preview.empty')}</span>}
+    </div>
+  )
+}
+
+function ToolbarUploadButton(params: { onFileSelected: (file: File) => void }): React.ReactElement {
+  return (
+    <label className="px-3 py-1 text-sm rounded bg-blue-600 text-white cursor-pointer hover:bg-blue-700">
+      {t('markdown.upload.media')}
+      <input
+        type="file"
+        accept=".png,.jpg,.jpeg,.webp"
+        className="hidden"
+        onChange={(e) => {
+          const file = e.target.files?.[0]
+          if (file) {
+            params.onFileSelected(file)
+          }
+        }}
+      />
+    </label>
+  )
+}
+
+function ToolbarAddPageButtons(params: { onAddPage: ((type: 'markdown' | 'image') => void) | undefined }): React.ReactElement | null {
+  if (!params.onAddPage) {
+    return null
+  }
+  return (
+    <>
+      <button
+        type="button"
+        className="px-3 py-1 text-sm rounded bg-green-600 text-white hover:bg-green-700"
+        onClick={() => params.onAddPage?.('markdown')}
+      >
+        {t('page.add.markdown')}
+      </button>
+      <button
+        type="button"
+        className="px-3 py-1 text-sm rounded bg-purple-600 text-white hover:bg-purple-700"
+        onClick={() => params.onAddPage?.('image')}
+      >
+        {t('page.add.image')}
+      </button>
+    </>
+  )
+}
+
+function ToolbarStatus(params: { uploading: boolean; error: string | null }): React.ReactElement | null {
+  if (!params.uploading && !params.error) {
+    return null
+  }
+  return (
+    <>
+      {params.uploading ? <span className="text-sm text-gray-500">{t('markdown.upload.uploading')}</span> : null}
+      {params.error ? <span className="text-sm text-red-600">{params.error}</span> : null}
+    </>
+  )
+}
diff --git a/components/markdownEditorTwoColumns/PagesManager.tsx b/components/markdownEditorTwoColumns/PagesManager.tsx
new file mode 100644
index 0000000..6346c08
--- /dev/null
+++ b/components/markdownEditorTwoColumns/PagesManager.tsx
@@ -0,0 +1,165 @@
+import { t } from '@/lib/i18n'
+import type { Page } from '@/types/nostr'
+
+export function PagesManager(params: {
+  pages: Page[]
+  onPageContentChange: (pageNumber: number, content: string) => void
+  onPageTypeChange: (pageNumber: number, type: 'markdown' | 'image') => void
+  onRemovePage: (pageNumber: number) => void
+  onImageUpload: (file: File, pageNumber: number) => Promise<void>
+}): React.ReactElement {
+  if (params.pages.length === 0) {
+    return <div className="text-sm text-gray-500">{t('page.empty')}</div>
+  }
+  return (
+    <div className="space-y-4">
+      <h3 className="text-lg font-semibold">{t('page.title')}</h3>
+      {params.pages.map((page) => (
+        <PageEditor
+          key={page.number}
+          page={page}
+          onContentChange={(content) => params.onPageContentChange(page.number, content)}
+          onTypeChange={(type) => params.onPageTypeChange(page.number, type)}
+          onRemove={() => params.onRemovePage(page.number)}
+          onImageUpload={async (file) => {
+            await params.onImageUpload(file, page.number)
+          }}
+        />
+      ))}
+    </div>
+  )
+}
+
+function PageEditor(params: {
+  page: Page
+  onContentChange: (content: string) => void
+  onTypeChange: (type: 'markdown' | 'image') => void
+  onRemove: () => void
+  onImageUpload: (file: File) => Promise<void>
+}): React.ReactElement {
+  return (
+    <div className="border rounded-lg p-4 space-y-3">
+      <PageEditorHeader page={params.page} onTypeChange={params.onTypeChange} onRemove={params.onRemove} />
+      <PageEditorBody page={params.page} onContentChange={params.onContentChange} onImageUpload={params.onImageUpload} />
+    </div>
+  )
+}
+
+function PageEditorHeader(params: { page: Page; onTypeChange: (type: 'markdown' | 'image') => void; onRemove: () => void }): React.ReactElement {
+  return (
+    <div className="flex items-center justify-between">
+      <h4 className="font-semibold">
+        {t('page.number', { number: params.page.number })} - {t(`page.type.${params.page.type}`)}
+      </h4>
+      <div className="flex items-center gap-2">
+        <select
+          value={params.page.type}
+          onChange={(e) => params.onTypeChange(e.target.value as 'markdown' | 'image')}
+          className="text-sm border rounded px-2 py-1"
+        >
+          <option value="markdown">{t('page.type.markdown')}</option>
+          <option value="image">{t('page.type.image')}</option>
+        </select>
+        <button
+          type="button"
+          className="px-2 py-1 text-sm rounded bg-red-600 text-white hover:bg-red-700"
+          onClick={params.onRemove}
+        >
+          {t('page.remove')}
+        </button>
+      </div>
+    </div>
+  )
+}
+
+function PageEditorBody(params: { page: Page; onContentChange: (content: string) => void; onImageUpload: (file: File) => Promise<void> }): React.ReactElement {
+  if (params.page.type === 'markdown') {
+    return (
+      <textarea
+        className="w-full border rounded p-2 h-48 font-mono text-sm"
+        value={params.page.content}
+        onChange={(e) => params.onContentChange(e.target.value)}
+        placeholder={t('page.markdown.placeholder')}
+      />
+    )
+  }
+  return <PageEditorImageBody page={params.page} onContentChange={params.onContentChange} onImageUpload={params.onImageUpload} />
+}
+
+function PageEditorImageBody(params: { page: Page; onContentChange: (content: string) => void; onImageUpload: (file: File) => Promise<void> }): React.ReactElement {
+  if (params.page.content) {
+    return (
+      <div className="relative">
+        <img src={params.page.content} alt={t('page.image.alt', { number: params.page.number })} className="max-w-full h-auto rounded" />
+        <button
+          type="button"
+          className="absolute top-2 right-2 px-2 py-1 text-sm rounded bg-red-600 text-white hover:bg-red-700"
+          onClick={() => params.onContentChange('')}
+        >
+          {t('page.image.remove')}
+        </button>
+      </div>
+    )
+  }
+  return <PageImageUploadButton onFileSelected={params.onImageUpload} />
+}
+
+function PageImageUploadButton(params: { onFileSelected: (file: File) => Promise<void> }): React.ReactElement {
+  return (
+    <label className="block px-3 py-2 text-sm rounded bg-blue-600 text-white cursor-pointer hover:bg-blue-700 text-center">
+      {t('page.image.upload')}
+      <input
+        type="file"
+        accept=".png,.jpg,.jpeg,.webp"
+        className="hidden"
+        onChange={(e) => {
+          const file = e.target.files?.[0]
+          if (file) {
+            void params.onFileSelected(file)
+          }
+        }}
+      />
+    </label>
+  )
+}
+
+export function createPagesHandlers(params: {
+  pages: Page[]
+  onPagesChange: ((pages: Page[]) => void) | undefined
+}): {
+  addPage: (type: 'markdown' | 'image') => void
+  setPageContent: (pageNumber: number, content: string) => void
+  setPageType: (pageNumber: number, type: 'markdown' | 'image') => void
+  removePage: (pageNumber: number) => void
+} {
+  const update = (next: Page[]): void => {
+    params.onPagesChange?.(next)
+  }
+  return {
+    addPage: (type: 'markdown' | 'image'): void => {
+      if (!params.onPagesChange) {
+        return
+      }
+      const newPage: Page = { number: params.pages.length + 1, type, content: '' }
+      update([...params.pages, newPage])
+    },
+    setPageContent: (pageNumber: number, content: string): void => {
+      if (!params.onPagesChange) {
+        return
+      }
+      update(params.pages.map((p) => (p.number === pageNumber ? { ...p, content } : p)))
+    },
+    setPageType: (pageNumber: number, type: 'markdown' | 'image'): void => {
+      if (!params.onPagesChange) {
+        return
+      }
+      update(params.pages.map((p) => (p.number === pageNumber ? { ...p, type, content: '' } : p)))
+    },
+    removePage: (pageNumber: number): void => {
+      if (!params.onPagesChange) {
+        return
+      }
+      update(params.pages.filter((p) => p.number !== pageNumber).map((p, idx) => ({ ...p, number: idx + 1 })))
+    },
+  }
+}
diff --git a/components/markdownEditorTwoColumns/imageUpload.ts b/components/markdownEditorTwoColumns/imageUpload.ts
new file mode 100644
index 0000000..008afb9
--- /dev/null
+++ b/components/markdownEditorTwoColumns/imageUpload.ts
@@ -0,0 +1,32 @@
+import type { MediaRef } from '@/types/nostr'
+import { uploadNip95Media } from '@/lib/nip95'
+import { t } from '@/lib/i18n'
+
+export function createImageUploadHandler(params: {
+  setError: (value: string | null) => void
+  setUploading: (value: boolean) => void
+  onMediaAdd: ((media: MediaRef) => void) | undefined
+  onBannerChange: ((url: string) => void) | undefined
+  onSetPageImageUrl: (pageNumber: number, url: string) => void
+}): (args: { file: File; pageNumber?: number }) => Promise<void> {
+  return async (args): Promise<void> => {
+    params.setError(null)
+    params.setUploading(true)
+    try {
+      const media = await uploadNip95Media(args.file)
+      if (media.type !== 'image') {
+        return
+      }
+      if (args.pageNumber !== undefined) {
+        params.onSetPageImageUrl(args.pageNumber, media.url)
+      } else {
+        params.onBannerChange?.(media.url)
+      }
+      params.onMediaAdd?.(media)
+    } catch (e) {
+      params.setError(e instanceof Error ? e.message : t('upload.error.failed'))
+    } finally {
+      params.setUploading(false)
+    }
+  }
+}
diff --git a/components/nip95Config/Nip95ApiCard.tsx b/components/nip95Config/Nip95ApiCard.tsx
new file mode 100644
index 0000000..4ec1826
--- /dev/null
+++ b/components/nip95Config/Nip95ApiCard.tsx
@@ -0,0 +1,155 @@
+import type { Nip95Config } from '@/lib/configStorageTypes'
+import { t } from '@/lib/i18n'
+import { DragHandle } from '../DragHandle'
+import { getApiCardClassName } from './getApiCardClassName'
+
+export function Nip95ApiCard(params: {
+  api: Nip95Config
+  priority: number
+  isEditing: boolean
+  draggedId: string | null
+  dragOverId: string | null
+  onStartEditing: (id: string) => void
+  onStopEditing: () => void
+  onUpdateUrl: (id: string, url: string) => void
+  onToggleEnabled: (id: string, enabled: boolean) => void
+  onRemoveApi: (id: string) => void
+  onDragStart: (e: React.DragEvent<HTMLDivElement>, id: string) => void
+  onDragOver: (e: React.DragEvent<HTMLDivElement>, id: string) => void
+  onDragLeave: () => void
+  onDrop: (e: React.DragEvent<HTMLDivElement>, targetId: string) => void
+}): React.ReactElement {
+  return (
+    <div
+      onDragOver={(e) => params.onDragOver(e, params.api.id)}
+      onDragLeave={params.onDragLeave}
+      onDrop={(e) => params.onDrop(e, params.api.id)}
+      className={`bg-cyber-dark border rounded p-4 space-y-3 transition-all ${getApiCardClassName(params.api.id, params.draggedId, params.dragOverId)}`}
+    >
+      <div className="flex items-start justify-between gap-4">
+        <div className="flex items-center gap-3 flex-1">
+          <DragGrip apiId={params.api.id} onDragStart={params.onDragStart} />
+          <UrlCell
+            api={params.api}
+            isEditing={params.isEditing}
+            onStartEditing={params.onStartEditing}
+            onStopEditing={params.onStopEditing}
+            onUpdateUrl={params.onUpdateUrl}
+          />
+        </div>
+        <ActionsCell api={params.api} onToggleEnabled={params.onToggleEnabled} onRemoveApi={params.onRemoveApi} />
+      </div>
+      <PriorityRow priority={params.priority} apiId={params.api.id} />
+    </div>
+  )
+}
+
+function DragGrip(params: { apiId: string; onDragStart: (e: React.DragEvent<HTMLDivElement>, id: string) => void }): React.ReactElement {
+  return (
+    <div
+      className="drag-handle cursor-grab active:cursor-grabbing"
+      draggable
+      onDragStart={(e) => {
+        params.onDragStart(e, params.apiId)
+        e.stopPropagation()
+      }}
+      onMouseDown={(e) => e.stopPropagation()}
+    >
+      <DragHandle />
+    </div>
+  )
+}
+
+function UrlCell(params: {
+  api: Nip95Config
+  isEditing: boolean
+  onStartEditing: (id: string) => void
+  onStopEditing: () => void
+  onUpdateUrl: (id: string, url: string) => void
+}): React.ReactElement {
+  return <div className="flex-1">{params.isEditing ? <UrlEditor api={params.api} onStop={params.onStopEditing} onUpdate={params.onUpdateUrl} /> : <UrlText api={params.api} onStartEditing={params.onStartEditing} />}</div>
+}
+
+function UrlText(params: { api: Nip95Config; onStartEditing: (id: string) => void }): React.ReactElement {
+  return (
+    <div
+      className="text-neon-cyan cursor-pointer hover:text-neon-green transition-colors"
+      onClick={() => params.onStartEditing(params.api.id)}
+      title={t('settings.nip95.list.editUrl')}
+    >
+      {params.api.url}
+    </div>
+  )
+}
+
+function UrlEditor(params: { api: Nip95Config; onStop: () => void; onUpdate: (id: string, url: string) => void }): React.ReactElement {
+  return (
+    <input
+      type="url"
+      defaultValue={params.api.url}
+      onBlur={(e) => {
+        const next = e.target.value
+        if (next !== params.api.url) {
+          params.onUpdate(params.api.id, next)
+        } else {
+          params.onStop()
+        }
+      }}
+      onKeyDown={(e) => {
+        if (e.key === 'Enter') {
+          e.currentTarget.blur()
+        } else if (e.key === 'Escape') {
+          params.onStop()
+        }
+      }}
+      className="w-full px-3 py-2 bg-cyber-darker border border-neon-cyan/50 rounded text-cyber-light focus:border-neon-cyan focus:outline-none"
+      autoFocus
+    />
+  )
+}
+
+function ActionsCell(params: { api: Nip95Config; onToggleEnabled: (id: string, enabled: boolean) => void; onRemoveApi: (id: string) => void }): React.ReactElement {
+  return (
+    <div className="flex items-center gap-2">
+      <EnabledToggle api={params.api} onToggleEnabled={params.onToggleEnabled} />
+      <RemoveButton apiId={params.api.id} onRemove={params.onRemoveApi} />
+    </div>
+  )
+}
+
+function EnabledToggle(params: { api: Nip95Config; onToggleEnabled: (id: string, enabled: boolean) => void }): React.ReactElement {
+  return (
+    <label className="flex items-center gap-2 cursor-pointer">
+      <input
+        type="checkbox"
+        checked={params.api.enabled}
+        onChange={(e) => params.onToggleEnabled(params.api.id, e.target.checked)}
+        className="w-4 h-4 text-neon-cyan bg-cyber-darker border-cyber-accent rounded focus:ring-neon-cyan"
+      />
+      <span className="text-sm text-cyber-accent">
+        {params.api.enabled ? t('settings.nip95.list.enabled') : t('settings.nip95.list.disabled')}
+      </span>
+    </label>
+  )
+}
+
+function RemoveButton(params: { apiId: string; onRemove: (id: string) => void }): React.ReactElement {
+  return (
+    <button
+      type="button"
+      onClick={() => params.onRemove(params.apiId)}
+      className="px-3 py-1 text-sm bg-red-900/30 hover:bg-red-900/50 text-red-300 border border-red-500/50 rounded transition-colors"
+      title={t('settings.nip95.list.remove')}
+    >
+      {t('settings.nip95.list.remove')}
+    </button>
+  )
+}
+
+function PriorityRow(params: { priority: number; apiId: string }): React.ReactElement {
+  return (
+    <div className="flex items-center gap-2 text-xs text-cyber-accent/70">
+      <span>{t('settings.nip95.list.priorityLabel', { priority: params.priority, id: params.apiId })}</span>
+    </div>
+  )
+}
diff --git a/components/nip95Config/Nip95ApiList.tsx b/components/nip95Config/Nip95ApiList.tsx
new file mode 100644
index 0000000..8c0cb5b
--- /dev/null
+++ b/components/nip95Config/Nip95ApiList.tsx
@@ -0,0 +1,30 @@
+import type { Nip95Config } from '@/lib/configStorageTypes'
+import { t } from '@/lib/i18n'
+import { Nip95ApiCard } from './Nip95ApiCard'
+
+export function Nip95ApiList(params: {
+  apis: Nip95Config[]
+  editingId: string | null
+  draggedId: string | null
+  dragOverId: string | null
+  onStartEditing: (id: string) => void
+  onStopEditing: () => void
+  onUpdateUrl: (id: string, url: string) => void
+  onToggleEnabled: (id: string, enabled: boolean) => void
+  onRemoveApi: (id: string) => void
+  onDragStart: (e: React.DragEvent<HTMLDivElement>, id: string) => void
+  onDragOver: (e: React.DragEvent<HTMLDivElement>, id: string) => void
+  onDragLeave: () => void
+  onDrop: (e: React.DragEvent<HTMLDivElement>, targetId: string) => void
+}): React.ReactElement {
+  if (params.apis.length === 0) {
+    return <div className="text-center py-8 text-cyber-accent">{t('settings.nip95.empty')}</div>
+  }
+  return (
+    <div className="space-y-4">
+      {params.apis.map((api, index) => (
+        <Nip95ApiCard key={api.id} api={api} priority={index + 1} isEditing={params.editingId === api.id} draggedId={params.draggedId} dragOverId={params.dragOverId} onStartEditing={params.onStartEditing} onStopEditing={params.onStopEditing} onUpdateUrl={params.onUpdateUrl} onToggleEnabled={params.onToggleEnabled} onRemoveApi={params.onRemoveApi} onDragStart={params.onDragStart} onDragOver={params.onDragOver} onDragLeave={params.onDragLeave} onDrop={params.onDrop} />
+      ))}
+    </div>
+  )
+}
diff --git a/components/nip95Config/Nip95ConfigContent.tsx b/components/nip95Config/Nip95ConfigContent.tsx
new file mode 100644
index 0000000..219a8f1
--- /dev/null
+++ b/components/nip95Config/Nip95ConfigContent.tsx
@@ -0,0 +1,107 @@
+import type { Nip95Config } from '@/lib/configStorageTypes'
+import { t } from '@/lib/i18n'
+import { Nip95ApiList } from './Nip95ApiList'
+
+export function Nip95ConfigContent(params: {
+  apis: Nip95Config[]
+  error: string | null
+  editingId: string | null
+  newUrl: string
+  showAddForm: boolean
+  draggedId: string | null
+  dragOverId: string | null
+  onClearError: () => void
+  onToggleAddForm: () => void
+  onNewUrlChange: (value: string) => void
+  onCancelAdd: () => void
+  onAddApi: () => void
+  onStartEditing: (id: string) => void
+  onStopEditing: () => void
+  onUpdateUrl: (id: string, url: string) => void
+  onToggleEnabled: (id: string, enabled: boolean) => void
+  onRemoveApi: (id: string) => void
+  onDragStart: (e: React.DragEvent<HTMLDivElement>, id: string) => void
+  onDragOver: (e: React.DragEvent<HTMLDivElement>, id: string) => void
+  onDragLeave: () => void
+  onDrop: (e: React.DragEvent<HTMLDivElement>, targetId: string) => void
+}): React.ReactElement {
+  return (
+    <div className="space-y-6">
+      {params.error ? <ErrorBanner error={params.error} onClear={params.onClearError} /> : null}
+      <Header showAddForm={params.showAddForm} onToggleAddForm={params.onToggleAddForm} />
+      {params.showAddForm ? <AddForm newUrl={params.newUrl} onNewUrlChange={params.onNewUrlChange} onAdd={params.onAddApi} onCancel={params.onCancelAdd} /> : null}
+      <Nip95ApiList apis={params.apis} editingId={params.editingId} draggedId={params.draggedId} dragOverId={params.dragOverId} onStartEditing={params.onStartEditing} onStopEditing={params.onStopEditing} onUpdateUrl={params.onUpdateUrl} onToggleEnabled={params.onToggleEnabled} onRemoveApi={params.onRemoveApi} onDragStart={params.onDragStart} onDragOver={params.onDragOver} onDragLeave={params.onDragLeave} onDrop={params.onDrop} />
+      <Notes />
+    </div>
+  )
+}
+
+function ErrorBanner(params: { error: string; onClear: () => void }): React.ReactElement {
+  return (
+    <div className="bg-red-900/30 border border-red-500/50 rounded p-4 text-red-300">
+      {params.error}
+      <button type="button" onClick={params.onClear} className="ml-4 text-red-400 hover:text-red-200">
+        ×
+      </button>
+    </div>
+  )
+}
+
+function Header(params: { showAddForm: boolean; onToggleAddForm: () => void }): React.ReactElement {
+  return (
+    <div className="flex justify-between items-center">
+      <h2 className="text-2xl font-bold text-neon-cyan">{t('settings.nip95.title')}</h2>
+      <button
+        type="button"
+        onClick={params.onToggleAddForm}
+        className="px-4 py-2 bg-neon-cyan/20 hover:bg-neon-cyan/30 text-neon-cyan border border-neon-cyan/50 rounded transition-colors"
+      >
+        {params.showAddForm ? t('settings.nip95.add.cancel') : t('settings.nip95.addButton')}
+      </button>
+    </div>
+  )
+}
+
+function AddForm(params: { newUrl: string; onNewUrlChange: (value: string) => void; onAdd: () => void; onCancel: () => void }): React.ReactElement {
+  return (
+    <div className="bg-cyber-dark border border-neon-cyan/30 rounded p-4 space-y-4">
+      <div>
+        <label className="block text-sm font-medium text-cyber-accent mb-2">{t('settings.nip95.add.url')}</label>
+        <input
+          type="url"
+          value={params.newUrl}
+          onChange={(e) => params.onNewUrlChange(e.target.value)}
+          placeholder={t('settings.nip95.add.placeholder')}
+          className="w-full px-4 py-2 bg-cyber-darker border border-cyber-accent/30 rounded text-cyber-light focus:border-neon-cyan focus:outline-none"
+        />
+      </div>
+      <div className="flex gap-2">
+        <button
+          type="button"
+          onClick={params.onAdd}
+          className="px-4 py-2 bg-neon-cyan/20 hover:bg-neon-cyan/30 text-neon-cyan border border-neon-cyan/50 rounded transition-colors"
+        >
+          {t('settings.nip95.add.add')}
+        </button>
+        <button
+          type="button"
+          onClick={params.onCancel}
+          className="px-4 py-2 bg-cyber-accent/20 hover:bg-cyber-accent/30 text-cyber-accent border border-cyber-accent/50 rounded transition-colors"
+        >
+          {t('settings.nip95.add.cancel')}
+        </button>
+      </div>
+    </div>
+  )
+}
+
+function Notes(): React.ReactElement {
+  return (
+    <div className="text-sm text-cyber-accent space-y-2">
+      <p>
+        <strong>{t('settings.nip95.note.title')}</strong> {t('settings.nip95.note.priority')}
+      </p>
+      <p>{t('settings.nip95.note.fallback')}</p>
+    </div>
+  )
+}
diff --git a/components/nip95Config/Nip95ConfigManager.tsx b/components/nip95Config/Nip95ConfigManager.tsx
new file mode 100644
index 0000000..231740a
--- /dev/null
+++ b/components/nip95Config/Nip95ConfigManager.tsx
@@ -0,0 +1,45 @@
+import { useEffect, useState } from 'react'
+import type { Nip95Config } from '@/lib/configStorageTypes'
+import { Nip95ConfigView } from './view'
+import { loadApis } from './controller'
+import { createNip95ConfigViewProps } from './viewModel'
+
+export interface Nip95ConfigManagerProps {
+  onConfigChange?: () => void
+}
+
+export function Nip95ConfigManager(props: Nip95ConfigManagerProps): React.ReactElement {
+  const [apis, setApis] = useState<Nip95Config[]>([])
+  const [loading, setLoading] = useState(true)
+  const [error, setError] = useState<string | null>(null)
+  const [editingId, setEditingId] = useState<string | null>(null)
+  const [newUrl, setNewUrl] = useState('')
+  const [showAddForm, setShowAddForm] = useState(false)
+  const [draggedId, setDraggedId] = useState<string | null>(null)
+  const [dragOverId, setDragOverId] = useState<string | null>(null)
+
+  useEffect(() => {
+    void loadApis({ setApis, setLoading, setError })
+  }, [])
+
+  const viewProps = createNip95ConfigViewProps({
+    apis,
+    loading,
+    error,
+    editingId,
+    newUrl,
+    showAddForm,
+    draggedId,
+    dragOverId,
+    setApis,
+    setError,
+    setEditingId,
+    setNewUrl,
+    setShowAddForm,
+    setDraggedId,
+    setDragOverId,
+    onConfigChange: props.onConfigChange,
+  })
+
+  return <Nip95ConfigView {...viewProps} />
+}
diff --git a/components/nip95Config/Nip95ConfigView.tsx b/components/nip95Config/Nip95ConfigView.tsx
new file mode 100644
index 0000000..e2d2058
--- /dev/null
+++ b/components/nip95Config/Nip95ConfigView.tsx
@@ -0,0 +1,37 @@
+import type { Nip95Config } from '@/lib/configStorageTypes'
+import { t } from '@/lib/i18n'
+import { Nip95ConfigContent } from './Nip95ConfigContent'
+
+export function Nip95ConfigView(params: {
+  apis: Nip95Config[]
+  loading: boolean
+  error: string | null
+  editingId: string | null
+  newUrl: string
+  showAddForm: boolean
+  draggedId: string | null
+  dragOverId: string | null
+  onClearError: () => void
+  onToggleAddForm: () => void
+  onNewUrlChange: (value: string) => void
+  onCancelAdd: () => void
+  onAddApi: () => void
+  onStartEditing: (id: string) => void
+  onStopEditing: () => void
+  onUpdateUrl: (id: string, url: string) => void
+  onToggleEnabled: (id: string, enabled: boolean) => void
+  onRemoveApi: (id: string) => void
+  onDragStart: (e: React.DragEvent<HTMLDivElement>, id: string) => void
+  onDragOver: (e: React.DragEvent<HTMLDivElement>, id: string) => void
+  onDragLeave: () => void
+  onDrop: (e: React.DragEvent<HTMLDivElement>, targetId: string) => void
+}): React.ReactElement {
+  if (params.loading) {
+    return (
+      <div className="text-center py-8 text-neon-cyan">
+        <div>{t('settings.nip95.loading')}</div>
+      </div>
+    )
+  }
+  return <Nip95ConfigContent {...params} />
+}
diff --git a/components/nip95Config/controller.ts b/components/nip95Config/controller.ts
new file mode 100644
index 0000000..fd3d99a
--- /dev/null
+++ b/components/nip95Config/controller.ts
@@ -0,0 +1,212 @@
+import { configStorage } from '@/lib/configStorage'
+import type { Nip95Config } from '@/lib/configStorageTypes'
+import { t } from '@/lib/i18n'
+import { userConfirm } from '@/lib/userConfirm'
+
+export async function loadApis(params: {
+  setApis: (value: Nip95Config[]) => void
+  setLoading: (value: boolean) => void
+  setError: (value: string | null) => void
+}): Promise<void> {
+  try {
+    params.setLoading(true)
+    params.setError(null)
+    const config = await configStorage.getConfig()
+    params.setApis(config.nip95Apis.sort((a, b) => a.priority - b.priority))
+  } catch (e) {
+    const errorMessage = e instanceof Error ? e.message : t('settings.nip95.error.loadFailed')
+    params.setError(errorMessage)
+    console.error('[Nip95Config] Error loading APIs:', e)
+  } finally {
+    params.setLoading(false)
+  }
+}
+
+export async function toggleEnabled(params: {
+  id: string
+  enabled: boolean
+  setApis: (value: Nip95Config[]) => void
+  setError: (value: string | null) => void
+  onConfigChange: (() => void) | undefined
+}): Promise<void> {
+  try {
+    await configStorage.updateNip95Api(params.id, { enabled: params.enabled })
+    await reloadApis({ setApis: params.setApis, setError: params.setError })
+    params.onConfigChange?.()
+  } catch (e) {
+    const errorMessage = e instanceof Error ? e.message : t('settings.nip95.error.updateFailed')
+    params.setError(errorMessage)
+    console.error('[Nip95Config] Error updating API:', e)
+  }
+}
+
+export async function updateUrl(params: {
+  id: string
+  url: string
+  setApis: (value: Nip95Config[]) => void
+  setError: (value: string | null) => void
+  setEditingId: (value: string | null) => void
+  onConfigChange: (() => void) | undefined
+}): Promise<void> {
+  try {
+    await configStorage.updateNip95Api(params.id, { url: params.url })
+    await reloadApis({ setApis: params.setApis, setError: params.setError })
+    params.setEditingId(null)
+    params.onConfigChange?.()
+  } catch (e) {
+    const errorMessage = e instanceof Error ? e.message : t('settings.nip95.error.urlFailed')
+    params.setError(errorMessage)
+    console.error('[Nip95Config] Error updating URL:', e)
+  }
+}
+
+export async function addApi(params: {
+  newUrl: string
+  setError: (value: string | null) => void
+  setNewUrl: (value: string) => void
+  setShowAddForm: (value: boolean | ((prev: boolean) => boolean)) => void
+  setApis: (value: Nip95Config[]) => void
+  onConfigChange: (() => void) | undefined
+}): Promise<void> {
+  if (!params.newUrl.trim()) {
+    params.setError(t('settings.nip95.error.urlRequired'))
+    return
+  }
+  try {
+    void new URL(params.newUrl)
+    await configStorage.addNip95Api(params.newUrl.trim(), false)
+    params.setNewUrl('')
+    params.setShowAddForm(false)
+    await reloadApis({ setApis: params.setApis, setError: params.setError })
+    params.onConfigChange?.()
+  } catch (e) {
+    params.setError(getAddApiErrorMessage(e))
+    console.error('[Nip95Config] Error adding API:', e)
+  }
+}
+
+export async function removeApi(params: {
+  id: string
+  setApis: (value: Nip95Config[]) => void
+  setError: (value: string | null) => void
+  onConfigChange: (() => void) | undefined
+}): Promise<void> {
+  const confirmed = await userConfirm(t('settings.nip95.remove.confirm'))
+  if (!confirmed) {
+    return
+  }
+  try {
+    await configStorage.removeNip95Api(params.id)
+    await reloadApis({ setApis: params.setApis, setError: params.setError })
+    params.onConfigChange?.()
+  } catch (e) {
+    const errorMessage = e instanceof Error ? e.message : t('settings.nip95.error.removeFailed')
+    params.setError(errorMessage)
+    console.error('[Nip95Config] Error removing API:', e)
+  }
+}
+
+export function onDragStart(params: {
+  e: React.DragEvent<HTMLDivElement>
+  id: string
+  setDraggedId: (value: string | null) => void
+}): void {
+  params.setDraggedId(params.id)
+  const { dataTransfer } = params.e
+  dataTransfer.effectAllowed = 'move'
+  dataTransfer.setData('text/plain', params.id)
+}
+
+export function onDragOver(params: {
+  e: React.DragEvent<HTMLDivElement>
+  id: string
+  setDragOverId: (value: string | null) => void
+}): void {
+  params.e.preventDefault()
+  const { dataTransfer } = params.e
+  dataTransfer.dropEffect = 'move'
+  params.setDragOverId(params.id)
+}
+
+export async function onDrop(params: {
+  e: React.DragEvent<HTMLDivElement>
+  targetId: string
+  apis: Nip95Config[]
+  draggedId: string | null
+  setApis: (value: Nip95Config[]) => void
+  setDraggedId: (value: string | null) => void
+  setDragOverId: (value: string | null) => void
+  setError: (value: string | null) => void
+  onConfigChange: (() => void) | undefined
+}): Promise<void> {
+  params.e.preventDefault()
+  params.setDragOverId(null)
+  if (!params.draggedId || params.draggedId === params.targetId) {
+    params.setDraggedId(null)
+    return
+  }
+  const reordered = reorderApis({ apis: params.apis, draggedId: params.draggedId, targetId: params.targetId })
+  if (!reordered) {
+    params.setDraggedId(null)
+    return
+  }
+  params.setApis(reordered)
+  params.setDraggedId(null)
+  await updatePriorities({ apis: reordered, setError: params.setError, onConfigChange: params.onConfigChange })
+}
+
+async function reloadApis(params: { setApis: (value: Nip95Config[]) => void; setError: (value: string | null) => void }): Promise<void> {
+  try {
+    const config = await configStorage.getConfig()
+    params.setApis(config.nip95Apis.sort((a, b) => a.priority - b.priority))
+  } catch (e) {
+    const errorMessage = e instanceof Error ? e.message : t('settings.nip95.error.loadFailed')
+    params.setError(errorMessage)
+    console.error('[Nip95Config] Error reloading APIs:', e)
+  }
+}
+
+function getAddApiErrorMessage(error: unknown): string {
+  if (error instanceof TypeError && error.message.includes('Invalid URL')) {
+    return t('settings.nip95.error.invalidUrl')
+  }
+  if (error instanceof Error) {
+    return error.message
+  }
+  return t('settings.nip95.error.addFailed')
+}
+
+function reorderApis(params: { apis: Nip95Config[]; draggedId: string; targetId: string }): Nip95Config[] | null {
+  const draggedIndex = params.apis.findIndex((api) => api.id === params.draggedId)
+  const targetIndex = params.apis.findIndex((api) => api.id === params.targetId)
+  if (draggedIndex === -1 || targetIndex === -1) {
+    return null
+  }
+  const next = [...params.apis]
+  const removed = next[draggedIndex]
+  if (!removed) {
+    return null
+  }
+  next.splice(draggedIndex, 1)
+  next.splice(targetIndex, 0, removed)
+  return next
+}
+
+async function updatePriorities(params: {
+  apis: Nip95Config[]
+  setError: (value: string | null) => void
+  onConfigChange: (() => void) | undefined
+}): Promise<void> {
+  try {
+    const updates = params.apis.map((api, index) => {
+      const priority = index + 1
+      return api.priority !== priority ? configStorage.updateNip95Api(api.id, { priority }) : Promise.resolve()
+    })
+    await Promise.all(updates)
+    params.onConfigChange?.()
+  } catch (e) {
+    const errorMessage = e instanceof Error ? e.message : t('settings.nip95.error.priorityFailed')
+    params.setError(errorMessage)
+    console.error('[Nip95Config] Error updating priorities:', e)
+  }
+}
diff --git a/components/nip95Config/getApiCardClassName.ts b/components/nip95Config/getApiCardClassName.ts
new file mode 100644
index 0000000..aa0c01a
--- /dev/null
+++ b/components/nip95Config/getApiCardClassName.ts
@@ -0,0 +1,9 @@
+export function getApiCardClassName(apiId: string, draggedId: string | null, dragOverId: string | null): string {
+  if (draggedId === apiId) {
+    return 'opacity-50 border-neon-cyan'
+  }
+  if (dragOverId === apiId) {
+    return 'border-neon-green shadow-lg'
+  }
+  return 'border-neon-cyan/30'
+}
diff --git a/components/nip95Config/view.tsx b/components/nip95Config/view.tsx
new file mode 100644
index 0000000..bd993ee
--- /dev/null
+++ b/components/nip95Config/view.tsx
@@ -0,0 +1 @@
+export { Nip95ConfigView } from './Nip95ConfigView'
diff --git a/components/nip95Config/viewModel.ts b/components/nip95Config/viewModel.ts
new file mode 100644
index 0000000..99ff975
--- /dev/null
+++ b/components/nip95Config/viewModel.ts
@@ -0,0 +1,121 @@
+import type { Nip95Config } from '@/lib/configStorageTypes'
+import { Nip95ConfigView } from './view'
+import { addApi, onDragOver, onDragStart, onDrop, removeApi, toggleEnabled, updateUrl } from './controller'
+
+type ViewProps = Parameters<typeof Nip95ConfigView>[0]
+
+export function createNip95ConfigViewProps(params: {
+  apis: Nip95Config[]
+  loading: boolean
+  error: string | null
+  editingId: string | null
+  newUrl: string
+  showAddForm: boolean
+  draggedId: string | null
+  dragOverId: string | null
+  setApis: (value: Nip95Config[]) => void
+  setError: (value: string | null) => void
+  setEditingId: (value: string | null) => void
+  setNewUrl: (value: string) => void
+  setShowAddForm: (value: boolean | ((prev: boolean) => boolean)) => void
+  setDraggedId: (value: string | null) => void
+  setDragOverId: (value: string | null) => void
+  onConfigChange: (() => void) | undefined
+}): ViewProps {
+  return { ...baseStateProps(params), ...formHandlers(params), ...apiHandlers(params), ...dragHandlers(params) }
+}
+
+function baseStateProps(params: {
+  apis: Nip95Config[]
+  loading: boolean
+  error: string | null
+  editingId: string | null
+  newUrl: string
+  showAddForm: boolean
+  draggedId: string | null
+  dragOverId: string | null
+}): Pick<ViewProps, 'apis' | 'loading' | 'error' | 'editingId' | 'newUrl' | 'showAddForm' | 'draggedId' | 'dragOverId'> {
+  return {
+    apis: params.apis,
+    loading: params.loading,
+    error: params.error,
+    editingId: params.editingId,
+    newUrl: params.newUrl,
+    showAddForm: params.showAddForm,
+    draggedId: params.draggedId,
+    dragOverId: params.dragOverId,
+  }
+}
+
+function formHandlers(params: {
+  newUrl: string
+  setApis: (value: Nip95Config[]) => void
+  setError: (value: string | null) => void
+  setNewUrl: (value: string) => void
+  setShowAddForm: (value: boolean | ((prev: boolean) => boolean)) => void
+  onConfigChange: (() => void) | undefined
+}): Pick<ViewProps, 'onClearError' | 'onToggleAddForm' | 'onNewUrlChange' | 'onCancelAdd' | 'onAddApi'> {
+  return {
+    onClearError: () => params.setError(null),
+    onToggleAddForm: () => params.setShowAddForm((prev) => !prev),
+    onNewUrlChange: (value) => params.setNewUrl(value),
+    onCancelAdd: () => {
+      params.setShowAddForm(false)
+      params.setNewUrl('')
+      params.setError(null)
+    },
+    onAddApi: () =>
+      void addApi({
+        newUrl: params.newUrl,
+        setError: params.setError,
+        setNewUrl: params.setNewUrl,
+        setShowAddForm: params.setShowAddForm,
+        setApis: params.setApis,
+        onConfigChange: params.onConfigChange,
+      }),
+  }
+}
+
+function apiHandlers(params: {
+  setApis: (value: Nip95Config[]) => void
+  setError: (value: string | null) => void
+  setEditingId: (value: string | null) => void
+  onConfigChange: (() => void) | undefined
+}): Pick<ViewProps, 'onStartEditing' | 'onStopEditing' | 'onUpdateUrl' | 'onToggleEnabled' | 'onRemoveApi'> {
+  return {
+    onStartEditing: (id) => params.setEditingId(id),
+    onStopEditing: () => params.setEditingId(null),
+    onUpdateUrl: (id, url) =>
+      void updateUrl({ id, url, setError: params.setError, setEditingId: params.setEditingId, setApis: params.setApis, onConfigChange: params.onConfigChange }),
+    onToggleEnabled: (id, enabled) => void toggleEnabled({ id, enabled, setError: params.setError, setApis: params.setApis, onConfigChange: params.onConfigChange }),
+    onRemoveApi: (id) => void removeApi({ id, setError: params.setError, setApis: params.setApis, onConfigChange: params.onConfigChange }),
+  }
+}
+
+function dragHandlers(params: {
+  apis: Nip95Config[]
+  draggedId: string | null
+  setApis: (value: Nip95Config[]) => void
+  setDraggedId: (value: string | null) => void
+  setDragOverId: (value: string | null) => void
+  setError: (value: string | null) => void
+  onConfigChange: (() => void) | undefined
+}): Pick<ViewProps, 'onDragStart' | 'onDragOver' | 'onDragLeave' | 'onDrop'> {
+  return {
+    onDragStart: (e, id) => onDragStart({ e, id, setDraggedId: params.setDraggedId }),
+    onDragOver: (e, id) => onDragOver({ e, id, setDragOverId: params.setDragOverId }),
+    onDragLeave: () => params.setDragOverId(null),
+    onDrop: (e, targetId) =>
+      void onDrop({
+        e,
+        targetId,
+        apis: params.apis,
+        draggedId: params.draggedId,
+        setApis: params.setApis,
+        setDraggedId: params.setDraggedId,
+        setDragOverId: params.setDragOverId,
+        setError: params.setError,
+        onConfigChange: params.onConfigChange,
+      }),
+  }
+}
diff --git a/components/relayManager/RelayCard.tsx b/components/relayManager/RelayCard.tsx
new file mode 100644
index 0000000..9f0048d
--- /dev/null
+++ b/components/relayManager/RelayCard.tsx
@@ -0,0 +1,132 @@
+import type { RelayConfig } from '@/lib/configStorageTypes'
+import { t } from '@/lib/i18n'
+import { DragHandle } from '../DragHandle'
+import { getRelayCardClassName } from './controller'
+
+export function RelayCard(params: {
+  relay: RelayConfig
+  isEditing: boolean
+  draggedId: string | null
+  dragOverId: string | null
+  onStartEditing: (id: string) => void
+  onStopEditing: () => void
+  onUpdateUrl: (id: string, url: string) => void
+  onToggleEnabled: (id: string, enabled: boolean) => void
+  onRemoveRelay: (id: string) => void
+  onDragStart: (e: React.DragEvent<HTMLDivElement>, id: string) => void
+  onDragOver: (e: React.DragEvent<HTMLDivElement>, id: string) => void
+  onDragLeave: () => void
+  onDrop: (e: React.DragEvent<HTMLDivElement>, targetId: string) => void
+  onDragEnd: () => void
+}): React.ReactElement {
+  return (
+    <div
+      onDragOver={(e) => params.onDragOver(e, params.relay.id)}
+      onDragLeave={params.onDragLeave}
+      onDrop={(e) => params.onDrop(e, params.relay.id)}
+      className={`bg-cyber-dark border rounded p-4 space-y-3 transition-all ${getRelayCardClassName(params.relay.id, params.draggedId, params.dragOverId)}`}
+    >
+      <div className="flex items-start justify-between gap-4">
+        <div className="flex items-center gap-3 flex-1">
+          <DragGrip relayId={params.relay.id} onDragStart={params.onDragStart} onDragEnd={params.onDragEnd} />
+          <UrlCell relay={params.relay} isEditing={params.isEditing} onStartEditing={params.onStartEditing} onStopEditing={params.onStopEditing} onUpdateUrl={params.onUpdateUrl} />
+          {params.relay.lastSyncDate ? <LastSync lastSyncDate={params.relay.lastSyncDate} /> : null}
+        </div>
+        <ActionsCell relay={params.relay} onToggleEnabled={params.onToggleEnabled} onRemoveRelay={params.onRemoveRelay} />
+      </div>
+    </div>
+  )
+}
+
+function DragGrip(params: {
+  relayId: string
+  onDragStart: (e: React.DragEvent<HTMLDivElement>, id: string) => void
+  onDragEnd: () => void
+}): React.ReactElement {
+  return (
+    <div
+      className="drag-handle cursor-grab active:cursor-grabbing"
+      draggable
+      onDragStart={(e) => params.onDragStart(e, params.relayId)}
+      onDragEnd={params.onDragEnd}
+      onMouseDown={(e) => e.stopPropagation()}
+    >
+      <DragHandle />
+    </div>
+  )
+}
+
+function UrlCell(params: {
+  relay: RelayConfig
+  isEditing: boolean
+  onStartEditing: (id: string) => void
+  onStopEditing: () => void
+  onUpdateUrl: (id: string, url: string) => void
+}): React.ReactElement {
+  if (params.isEditing) {
+    return <UrlEditor relay={params.relay} onStop={params.onStopEditing} onUpdate={params.onUpdateUrl} />
+  }
+  return (
+    <div className="text-neon-cyan cursor-pointer hover:text-neon-green transition-colors" onClick={() => params.onStartEditing(params.relay.id)} title={t('settings.relay.list.editUrl')}>
+      {params.relay.url}
+    </div>
+  )
+}
+
+function UrlEditor(params: { relay: RelayConfig; onStop: () => void; onUpdate: (id: string, url: string) => void }): React.ReactElement {
+  return (
+    <input
+      type="text"
+      defaultValue={params.relay.url}
+      onBlur={(e) => {
+        const next = e.target.value
+        if (next !== params.relay.url) {
+          params.onUpdate(params.relay.id, next)
+        } else {
+          params.onStop()
+        }
+      }}
+      onKeyDown={(e) => {
+        if (e.key === 'Enter') {
+          e.currentTarget.blur()
+        } else if (e.key === 'Escape') {
+          params.onStop()
+        }
+      }}
+      className="w-full px-3 py-2 bg-cyber-darker border border-neon-cyan/50 rounded text-cyber-light focus:border-neon-cyan focus:outline-none"
+      autoFocus
+    />
+  )
+}
+
+function LastSync(params: { lastSyncDate: string }): React.ReactElement {
+  return (
+    <div className="text-xs text-cyber-accent/70 mt-1">
+      {t('settings.relay.list.lastSync')}: {new Date(params.lastSyncDate).toLocaleString()}
+    </div>
+  )
+}
+
+function ActionsCell(params: { relay: RelayConfig; onToggleEnabled: (id: string, enabled: boolean) => void; onRemoveRelay: (id: string) => void }): React.ReactElement {
+  return (
+    <div className="flex items-center gap-2">
+      <label className="flex items-center gap-2 cursor-pointer">
+        <input
+          type="checkbox"
+          checked={params.relay.enabled}
+          onChange={(e) => params.onToggleEnabled(params.relay.id, e.target.checked)}
+          className="w-4 h-4 text-neon-cyan bg-cyber-darker border-cyber-accent rounded focus:ring-neon-cyan"
+        />
+        <span className="text-sm text-cyber-accent">{params.relay.enabled ? t('settings.relay.list.enabled') : t('settings.relay.list.disabled')}</span>
+      </label>
+      <button
+        type="button"
+        onClick={() => params.onRemoveRelay(params.relay.id)}
+        className="px-3 py-1 text-sm bg-red-900/30 hover:bg-red-900/50 text-red-300 border border-red-500/50 rounded transition-colors"
+        title={t('settings.relay.list.remove')}
+      >
+        {t('settings.relay.list.remove')}
+      </button>
+    </div>
+  )
+}
diff --git a/components/relayManager/RelayList.tsx b/components/relayManager/RelayList.tsx
new file mode 100644
index 0000000..5932db1
--- /dev/null
+++ b/components/relayManager/RelayList.tsx
@@ -0,0 +1,49 @@
+import type { RelayConfig } from '@/lib/configStorageTypes'
+import { t } from '@/lib/i18n'
+import { RelayCard } from './RelayCard'
+
+interface RelayListProps {
+  relays: RelayConfig[]
+  editingId: string | null
+  draggedId: string | null
+  dragOverId: string | null
+  onStartEditing: (id: string) => void
+  onStopEditing: () => void
+  onUpdateUrl: (id: string, url: string) => void
+  onToggleEnabled: (id: string, enabled: boolean) => void
+  onRemoveRelay: (id: string) => void
+  onDragStart: (e: React.DragEvent<HTMLDivElement>, id: string) => void
+  onDragOver: (e: React.DragEvent<HTMLDivElement>, id: string) => void
+  onDragLeave: () => void
+  onDrop: (e: React.DragEvent<HTMLDivElement>, targetId: string) => void
+  onDragEnd: () => void
+}
+
+export function RelayList(params: RelayListProps): React.ReactElement {
+  if (params.relays.length === 0) {
+    return <div className="text-center py-8 text-cyber-accent">{t('settings.relay.empty')}</div>
+  }
+  return (
+    <div className="space-y-4">
+      {params.relays.map((relay) => (
+        <RelayCard
+          key={relay.id}
+          relay={relay}
+          isEditing={params.editingId === relay.id}
+          draggedId={params.draggedId}
+          dragOverId={params.dragOverId}
+          onStartEditing={params.onStartEditing}
+          onStopEditing={params.onStopEditing}
+          onUpdateUrl={params.onUpdateUrl}
+          onToggleEnabled={params.onToggleEnabled}
+          onRemoveRelay={params.onRemoveRelay}
+          onDragStart={params.onDragStart}
+          onDragOver={params.onDragOver}
+          onDragLeave={params.onDragLeave}
+          onDrop={params.onDrop}
+          onDragEnd={params.onDragEnd}
+        />
+      ))}
+    </div>
+  )
+}
diff --git a/components/relayManager/RelayManager.tsx b/components/relayManager/RelayManager.tsx
new file mode 100644
index 0000000..e3ea5ff
--- /dev/null
+++ b/components/relayManager/RelayManager.tsx
@@ -0,0 +1,46 @@
+import { useEffect, useState } from 'react'
+import type { RelayConfig } from '@/lib/configStorageTypes'
+import { RelayManagerView } from './view'
+import { initialLoadRelays } from './viewModel'
+import { buildRelayManagerViewProps } from './viewProps'
+
+export interface RelayManagerProps {
+  onConfigChange?: () => void
+}
+
+export function RelayManager(props: RelayManagerProps): React.ReactElement {
+  const [relays, setRelays] = useState<RelayConfig[]>([])
+  const [loading, setLoading] = useState(true)
+  const [error, setError] = useState<string | null>(null)
+  const [editingId, setEditingId] = useState<string | null>(null)
+  const [newUrl, setNewUrl] = useState('')
+  const [showAddForm, setShowAddForm] = useState(false)
+  const [draggedId, setDraggedId] = useState<string | null>(null)
+  const [dragOverId, setDragOverId] = useState<string | null>(null)
+
+  useEffect(() => {
+    initialLoadRelays({ setRelays, setLoading, setError })
+  }, [])
+
+  const viewProps = buildRelayManagerViewProps({
+    relays,
+    loading,
+    error,
+    editingId,
+    newUrl,
+    showAddForm,
+    draggedId,
+    dragOverId,
+    setRelays,
+    setLoading,
+    setError,
+    setEditingId,
+    setNewUrl,
+    setShowAddForm,
+    setDraggedId,
+    setDragOverId,
+    onConfigChange: props.onConfigChange,
+  })
+
+  return <RelayManagerView {...viewProps} />
+}
diff --git a/components/relayManager/RelayManagerContent.tsx b/components/relayManager/RelayManagerContent.tsx
new file mode 100644
index 0000000..0dc5131
--- /dev/null
+++ b/components/relayManager/RelayManagerContent.tsx
@@ -0,0 +1,100 @@
+import { t } from '@/lib/i18n'
+import { RelayList } from './RelayList'
+import type { RelayManagerContentProps } from './types'
+
+export function RelayManagerContent(params: RelayManagerContentProps): React.ReactElement {
+  return (
+    <div className="space-y-6">
+      {params.error ? <ErrorBanner error={params.error} onClear={params.onClearError} /> : null}
+      <Header showAddForm={params.showAddForm} onToggleAddForm={params.onToggleAddForm} />
+      {params.showAddForm ? <AddForm newUrl={params.newUrl} onNewUrlChange={params.onNewUrlChange} onAdd={params.onAddRelay} onCancel={params.onCancelAdd} /> : null}
+      <RelayList
+        relays={params.relays}
+        editingId={params.editingId}
+        draggedId={params.draggedId}
+        dragOverId={params.dragOverId}
+        onStartEditing={params.onStartEditing}
+        onStopEditing={params.onStopEditing}
+        onUpdateUrl={params.onUpdateUrl}
+        onToggleEnabled={params.onToggleEnabled}
+        onRemoveRelay={params.onRemoveRelay}
+        onDragStart={params.onDragStart}
+        onDragOver={params.onDragOver}
+        onDragLeave={params.onDragLeave}
+        onDrop={params.onDrop}
+        onDragEnd={params.onDragEnd}
+      />
+      <Notes />
+    </div>
+  )
+}
+
+function ErrorBanner(params: { error: string; onClear: () => void }): React.ReactElement {
+  return (
+    <div className="bg-red-900/30 border border-red-500/50 rounded p-4 text-red-300">
+      {params.error}
+      <button type="button" onClick={params.onClear} className="ml-4 text-red-400 hover:text-red-200">
+        ×
+      </button>
+    </div>
+  )
+}
+
+function Header(params: { showAddForm: boolean; onToggleAddForm: () => void }): React.ReactElement {
+  return (
+    <div className="flex justify-between items-center">
+      <h2 className="text-2xl font-bold text-neon-cyan">{t('settings.relay.title')}</h2>
+      <button
+        type="button"
+        onClick={params.onToggleAddForm}
+        className="px-4 py-2 bg-neon-cyan/20 hover:bg-neon-cyan/30 text-neon-cyan border border-neon-cyan/50 rounded transition-colors"
+      >
+        {params.showAddForm ? t('settings.relay.add.cancel') : t('settings.relay.addButton')}
+      </button>
+    </div>
+  )
+}
+
+function AddForm(params: { newUrl: string; onNewUrlChange: (value: string) => void; onAdd: () => void; onCancel: () => void }): React.ReactElement {
+  return (
+    <div className="bg-cyber-dark border border-neon-cyan/30 rounded p-4 space-y-4">
+      <div>
+        <label className="block text-sm font-medium text-cyber-accent mb-2">{t('settings.relay.add.url')}</label>
+        <input
+          type="text"
+          value={params.newUrl}
+          onChange={(e) => params.onNewUrlChange(e.target.value)}
+          placeholder={t('settings.relay.add.placeholder')}
+          className="w-full px-4 py-2 bg-cyber-darker border border-cyber-accent/30 rounded text-cyber-light focus:border-neon-cyan focus:outline-none"
+        />
+      </div>
+      <div className="flex gap-2">
+        <button
+          type="button"
+          onClick={params.onAdd}
+          className="px-4 py-2 bg-neon-cyan/20 hover:bg-neon-cyan/30 text-neon-cyan border border-neon-cyan/50 rounded transition-colors"
+        >
+          {t('settings.relay.add.add')}
+        </button>
+        <button
+          type="button"
+          onClick={params.onCancel}
+          className="px-4 py-2 bg-cyber-accent/20 hover:bg-cyber-accent/30 text-cyber-accent border border-cyber-accent/50 rounded transition-colors"
+        >
+          {t('settings.relay.add.cancel')}
+        </button>
+      </div>
+    </div>
+  )
+}
+
+function Notes(): React.ReactElement {
+  return (
+    <div className="text-sm text-cyber-accent space-y-2">
+      <p>
+        <strong>{t('settings.relay.note.title')}</strong> {t('settings.relay.note.priority')}
+      </p>
+      <p>{t('settings.relay.note.rotation')}</p>
+    </div>
+  )
+}
diff --git a/components/relayManager/controller.ts b/components/relayManager/controller.ts
new file mode 100644
index 0000000..6b0058d
--- /dev/null
+++ b/components/relayManager/controller.ts
@@ -0,0 +1,256 @@
+import { configStorage } from '@/lib/configStorage'
+import type { RelayConfig } from '@/lib/configStorageTypes'
+import { t } from '@/lib/i18n'
+import { relaySessionManager } from '@/lib/relaySessionManager'
+import { userConfirm } from '@/lib/userConfirm'
+
+export async function loadRelays(params: {
+  setRelays: (value: RelayConfig[]) => void
+  setLoading: (value: boolean) => void
+  setError: (value: string | null) => void
+}): Promise<void> {
+  try {
+    params.setLoading(true)
+    params.setError(null)
+    const config = await configStorage.getConfig()
+    const updated = await maybeDisableFailedRelays(config.relays)
+    params.setRelays(sortByPriority(updated))
+  } catch (e) {
+    const errorMessage = e instanceof Error ? e.message : t('settings.relay.error.loadFailed')
+    params.setError(errorMessage)
+    console.error('[RelayManager] Error loading relays:', e)
+  } finally {
+    params.setLoading(false)
+  }
+}
+
+export async function toggleEnabled(params: {
+  id: string
+  enabled: boolean
+  setRelays: (value: RelayConfig[]) => void
+  setError: (value: string | null) => void
+  onConfigChange: (() => void) | undefined
+}): Promise<void> {
+  try {
+    await configStorage.updateRelay(params.id, { enabled: params.enabled })
+    await reloadRelays({ setRelays: params.setRelays, setError: params.setError })
+    params.onConfigChange?.()
+  } catch (e) {
+    const errorMessage = e instanceof Error ? e.message : t('settings.relay.error.updateFailed')
+    params.setError(errorMessage)
+    console.error('[RelayManager] Error updating relay:', e)
+  }
+}
+
+export async function updateUrl(params: {
+  id: string
+  url: string
+  setRelays: (value: RelayConfig[]) => void
+  setError: (value: string | null) => void
+  setEditingId: (value: string | null) => void
+  onConfigChange: (() => void) | undefined
+}): Promise<void> {
+  try {
+    await configStorage.updateRelay(params.id, { url: params.url })
+    await reloadRelays({ setRelays: params.setRelays, setError: params.setError })
+    params.setEditingId(null)
+    params.onConfigChange?.()
+  } catch (e) {
+    const errorMessage = e instanceof Error ? e.message : t('settings.relay.error.urlFailed')
+    params.setError(errorMessage)
+    console.error('[RelayManager] Error updating URL:', e)
+  }
+}
+
+export async function addRelay(params: {
+  newUrl: string
+  setError: (value: string | null) => void
+  setNewUrl: (value: string) => void
+  setShowAddForm: (value: boolean | ((prev: boolean) => boolean)) => void
+  setRelays: (value: RelayConfig[]) => void
+  onConfigChange: (() => void) | undefined
+}): Promise<void> {
+  const normalizedUrl = normalizeRelayUrl(params.newUrl)
+  if (!normalizedUrl) {
+    params.setError(t('settings.relay.error.urlRequired'))
+    return
+  }
+  try {
+    void new URL(normalizedUrl)
+    await configStorage.addRelay(normalizedUrl, true)
+    params.setNewUrl('')
+    params.setShowAddForm(false)
+    await reloadRelays({ setRelays: params.setRelays, setError: params.setError })
+    params.onConfigChange?.()
+  } catch (e) {
+    params.setError(getAddRelayErrorMessage(e))
+    console.error('[RelayManager] Error adding relay:', e)
+  }
+}
+
+export async function removeRelay(params: {
+  id: string
+  setRelays: (value: RelayConfig[]) => void
+  setError: (value: string | null) => void
+  onConfigChange: (() => void) | undefined
+}): Promise<void> {
+  const confirmed = await userConfirm(t('settings.relay.remove.confirm'))
+  if (!confirmed) {
+    return
+  }
+  try {
+    await configStorage.removeRelay(params.id)
+    await reloadRelays({ setRelays: params.setRelays, setError: params.setError })
+    params.onConfigChange?.()
+  } catch (e) {
+    const errorMessage = e instanceof Error ? e.message : t('settings.relay.error.removeFailed')
+    params.setError(errorMessage)
+    console.error('[RelayManager] Error removing relay:', e)
+  }
+}
+
+export async function updatePriorities(params: {
+  relays: RelayConfig[]
+  setError: (value: string | null) => void
+  onConfigChange: (() => void) | undefined
+}): Promise<void> {
+  try {
+    const updates = params.relays.map((relay, index) => {
+      const priority = index + 1
+      return relay.priority !== priority ? configStorage.updateRelay(relay.id, { priority }) : Promise.resolve()
+    })
+    await Promise.all(updates)
+    params.onConfigChange?.()
+  } catch (e) {
+    const errorMessage = e instanceof Error ? e.message : t('settings.relay.error.priorityFailed')
+    params.setError(errorMessage)
+    console.error('[RelayManager] Error updating priorities:', e)
+  }
+}
+
+export function onDragStart(params: {
+  e: React.DragEvent<HTMLDivElement>
+  id: string
+  setDraggedId: (value: string | null) => void
+}): void {
+  params.setDraggedId(params.id)
+  const { dataTransfer } = params.e
+  dataTransfer.effectAllowed = 'move'
+  dataTransfer.setData('text/plain', params.id)
+}
+
+export function onDragOver(params: {
+  e: React.DragEvent<HTMLDivElement>
+  id: string
+  setDragOverId: (value: string | null) => void
+}): void {
+  params.e.preventDefault()
+  const { dataTransfer } = params.e
+  dataTransfer.dropEffect = 'move'
+  params.setDragOverId(params.id)
+}
+
+export async function onDrop(params: {
+  e: React.DragEvent<HTMLDivElement>
+  targetId: string
+  relays: RelayConfig[]
+  draggedId: string | null
+  setRelays: (value: RelayConfig[]) => void
+  setDraggedId: (value: string | null) => void
+  setDragOverId: (value: string | null) => void
+  setError: (value: string | null) => void
+  onConfigChange: (() => void) | undefined
+}): Promise<void> {
+  params.e.preventDefault()
+  params.setDragOverId(null)
+  if (!params.draggedId || params.draggedId === params.targetId) {
+    params.setDraggedId(null)
+    return
+  }
+  const reordered = reorderRelays({ relays: params.relays, draggedId: params.draggedId, targetId: params.targetId })
+  if (!reordered) {
+    params.setDraggedId(null)
+    return
+  }
+  params.setRelays(reordered)
+  params.setDraggedId(null)
+  await updatePriorities({ relays: reordered, setError: params.setError, onConfigChange: params.onConfigChange })
+}
+
+export function getRelayCardClassName(relayId: string, draggedId: string | null, dragOverId: string | null): string {
+  if (draggedId === relayId) {
+    return 'opacity-50 border-neon-cyan'
+  }
+  if (dragOverId === relayId) {
+    return 'border-neon-green shadow-lg'
+  }
+  return 'border-neon-cyan/30'
+}
+
+function sortByPriority(relays: RelayConfig[]): RelayConfig[] {
+  return relays.sort((a, b) => a.priority - b.priority)
+}
+
+async function reloadRelays(params: { setRelays: (value: RelayConfig[]) => void; setError: (value: string | null) => void }): Promise<void> {
+  try {
+    const config = await configStorage.getConfig()
+    params.setRelays(sortByPriority(config.relays))
+  } catch (e) {
+    const errorMessage = e instanceof Error ? e.message : t('settings.relay.error.loadFailed')
+    params.setError(errorMessage)
+    console.error('[RelayManager] Error reloading relays:', e)
+  }
+}
+
+async function maybeDisableFailedRelays(relays: RelayConfig[]): Promise<RelayConfig[]> {
+  const failedRelays = relaySessionManager.getFailedRelays()
+  if (failedRelays.length === 0) {
+    return relays
+  }
+  const toDisable = relays.filter((relay) => relay.enabled && failedRelays.includes(relay.url))
+  if (toDisable.length === 0) {
+    return relays
+  }
+  for (const relay of toDisable) {
+    await configStorage.updateRelay(relay.id, { enabled: false })
+  }
+  const updated = await configStorage.getConfig()
+  return updated.relays
+}
+
+function normalizeRelayUrl(rawUrl: string): string | null {
+  const trimmed = rawUrl.trim()
+  if (trimmed.length === 0) {
+    return null
+  }
+  if (trimmed.startsWith('ws://') || trimmed.startsWith('wss://')) {
+    return trimmed
+  }
+  return `wss://${trimmed}`
+}
+
+function getAddRelayErrorMessage(error: unknown): string {
+  if (error instanceof TypeError && error.message.includes('Invalid URL')) {
+    return t('settings.relay.error.invalidUrl')
+  }
+  if (error instanceof Error) {
+    return error.message
+  }
+  return t('settings.relay.error.addFailed')
+}
+
+function reorderRelays(params: { relays: RelayConfig[]; draggedId: string; targetId: string }): RelayConfig[] | null {
+  const draggedIndex = params.relays.findIndex((relay) => relay.id === params.draggedId)
+  const targetIndex = params.relays.findIndex((relay) => relay.id === params.targetId)
+  if (draggedIndex === -1 || targetIndex === -1) {
+    return null
+  }
+  const next = [...params.relays]
+  const removed = next[draggedIndex]
+  if (!removed) {
+    return null
+  }
+  next.splice(draggedIndex, 1)
+  next.splice(targetIndex, 0, removed)
+  return next
+}
diff --git a/components/relayManager/types.ts b/components/relayManager/types.ts
new file mode 100644
index 0000000..951120d
--- /dev/null
+++ b/components/relayManager/types.ts
@@ -0,0 +1,29 @@
+import type { RelayConfig } from '@/lib/configStorageTypes'
+
+export interface RelayManagerViewProps {
+  relays: RelayConfig[]
+  loading: boolean
+  error: string | null
+  editingId: string | null
+  newUrl: string
+  showAddForm: boolean
+  draggedId: string | null
+  dragOverId: string | null
+  onClearError: () => void
+  onToggleAddForm: () => void
+  onNewUrlChange: (value: string) => void
+  onCancelAdd: () => void
+  onAddRelay: () => void
+  onStartEditing: (id: string) => void
+  onStopEditing: () => void
+  onUpdateUrl: (id: string, url: string) => void
+  onToggleEnabled: (id: string, enabled: boolean) => void
+  onRemoveRelay: (id: string) => void
+  onDragStart: (e: React.DragEvent<HTMLDivElement>, id: string) => void
+  onDragOver: (e: React.DragEvent<HTMLDivElement>, id: string) => void
+  onDragLeave: () => void
+  onDrop: (e: React.DragEvent<HTMLDivElement>, targetId: string) => void
+  onDragEnd: () => void
+}
+
+export type RelayManagerContentProps = Omit<RelayManagerViewProps, 'loading'>
diff --git a/components/relayManager/view.tsx b/components/relayManager/view.tsx
new file mode 100644
index 0000000..8996ae5
--- /dev/null
+++ b/components/relayManager/view.tsx
@@ -0,0 +1,14 @@
+import { t } from '@/lib/i18n'
+import { RelayManagerContent } from './RelayManagerContent'
+import type { RelayManagerViewProps } from './types'
+
+export function RelayManagerView(params: RelayManagerViewProps): React.ReactElement {
+  if (params.loading) {
+    return (
+      <div className="text-center py-8 text-neon-cyan">
+        <div>{t('settings.relay.loading')}</div>
+      </div>
+    )
+  }
+  return <RelayManagerContent {...params} />
+}
diff --git a/components/relayManager/viewModel.ts b/components/relayManager/viewModel.ts
new file mode 100644
index 0000000..e2e69ea
--- /dev/null
+++ b/components/relayManager/viewModel.ts
@@ -0,0 +1,6 @@
+import type { RelayConfig } from '@/lib/configStorageTypes'
+import { loadRelays } from './controller'
+
+export function initialLoadRelays(params: { setRelays: (value: RelayConfig[]) => void; setLoading: (value: boolean) => void; setError: (value: string | null) => void }): void {
+  void loadRelays({ setRelays: params.setRelays, setLoading: params.setLoading, setError: params.setError })
+}
diff --git a/components/relayManager/viewProps.ts b/components/relayManager/viewProps.ts
new file mode 100644
index 0000000..b61957f
--- /dev/null
+++ b/components/relayManager/viewProps.ts
@@ -0,0 +1,130 @@
+import type { RelayConfig } from '@/lib/configStorageTypes'
+import type { RelayManagerProps } from './RelayManager'
+import { addRelay, onDragOver, onDragStart, onDrop, removeRelay, toggleEnabled, updateUrl } from './controller'
+import type { RelayManagerViewProps } from './types'
+
+export function buildRelayManagerViewProps(params: {
+  relays: RelayConfig[]
+  loading: boolean
+  error: string | null
+  editingId: string | null
+  newUrl: string
+  showAddForm: boolean
+  draggedId: string | null
+  dragOverId: string | null
+  setRelays: (value: RelayConfig[]) => void
+  setLoading: (value: boolean) => void
+  setError: (value: string | null) => void
+  setEditingId: (value: string | null) => void
+  setNewUrl: (value: string) => void
+  setShowAddForm: (value: boolean | ((prev: boolean) => boolean)) => void
+  setDraggedId: (value: string | null) => void
+  setDragOverId: (value: string | null) => void
+  onConfigChange: RelayManagerProps['onConfigChange']
+}): RelayManagerViewProps {
+  return { ...stateProps(params), ...formProps(params), ...relayActionProps(params), ...dragProps(params) }
+}
+
+function stateProps(params: {
+  relays: RelayConfig[]
+  loading: boolean
+  error: string | null
+  editingId: string | null
+  newUrl: string
+  showAddForm: boolean
+  draggedId: string | null
+  dragOverId: string | null
+}): Pick<RelayManagerViewProps, 'relays' | 'loading' | 'error' | 'editingId' | 'newUrl' | 'showAddForm' | 'draggedId' | 'dragOverId'> {
+  return {
+    relays: params.relays,
+    loading: params.loading,
+    error: params.error,
+    editingId: params.editingId,
+    newUrl: params.newUrl,
+    showAddForm: params.showAddForm,
+    draggedId: params.draggedId,
+    dragOverId: params.dragOverId,
+  }
+}
+
+function formProps(params: {
+  newUrl: string
+  setError: (value: string | null) => void
+  setNewUrl: (value: string) => void
+  setShowAddForm: (value: boolean | ((prev: boolean) => boolean)) => void
+  setRelays: (value: RelayConfig[]) => void
+  onConfigChange: RelayManagerProps['onConfigChange']
+}): Pick<RelayManagerViewProps, 'onClearError' | 'onToggleAddForm' | 'onNewUrlChange' | 'onCancelAdd' | 'onAddRelay'> {
+  return {
+    onClearError: () => params.setError(null),
+    onToggleAddForm: () => params.setShowAddForm((prev) => !prev),
+    onNewUrlChange: (value) => params.setNewUrl(value),
+    onCancelAdd: () => {
+      params.setShowAddForm(false)
+      params.setNewUrl('')
+      params.setError(null)
+    },
+    onAddRelay: () =>
+      void addRelay({
+        newUrl: params.newUrl,
+        setError: params.setError,
+        setNewUrl: params.setNewUrl,
+        setShowAddForm: params.setShowAddForm,
+        setRelays: params.setRelays,
+        onConfigChange: params.onConfigChange,
+      }),
+  }
+}
+
+function relayActionProps(params: {
+  setRelays: (value: RelayConfig[]) => void
+  setError: (value: string | null) => void
+  setEditingId: (value: string | null) => void
+  onConfigChange: RelayManagerProps['onConfigChange']
+}): Pick<RelayManagerViewProps, 'onStartEditing' | 'onStopEditing' | 'onUpdateUrl' | 'onToggleEnabled' | 'onRemoveRelay'> {
+  return {
+    onStartEditing: (id) => params.setEditingId(id),
+    onStopEditing: () => params.setEditingId(null),
+    onUpdateUrl: (id, url) =>
+      void updateUrl({
+        id,
+        url,
+        setRelays: params.setRelays,
+        setError: params.setError,
+        setEditingId: params.setEditingId,
+        onConfigChange: params.onConfigChange,
+      }),
+    onToggleEnabled: (id, enabled) =>
+      void toggleEnabled({ id, enabled, setRelays: params.setRelays, setError: params.setError, onConfigChange: params.onConfigChange }),
+    onRemoveRelay: (id) => void removeRelay({ id, setRelays: params.setRelays, setError: params.setError, onConfigChange: params.onConfigChange }),
+  }
+}
+
+function dragProps(params: {
+  relays: RelayConfig[]
+  draggedId: string | null
+  setRelays: (value: RelayConfig[]) => void
+  setDraggedId: (value: string | null) => void
+  setDragOverId: (value: string | null) => void
+  setError: (value: string | null) => void
+  onConfigChange: RelayManagerProps['onConfigChange']
+}): Pick<RelayManagerViewProps, 'onDragStart' | 'onDragOver' | 'onDragLeave' | 'onDrop' | 'onDragEnd'> {
+  return {
+    onDragStart: (e, id) => onDragStart({ e, id, setDraggedId: params.setDraggedId }),
+    onDragOver: (e, id) => onDragOver({ e, id, setDragOverId: params.setDragOverId }),
+    onDragLeave: () => params.setDragOverId(null),
+    onDrop: (e, targetId) =>
+      void onDrop({
+        e,
+        targetId,
+        relays: params.relays,
+        draggedId: params.draggedId,
+        setRelays: params.setRelays,
+        setDraggedId: params.setDraggedId,
+        setDragOverId: params.setDragOverId,
+        setError: params.setError,
+        onConfigChange: params.onConfigChange,
+      }),
+    onDragEnd: () => params.setDraggedId(null),
+  }
+}
diff --git a/components/syncProgressBar/SyncProgressBar.tsx b/components/syncProgressBar/SyncProgressBar.tsx
new file mode 100644
index 0000000..38856d3
--- /dev/null
+++ b/components/syncProgressBar/SyncProgressBar.tsx
@@ -0,0 +1,22 @@
+import { t } from '@/lib/i18n'
+import { useSyncProgressBarController } from './controller'
+import { SyncDateRange, SyncErrorBanner, SyncProgressSection, SyncResyncButton, SyncStatusMessage } from './view'
+
+export function SyncProgressBar(): React.ReactElement | null {
+  const controller = useSyncProgressBarController()
+  if (!controller) {
+    return null
+  }
+  return (
+    <div className="bg-cyber-darker border border-neon-cyan/30 rounded-lg p-4 mt-6">
+      <SyncErrorBanner error={controller.error} onDismiss={controller.dismissError} />
+      <div className="flex items-center justify-between mb-2">
+        <h3 className="text-lg font-semibold text-neon-cyan">{t('settings.sync.title')}</h3>
+        <SyncResyncButton isSyncing={controller.isSyncing} onClick={controller.onResyncClick} />
+      </div>
+      <SyncDateRange totalDays={controller.totalDays} startDate={controller.startDateLabel} endDate={controller.endDateLabel} />
+      <SyncProgressSection isSyncing={controller.isSyncing} syncProgress={controller.syncProgress} progressPercentage={controller.progressPercentage} />
+      <SyncStatusMessage isSyncing={controller.isSyncing} totalDays={controller.totalDays} isRecentlySynced={controller.isRecentlySynced} />
+    </div>
+  )
+}
diff --git a/components/syncProgressBar/controller.ts b/components/syncProgressBar/controller.ts
new file mode 100644
index 0000000..4a8fe93
--- /dev/null
+++ b/components/syncProgressBar/controller.ts
@@ -0,0 +1,216 @@
+import { useCallback, useEffect, useState } from 'react'
+import { nostrAuthService } from '@/lib/nostrAuth'
+import { MIN_EVENT_DATE } from '@/lib/platformConfig'
+import { objectCache } from '@/lib/objectCache'
+import { calculateDaysBetween, getCurrentTimestamp, getLastSyncDate, setLastSyncDate as setLastSyncDateStorage } from '@/lib/syncStorage'
+import { useSyncProgress } from '@/lib/hooks/useSyncProgress'
+import type { SyncProgress, SyncProgressBarController } from './types'
+
+type ConnectionState = { isInitialized: boolean; connected: boolean; pubkey: string | null }
+
+export function useSyncProgressBarController(): SyncProgressBarController | null {
+  const connection = useNostrConnectionState()
+  const [error, setError] = useState<string | null>(null)
+  const syncStatus = useSyncStatus()
+  const { syncProgress, isSyncing, startMonitoring, stopMonitoring } = useSyncProgress({ onComplete: syncStatus.loadSyncStatus })
+  useAutoSyncEffect({ connection, isSyncing, loadSyncStatus: syncStatus.loadSyncStatus, startMonitoring, stopMonitoring, setError })
+
+  if (!connection.isInitialized || !connection.connected || !connection.pubkey) {
+    return null
+  }
+
+  const progressPercentage = computeProgressPercentage(syncProgress)
+  const isRecentlySynced = isRecentlySyncedFromLastSyncDate(syncStatus.lastSyncDate)
+  const startDate = getSyncStartDate(syncStatus.lastSyncDate)
+  const endDate = getCurrentTimestamp()
+
+  return {
+    error,
+    dismissError: () => setError(null),
+    isSyncing,
+    syncProgress,
+    progressPercentage,
+    totalDays: syncStatus.totalDays,
+    startDateLabel: formatSyncDate(startDate),
+    endDateLabel: formatSyncDate(endDate),
+    isRecentlySynced,
+    onResyncClick: () => {
+      void resynchronizeUserContent({ startMonitoring, stopMonitoring, loadSyncStatus: syncStatus.loadSyncStatus, setError })
+    },
+  }
+}
+
+function useNostrConnectionState(): ConnectionState {
+  const initial = nostrAuthService.getState()
+  const [state, setState] = useState<{ connected: boolean; pubkey: string | null }>(() => ({
+    connected: initial.connected ?? false,
+    pubkey: initial.pubkey ?? null,
+  }))
+  const [isInitialized] = useState(true)
+  useEffect(() => {
+    const unsubscribe = nostrAuthService.subscribe((next) => setState({ connected: next.connected ?? false, pubkey: next.pubkey ?? null }))
+    return () => unsubscribe()
+  }, [])
+  return { isInitialized, connected: state.connected, pubkey: state.pubkey }
+}
+
+function useSyncStatus(): { lastSyncDate: number | null; totalDays: number; loadSyncStatus: () => Promise<void> } {
+  const [lastSyncDate, setLastSyncDate] = useState<number | null>(null)
+  const [totalDays, setTotalDays] = useState<number>(0)
+  const loadSyncStatus = useCallback(async (): Promise<void> => {
+    try {
+      const state = nostrAuthService.getState()
+      if (!state.connected || !state.pubkey) {
+        return
+      }
+      const storedLastSyncDate = await getLastSyncDate()
+      const days = calculateDaysBetween(storedLastSyncDate, getCurrentTimestamp())
+      setLastSyncDate(storedLastSyncDate)
+      setTotalDays(days)
+    } catch (loadError) {
+      console.error('[SyncProgressBar] Error loading sync status:', loadError)
+    }
+  }, [])
+  return { lastSyncDate, totalDays, loadSyncStatus }
+}
+
+function useAutoSyncEffect(params: {
+  connection: ConnectionState
+  isSyncing: boolean
+  loadSyncStatus: () => Promise<void>
+  startMonitoring: () => void
+  stopMonitoring: () => void
+  setError: (value: string | null) => void
+}): void {
+  useEffect(() => {
+    if (!params.connection.isInitialized || !params.connection.connected || !params.connection.pubkey) {
+      return
+    }
+    void runAutoSyncCheck({
+      connection: { connected: true, pubkey: params.connection.pubkey },
+      isSyncing: params.isSyncing,
+      loadSyncStatus: params.loadSyncStatus,
+      startMonitoring: params.startMonitoring,
+      stopMonitoring: params.stopMonitoring,
+      setError: params.setError,
+    })
+  }, [params.connection.connected, params.connection.isInitialized, params.connection.pubkey, params.isSyncing, params.loadSyncStatus, params.setError, params.startMonitoring, params.stopMonitoring])
+}
+
+function formatSyncDate(timestamp: number): string {
+  const date = new Date(timestamp * 1000)
+  const locale = typeof window !== 'undefined' ? navigator.language : 'fr-FR'
+  return date.toLocaleDateString(locale, { day: '2-digit', month: '2-digit', year: 'numeric' })
+}
+
+function getSyncStartDate(lastSyncDate: number | null): number {
+  return lastSyncDate ?? MIN_EVENT_DATE
+}
+
+function isRecentlySyncedFromLastSyncDate(lastSyncDate: number | null): boolean {
+  return lastSyncDate !== null && lastSyncDate >= getCurrentTimestamp() - 3600
+}
+
+async function resynchronizeUserContent(params: {
+  startMonitoring: () => void
+  stopMonitoring: () => void
+  loadSyncStatus: () => Promise<void>
+  setError: (value: string | null) => void
+}): Promise<void> {
+  try {
+    const state = nostrAuthService.getState()
+    if (!state.connected || !state.pubkey) {
+      return
+    }
+    await clearUserContentCache()
+    await setLastSyncDateStorage(MIN_EVENT_DATE)
+    await params.loadSyncStatus()
+    await startUserSyncOrStop({ pubkey: state.pubkey, startMonitoring: params.startMonitoring, stopMonitoring: params.stopMonitoring })
+  } catch (resyncError) {
+    console.error('[SyncProgressBar] Error resynchronizing:', resyncError)
+    params.stopMonitoring()
+    params.setError(resyncError instanceof Error ? resyncError.message : 'Erreur de synchronisation')
+  }
+}
+
+async function clearUserContentCache(): Promise<void> {
+  await Promise.all([
+    objectCache.clear('author'),
+    objectCache.clear('series'),
+    objectCache.clear('publication'),
+    objectCache.clear('review'),
+    objectCache.clear('purchase'),
+    objectCache.clear('sponsoring'),
+    objectCache.clear('review_tip'),
+  ])
+}
+
+async function startUserSyncOrStop(params: { pubkey: string; startMonitoring: () => void; stopMonitoring: () => void }): Promise<void> {
+  const { swClient } = await import('@/lib/swClient')
+  const isReady = await swClient.isReady()
+  if (!isReady) {
+    params.stopMonitoring()
+    return
+  }
+  await swClient.startUserSync(params.pubkey)
+  params.startMonitoring()
+}
+
+function computeProgressPercentage(syncProgress: SyncProgress): number {
+  if (!syncProgress || syncProgress.totalSteps <= 0) {
+    return 0
+  }
+  return Math.min(100, (syncProgress.currentStep / syncProgress.totalSteps) * 100)
+}
+
+async function runAutoSyncCheck(params: {
+  connection: { connected: boolean; pubkey: string | null }
+  isSyncing: boolean
+  loadSyncStatus: () => Promise<void>
+  startMonitoring: () => void
+  stopMonitoring: () => void
+  setError: (value: string | null) => void
+}): Promise<void> {
+  console.warn('[SyncProgressBar] Starting sync check...')
+  await params.loadSyncStatus()
+  const shouldStart = await shouldAutoStartSync({ isSyncing: params.isSyncing, pubkey: params.connection.pubkey })
+  if (!shouldStart || !params.connection.pubkey) {
+    console.warn('[SyncProgressBar] Skipping auto-sync:', { shouldStart, isSyncing: params.isSyncing, hasPubkey: Boolean(params.connection.pubkey) })
+    return
+  }
+  console.warn('[SyncProgressBar] Starting auto-sync...')
+  await startAutoSync({
+    pubkey: params.connection.pubkey,
+    startMonitoring: params.startMonitoring,
+    stopMonitoring: params.stopMonitoring,
+    setError: params.setError,
+  })
+}
+
+async function shouldAutoStartSync(params: { isSyncing: boolean; pubkey: string | null }): Promise<boolean> {
+  if (params.isSyncing || !params.pubkey) {
+    return false
+  }
+  const storedLastSyncDate = await getLastSyncDate()
+  const currentTimestamp = getCurrentTimestamp()
+  const isRecentlySynced = storedLastSyncDate >= currentTimestamp - 3600
+  console.warn('[SyncProgressBar] Sync status:', { storedLastSyncDate, currentTimestamp, isRecentlySynced })
+  return !isRecentlySynced
+}
+
+async function startAutoSync(params: { pubkey: string; startMonitoring: () => void; stopMonitoring: () => void; setError: (value: string | null) => void }): Promise<void> {
+  try {
+    const { swClient } = await import('@/lib/swClient')
+    const isReady = await swClient.isReady()
+    if (!isReady) {
+      params.stopMonitoring()
+      return
+    }
+    await swClient.startUserSync(params.pubkey)
+    params.startMonitoring()
+  } catch (autoSyncError) {
+    console.error('[SyncProgressBar] Error during auto-sync:', autoSyncError)
+    params.stopMonitoring()
+    params.setError(autoSyncError instanceof Error ? autoSyncError.message : 'Erreur de synchronisation')
+  }
+}
diff --git a/components/syncProgressBar/types.ts b/components/syncProgressBar/types.ts
new file mode 100644
index 0000000..a2637ad
--- /dev/null
+++ b/components/syncProgressBar/types.ts
@@ -0,0 +1,16 @@
+import type { useSyncProgress } from '@/lib/hooks/useSyncProgress'
+
+export type SyncProgress = ReturnType<typeof useSyncProgress>['syncProgress']
+
+export type SyncProgressBarController = {
+  error: string | null
+  dismissError: () => void
+  isSyncing: boolean
+  syncProgress: SyncProgress
+  progressPercentage: number
+  totalDays: number
+  startDateLabel: string
+  endDateLabel: string
+  isRecentlySynced: boolean
+  onResyncClick: () => void
+}
diff --git a/components/syncProgressBar/view.tsx b/components/syncProgressBar/view.tsx
new file mode 100644
index 0000000..e530657
--- /dev/null
+++ b/components/syncProgressBar/view.tsx
@@ -0,0 +1,73 @@
+import { t } from '@/lib/i18n'
+import type { SyncProgress } from './types'
+
+export function SyncErrorBanner(params: { error: string | null; onDismiss: () => void }): React.ReactElement | null {
+  if (!params.error) {
+    return null
+  }
+  return (
+    <div className="mb-4 bg-red-900/30 border border-red-500/50 rounded p-3 text-red-300 text-sm">
+      {params.error}
+      <button type="button" onClick={params.onDismiss} className="ml-2 text-red-400 hover:text-red-200">
+        ×
+      </button>
+    </div>
+  )
+}
+
+export function SyncResyncButton(params: { isSyncing: boolean; onClick: () => void }): React.ReactElement | null {
+  if (params.isSyncing) {
+    return null
+  }
+  return (
+    <button
+      type="button"
+      onClick={params.onClick}
+      className="px-3 py-1 text-xs bg-neon-cyan/20 hover:bg-neon-cyan/30 text-neon-cyan rounded border border-neon-cyan/50 hover:border-neon-cyan transition-colors"
+    >
+      {t('settings.sync.resync')}
+    </button>
+  )
+}
+
+export function SyncDateRange(params: { totalDays: number; startDate: string; endDate: string }): React.ReactElement | null {
+  if (params.totalDays <= 0) {
+    return null
+  }
+  return (
+    <div className="mb-2">
+      <p className="text-sm text-cyber-accent">
+        {t('settings.sync.daysRange', { startDate: params.startDate, endDate: params.endDate, days: params.totalDays })}
+      </p>
+    </div>
+  )
+}
+
+export function SyncProgressSection(params: { isSyncing: boolean; syncProgress: SyncProgress; progressPercentage: number }): React.ReactElement | null {
+  if (!params.isSyncing || !params.syncProgress) {
+    return null
+  }
+  return (
+    <div className="space-y-2">
+      <div className="flex items-center justify-between text-sm">
+        <span className="text-cyber-accent">
+          {t('settings.sync.progress', { current: params.syncProgress.currentStep, total: params.syncProgress.totalSteps })}
+        </span>
+        <span className="text-neon-cyan font-semibold">{Math.round(params.progressPercentage)}%</span>
+      </div>
+      <div className="w-full bg-cyber-dark rounded-full h-2 overflow-hidden">
+        <div className="bg-neon-cyan h-full transition-all duration-300" style={{ width: `${params.progressPercentage}%` }} />
+      </div>
+    </div>
+  )
+}
+
+export function SyncStatusMessage(params: { isSyncing: boolean; totalDays: number; isRecentlySynced: boolean }): React.ReactElement | null {
+  if (params.isSyncing || params.totalDays !== 0) {
+    return null
+  }
+  if (params.isRecentlySynced) {
+    return <p className="text-sm text-green-400">{t('settings.sync.completed')}</p>
+  }
+  return <p className="text-sm text-cyber-accent">{t('settings.sync.ready')}</p>
+}
diff --git a/components/unlockAccount/UnlockAccountButtons.tsx b/components/unlockAccount/UnlockAccountButtons.tsx
new file mode 100644
index 0000000..341d6c8
--- /dev/null
+++ b/components/unlockAccount/UnlockAccountButtons.tsx
@@ -0,0 +1,26 @@
+export function UnlockAccountButtons(params: {
+  loading: boolean
+  words: string[]
+  onUnlock: () => void
+  onClose: () => void
+}): React.ReactElement {
+  return (
+    <div className="flex gap-4">
+      <button
+        type="button"
+        onClick={params.onClose}
+        className="flex-1 py-2 px-4 bg-gray-200 hover:bg-gray-300 rounded-lg font-medium transition-colors"
+      >
+        Annuler
+      </button>
+      <button
+        type="button"
+        onClick={params.onUnlock}
+        disabled={params.loading || params.words.some((word) => !word)}
+        className="flex-1 py-2 px-4 bg-neon-cyan/20 hover:bg-neon-cyan/30 text-neon-cyan rounded-lg font-medium transition-all border border-neon-cyan/50 hover:shadow-glow-cyan disabled:opacity-50"
+      >
+        {params.loading ? 'Déverrouillage...' : 'Déverrouiller'}
+      </button>
+    </div>
+  )
+}
diff --git a/components/unlockAccount/UnlockAccountForm.tsx b/components/unlockAccount/UnlockAccountForm.tsx
new file mode 100644
index 0000000..ba47c00
--- /dev/null
+++ b/components/unlockAccount/UnlockAccountForm.tsx
@@ -0,0 +1,45 @@
+import { WordInputWithAutocomplete } from './WordInputWithAutocomplete'
+
+export function UnlockAccountForm(params: {
+  words: string[]
+  onWordChange: (index: number, value: string) => void
+  onPaste: () => void
+}): React.ReactElement {
+  return (
+    <div className="mb-4">
+      <WordInputsGrid words={params.words} onWordChange={params.onWordChange} />
+      <button
+        type="button"
+        onClick={params.onPaste}
+        className="mt-2 text-sm text-gray-600 hover:text-gray-800 underline"
+      >
+        Coller depuis le presse-papiers
+      </button>
+    </div>
+  )
+}
+
+function WordInputsGrid(params: { words: string[]; onWordChange: (index: number, value: string) => void }): React.ReactElement {
+  return (
+    <div className="grid grid-cols-2 gap-4">
+      <WordInputSlot index={0} value={params.words[0] ?? ''} onWordChange={params.onWordChange} />
+      <WordInputSlot index={1} value={params.words[1] ?? ''} onWordChange={params.onWordChange} />
+      <WordInputSlot index={2} value={params.words[2] ?? ''} onWordChange={params.onWordChange} />
+      <WordInputSlot index={3} value={params.words[3] ?? ''} onWordChange={params.onWordChange} />
+    </div>
+  )
+}
+
+function WordInputSlot(params: { index: number; value: string; onWordChange: (index: number, value: string) => void }): React.ReactElement {
+  const onFocus = (): void => {}
+  const onBlur = (): void => {}
+  return (
+    <WordInputWithAutocomplete
+      index={params.index}
+      value={params.value}
+      onChange={(value) => params.onWordChange(params.index, value)}
+      onFocus={onFocus}
+      onBlur={onBlur}
+    />
+  )
+}
diff --git a/components/unlockAccount/UnlockAccountModal.tsx b/components/unlockAccount/UnlockAccountModal.tsx
new file mode 100644
index 0000000..1036631
--- /dev/null
+++ b/components/unlockAccount/UnlockAccountModal.tsx
@@ -0,0 +1,35 @@
+import { useState } from 'react'
+import type { UnlockAccountModalProps } from './types'
+import { UnlockAccountButtons } from './UnlockAccountButtons'
+import { UnlockAccountForm } from './UnlockAccountForm'
+import { useUnlockAccountController } from './useUnlockAccountController'
+
+export function UnlockAccountModal(params: UnlockAccountModalProps): React.ReactElement {
+  const [words, setWords] = useState<string[]>(['', '', '', ''])
+  const [loading, setLoading] = useState(false)
+  const [error, setError] = useState<string | null>(null)
+
+  const controller = useUnlockAccountController({
+    words,
+    setWords,
+    setLoading,
+    setError,
+    onSuccess: params.onSuccess,
+    onClose: params.onClose,
+  })
+
+  return (
+    <div className="fixed inset-0 bg-black bg-opacity-50 flex items-center justify-center z-50">
+      <div className="bg-white rounded-lg p-6 max-w-md w-full mx-4">
+        <h2 className="text-2xl font-bold mb-4">Déverrouiller votre compte</h2>
+        <p className="text-gray-600 mb-6">
+          Entrez vos 4 mots-clés de récupération (dictionnaire BIP39) pour déverrouiller votre compte. Ces mots déchiffrent la clé de chiffrement
+          (KEK) stockée dans l&apos;API Credentials, qui déchiffre ensuite votre clé privée.
+        </p>
+        <UnlockAccountForm words={words} onWordChange={controller.handleWordChange} onPaste={controller.handlePaste} />
+        {error ? <p className="text-sm text-red-600 mb-4">{error}</p> : null}
+        <UnlockAccountButtons loading={loading} words={words} onUnlock={controller.handleUnlock} onClose={params.onClose} />
+      </div>
+    </div>
+  )
+}
diff --git a/components/unlockAccount/WordInputWithAutocomplete.tsx b/components/unlockAccount/WordInputWithAutocomplete.tsx
new file mode 100644
index 0000000..8555672
--- /dev/null
+++ b/components/unlockAccount/WordInputWithAutocomplete.tsx
@@ -0,0 +1,52 @@
+import { useRef } from 'react'
+import { useWordAutocomplete } from './useWordAutocomplete'
+import { WordSuggestions } from './WordSuggestions'
+
+export interface WordInputWithAutocompleteProps {
+  index: number
+  value: string
+  onChange: (value: string) => void
+  onFocus: () => void
+  onBlur: () => void
+}
+
+export function WordInputWithAutocomplete(params: WordInputWithAutocompleteProps): React.ReactElement {
+  const inputRef = useRef<HTMLInputElement>(null)
+  const autocomplete = useWordAutocomplete({ value: params.value, onChange: params.onChange, inputRef })
+
+  return (
+    <div className="relative">
+      <label htmlFor={`word-${params.index}`} className="block text-sm font-medium text-gray-700 mb-2">
+        Mot {params.index + 1}
+      </label>
+      <input
+        ref={inputRef}
+        id={`word-${params.index}`}
+        type="text"
+        value={params.value}
+        onChange={autocomplete.handleChange}
+        onKeyDown={autocomplete.handleKeyDown}
+        onFocus={params.onFocus}
+        onBlur={() => hideSuggestionsOnBlur({ onBlur: params.onBlur, setShowSuggestions: autocomplete.setShowSuggestions })}
+        className="w-full px-3 py-2 border border-gray-300 rounded-lg font-mono text-lg text-center"
+        autoComplete="off"
+        autoCapitalize="off"
+        autoCorrect="off"
+        spellCheck="false"
+      />
+      <WordSuggestions
+        showSuggestions={autocomplete.showSuggestions}
+        suggestions={autocomplete.suggestions}
+        selectedIndex={autocomplete.selectedIndex}
+        onSuggestionClick={autocomplete.applySuggestion}
+      />
+    </div>
+  )
+}
+
+function hideSuggestionsOnBlur(params: { onBlur: () => void; setShowSuggestions: (value: boolean) => void }): void {
+  setTimeout(() => {
+    params.setShowSuggestions(false)
+    params.onBlur()
+  }, 200)
+}
diff --git a/components/unlockAccount/WordSuggestions.tsx b/components/unlockAccount/WordSuggestions.tsx
new file mode 100644
index 0000000..8e77116
--- /dev/null
+++ b/components/unlockAccount/WordSuggestions.tsx
@@ -0,0 +1,24 @@
+export function WordSuggestions(params: {
+  showSuggestions: boolean
+  suggestions: string[]
+  selectedIndex: number
+  onSuggestionClick: (suggestion: string) => void
+}): React.ReactElement | null {
+  if (!params.showSuggestions || params.suggestions.length === 0) {
+    return null
+  }
+  return (
+    <div className="absolute z-10 w-full mt-1 bg-white border border-gray-300 rounded-lg shadow-lg max-h-40 overflow-y-auto">
+      {params.suggestions.map((suggestion, idx) => (
+        <button
+          key={suggestion}
+          type="button"
+          onClick={() => params.onSuggestionClick(suggestion)}
+          className={`w-full text-left px-3 py-2 hover:bg-gray-100 ${idx === params.selectedIndex ? 'bg-gray-100' : ''}`}
+        >
+          {suggestion}
+        </button>
+      ))}
+    </div>
+  )
+}
diff --git a/components/unlockAccount/autocompleteKeyDecision.ts b/components/unlockAccount/autocompleteKeyDecision.ts
new file mode 100644
index 0000000..cf48e09
--- /dev/null
+++ b/components/unlockAccount/autocompleteKeyDecision.ts
@@ -0,0 +1,27 @@
+export type AutocompleteKeyDecision =
+  | { action: 'none' }
+  | { action: 'escape' }
+  | { action: 'move'; nextIndex: number }
+  | { action: 'select'; index: number }
+
+export function decideAutocompleteKeyAction(params: {
+  key: string
+  selectedIndex: number
+  suggestionsCount: number
+}): AutocompleteKeyDecision {
+  if (params.key === 'Escape') {
+    return { action: 'escape' }
+  }
+  if (params.key === 'ArrowDown') {
+    const nextIndex = params.selectedIndex < params.suggestionsCount - 1 ? params.selectedIndex + 1 : params.selectedIndex
+    return { action: 'move', nextIndex }
+  }
+  if (params.key === 'ArrowUp') {
+    const nextIndex = params.selectedIndex > 0 ? params.selectedIndex - 1 : -1
+    return { action: 'move', nextIndex }
+  }
+  if (params.key === 'Enter' && params.selectedIndex >= 0) {
+    return { action: 'select', index: params.selectedIndex }
+  }
+  return { action: 'none' }
+}
diff --git a/components/unlockAccount/types.ts b/components/unlockAccount/types.ts
new file mode 100644
index 0000000..d961891
--- /dev/null
+++ b/components/unlockAccount/types.ts
@@ -0,0 +1,4 @@
+export interface UnlockAccountModalProps {
+  onSuccess: () => void
+  onClose: () => void
+}
diff --git a/components/unlockAccount/useUnlockAccountController.ts b/components/unlockAccount/useUnlockAccountController.ts
new file mode 100644
index 0000000..1fc73b3
--- /dev/null
+++ b/components/unlockAccount/useUnlockAccountController.ts
@@ -0,0 +1,92 @@
+import { nostrAuthService } from '@/lib/nostrAuth'
+
+export interface UseUnlockAccountControllerResult {
+  handleWordChange: (index: number, value: string) => void
+  handlePaste: () => void
+  handleUnlock: () => void
+}
+
+export function useUnlockAccountController(params: {
+  words: string[]
+  setWords: (words: string[]) => void
+  setLoading: (loading: boolean) => void
+  setError: (error: string | null) => void
+  onSuccess: () => void
+  onClose: () => void
+}): UseUnlockAccountControllerResult {
+  const handleWordChange = (index: number, value: string): void => {
+    const nextWords = buildNextWords({ current: params.words, index, value })
+    params.setWords(nextWords)
+    params.setError(null)
+  }
+
+  const handlePaste = (): void => {
+    void pasteWordsFromClipboard({ setWords: params.setWords, setError: params.setError })
+  }
+
+  const handleUnlock = (): void => {
+    void unlockAccount({
+      words: params.words,
+      setLoading: params.setLoading,
+      setError: params.setError,
+      onSuccess: params.onSuccess,
+      onClose: params.onClose,
+    })
+  }
+
+  return { handleWordChange, handlePaste, handleUnlock }
+}
+
+function buildNextWords(params: { current: string[]; index: number; value: string }): string[] {
+  const next = [...params.current]
+  next[params.index] = normalizeWord(params.value)
+  return next
+}
+
+function normalizeWord(value: string): string {
+  return value.trim().toLowerCase()
+}
+
+async function pasteWordsFromClipboard(params: {
+  setWords: (words: string[]) => void
+  setError: (error: string | null) => void
+}): Promise<void> {
+  try {
+    const text = await navigator.clipboard.readText()
+    const words = text.trim().split(/\s+/).slice(0, 4).map(normalizeWord)
+    if (words.length !== 4) {
+      params.setError('Le presse-papiers ne contient pas 4 mots.')
+      return
+    }
+    params.setWords(words)
+    params.setError(null)
+  } catch (e) {
+    console.error('[UnlockAccountModal] Error reading clipboard:', e)
+    params.setError('Impossible de lire le presse-papiers.')
+  }
+}
+
+async function unlockAccount(params: {
+  words: string[]
+  setLoading: (loading: boolean) => void
+  setError: (error: string | null) => void
+  onSuccess: () => void
+  onClose: () => void
+}): Promise<void> {
+  if (params.words.some((word) => !word)) {
+    params.setError('Veuillez remplir tous les mots-clés')
+    return
+  }
+  params.setLoading(true)
+  params.setError(null)
+  try {
+    await nostrAuthService.unlockAccount(params.words)
+    params.onSuccess()
+    params.onClose()
+  } catch (e) {
+    console.error('[UnlockAccountModal] Error unlocking account:', e)
+    params.setError(e instanceof Error ? e.message : 'Échec du déverrouillage. Vérifiez vos mots-clés.')
+  } finally {
+    params.setLoading(false)
+  }
+}
diff --git a/components/unlockAccount/useWordAutocomplete.ts b/components/unlockAccount/useWordAutocomplete.ts
new file mode 100644
index 0000000..dca2805
--- /dev/null
+++ b/components/unlockAccount/useWordAutocomplete.ts
@@ -0,0 +1,108 @@
+import { useMemo, useState } from 'react'
+import { getWordSuggestions } from '@/lib/keyManagementBIP39'
+import { decideAutocompleteKeyAction } from './autocompleteKeyDecision'
+
+export interface WordAutocompleteState {
+  suggestions: string[]
+  showSuggestions: boolean
+  setShowSuggestions: (value: boolean) => void
+  selectedIndex: number
+  handleChange: (event: React.ChangeEvent<HTMLInputElement>) => void
+  handleKeyDown: (event: React.KeyboardEvent<HTMLInputElement>) => void
+  applySuggestion: (suggestion: string) => void
+}
+
+export function useWordAutocomplete(params: {
+  value: string
+  onChange: (value: string) => void
+  inputRef: React.RefObject<HTMLInputElement | null>
+}): WordAutocompleteState {
+  const [showSuggestions, setShowSuggestions] = useState(false)
+  const [selectedIndex, setSelectedIndex] = useState(-1)
+  const suggestions = useWordSuggestions(params.value)
+
+  const applySuggestion = (suggestion: string): void => {
+    applySuggestionImpl({ suggestion, onChange: params.onChange, setShowSuggestions, inputRef: params.inputRef })
+  }
+  const handleChange = (event: React.ChangeEvent<HTMLInputElement>): void => {
+    handleChangeImpl({ event, onChange: params.onChange, setShowSuggestions, setSelectedIndex })
+  }
+  const handleKeyDown = (event: React.KeyboardEvent<HTMLInputElement>): void => {
+    handleKeyDownImpl({
+      event,
+      suggestions,
+      selectedIndex,
+      setSelectedIndex,
+      setShowSuggestions,
+      inputRef: params.inputRef,
+      applySuggestion,
+    })
+  }
+
+  return { suggestions, showSuggestions, setShowSuggestions, selectedIndex, handleChange, handleKeyDown, applySuggestion }
+}
+
+function useWordSuggestions(value: string): string[] {
+  return useMemo((): string[] => {
+    if (value.length === 0) {
+      return []
+    }
+    return getWordSuggestions(value, 5)
+  }, [value])
+}
+
+function applySuggestionImpl(params: {
+  suggestion: string
+  onChange: (value: string) => void
+  setShowSuggestions: (value: boolean) => void
+  inputRef: React.RefObject<HTMLInputElement | null>
+}): void {
+  params.onChange(params.suggestion)
+  params.setShowSuggestions(false)
+  params.inputRef.current?.blur()
+}
+
+function handleChangeImpl(params: {
+  event: React.ChangeEvent<HTMLInputElement>
+  onChange: (value: string) => void
+  setShowSuggestions: (value: boolean) => void
+  setSelectedIndex: (value: number) => void
+}): void {
+  const newValue = params.event.target.value.trim().toLowerCase()
+  params.setSelectedIndex(-1)
+  params.setShowSuggestions(newValue.length > 0)
+  params.onChange(newValue)
+}
+
+function handleKeyDownImpl(params: {
+  event: React.KeyboardEvent<HTMLInputElement>
+  suggestions: string[]
+  selectedIndex: number
+  setSelectedIndex: (value: number) => void
+  setShowSuggestions: (value: boolean) => void
+  inputRef: React.RefObject<HTMLInputElement | null>
+  applySuggestion: (suggestion: string) => void
+}): void {
+  const decision = decideAutocompleteKeyAction({
+    key: params.event.key,
+    selectedIndex: params.selectedIndex,
+    suggestionsCount: params.suggestions.length,
+  })
+  if (decision.action === 'none') {
+    return
+  }
+  params.event.preventDefault()
+  if (decision.action === 'move') {
+    params.setSelectedIndex(decision.nextIndex)
+    return
+  }
+  if (decision.action === 'escape') {
+    params.setShowSuggestions(false)
+    params.inputRef.current?.blur()
+    return
+  }
+  const suggestion = params.suggestions[decision.index]
+  if (suggestion) {
+    params.applySuggestion(suggestion)
+  }
+}
diff --git a/components/userArticles/UserArticles.tsx b/components/userArticles/UserArticles.tsx
new file mode 100644
index 0000000..00914f5
--- /dev/null
+++ b/components/userArticles/UserArticles.tsx
@@ -0,0 +1,17 @@
+import { useUserArticlesController } from './controller'
+import { UserArticlesLayout } from './layout'
+import type { UserArticlesProps } from './types'
+
+export function UserArticles(props: UserArticlesProps): React.ReactElement {
+  const controller = useUserArticlesController({ articles: props.articles, onLoadContent: props.onLoadContent, currentPubkey: props.currentPubkey })
+  return (
+    <UserArticlesLayout
+      controller={controller}
+      loading={props.loading}
+      error={props.error}
+      showEmptyMessage={props.showEmptyMessage ?? true}
+      currentPubkey={props.currentPubkey}
+      onSelectSeries={props.onSelectSeries}
+    />
+  )
+}
diff --git a/components/userArticles/controller.ts b/components/userArticles/controller.ts
new file mode 100644
index 0000000..0b921ca
--- /dev/null
+++ b/components/userArticles/controller.ts
@@ -0,0 +1,101 @@
+import { useMemo, useState } from 'react'
+import type { Article } from '@/types/nostr'
+import { useArticleEditing } from '@/hooks/useArticleEditing'
+import type { ArticleDraft } from '@/lib/articlePublisherTypes'
+import type { UserArticlesController, UserArticlesControllerParams } from './types'
+
+export function useUserArticlesController(params: UserArticlesControllerParams): UserArticlesController {
+  const [deletedArticleIds, setDeletedArticleIds] = useState<Set<string>>(new Set())
+  const [articleOverridesById, setArticleOverridesById] = useState<Map<string, Article>>(new Map())
+  const [unlockedArticles, setUnlockedArticles] = useState<Set<string>>(new Set())
+  const [pendingDeleteId, setPendingDeleteId] = useState<string | null>(null)
+  const editingCtx = useArticleEditing(params.currentPubkey)
+
+  const localArticles = useMemo((): Article[] => {
+    return params.articles.filter((a) => !deletedArticleIds.has(a.id)).map((a) => articleOverridesById.get(a.id) ?? a)
+  }, [articleOverridesById, deletedArticleIds, params.articles])
+
+  return {
+    localArticles,
+    unlockedArticles,
+    pendingDeleteId,
+    requestDelete: (id: string) => setPendingDeleteId(id),
+    handleUnlock: createHandleUnlock(params.onLoadContent, setUnlockedArticles),
+    handleDelete: createHandleDelete(editingCtx.deleteArticle, setDeletedArticleIds, setPendingDeleteId),
+    handleEditSubmit: createHandleEditSubmit(editingCtx.submitEdit, editingCtx.editingDraft, params.currentPubkey, setArticleOverridesById),
+    ...editingCtx,
+  }
+}
+
+function createHandleUnlock(
+  onLoadContent: (id: string, pubkey: string) => Promise<Article | null>,
+  setUnlocked: React.Dispatch<React.SetStateAction<Set<string>>>
+): (article: Article) => Promise<void> {
+  return async (article: Article): Promise<void> => {
+    const full = await onLoadContent(article.id, article.pubkey)
+    if (full?.paid) {
+      setUnlocked((prev) => new Set([...prev, article.id]))
+    }
+  }
+}
+
+function createHandleDelete(
+  deleteArticle: (id: string) => Promise<boolean>,
+  setDeletedArticleIds: React.Dispatch<React.SetStateAction<Set<string>>>,
+  setPendingDeleteId: React.Dispatch<React.SetStateAction<string | null>>
+): (article: Article) => Promise<void> {
+  return async (article: Article): Promise<void> => {
+    const ok = await deleteArticle(article.id)
+    if (ok) {
+      setDeletedArticleIds((prev) => new Set([...prev, article.id]))
+    }
+    setPendingDeleteId(null)
+  }
+}
+
+function createHandleEditSubmit(
+  submitEdit: () => Promise<import('@/lib/articleMutations').ArticleUpdateResult | null>,
+  draft: ReturnType<typeof useArticleEditing>['editingDraft'],
+  currentPubkey: string | null,
+  setArticleOverridesById: React.Dispatch<React.SetStateAction<Map<string, Article>>>
+): () => Promise<void> {
+  return async (): Promise<void> => {
+    const result = await submitEdit()
+    if (result && draft) {
+      const updated = buildUpdatedArticle(draft, currentPubkey ?? '', result.articleId)
+      setArticleOverridesById((prev) => {
+        const next = new Map(prev)
+        next.set(result.originalArticleId, { ...updated, id: result.originalArticleId })
+        return next
+      })
+    }
+  }
+}
+
+function buildUpdatedArticle(draft: ArticleDraft, pubkey: string, newId: string): Article {
+  const parts = newId.split('_')
+  const hash = parts[0] ?? ''
+  const index = Number.parseInt(parts[1] ?? '0', 10)
+  const version = Number.parseInt(parts[2] ?? '0', 10)
+  return {
+    id: newId,
+    hash,
+    version,
+    index,
+    pubkey,
+    title: draft.title,
+    preview: draft.preview,
+    content: '',
+    description: draft.preview,
+    contentDescription: draft.preview,
+    createdAt: Math.floor(Date.now() / 1000),
+    zapAmount: draft.zapAmount,
+    paid: false,
+    thumbnailUrl: draft.bannerUrl ?? '',
+    ...(draft.category ? { category: draft.category } : {}),
+    ...(draft.seriesId ? { seriesId: draft.seriesId } : {}),
+    ...(draft.bannerUrl ? { bannerUrl: draft.bannerUrl } : {}),
+    ...(draft.media ? { media: draft.media } : {}),
+    ...(draft.pages ? { pages: draft.pages } : {}),
+  }
+}
diff --git a/components/userArticles/layout.tsx b/components/userArticles/layout.tsx
new file mode 100644
index 0000000..fa7f7e9
--- /dev/null
+++ b/components/userArticles/layout.tsx
@@ -0,0 +1,93 @@
+import type { Article } from '@/types/nostr'
+import type { ArticleDraft } from '@/lib/articlePublisherTypes'
+import { EditPanel } from '../UserArticlesEditPanel'
+import { UserArticlesView } from '../UserArticlesList'
+import type { UserArticlesController } from './types'
+
+type UserArticlesLayoutProps = {
+  controller: UserArticlesController
+  loading: boolean
+  error: string | null
+  showEmptyMessage: boolean
+  currentPubkey: string | null
+  onSelectSeries?: ((seriesId: string | undefined) => void) | undefined
+}
+
+export function UserArticlesLayout(props: UserArticlesLayoutProps): React.ReactElement {
+  const { editPanelProps, listProps } = createLayoutProps(props.controller, props)
+  return (
+    <div className="space-y-4">
+      <EditPanel {...editPanelProps} />
+      <UserArticlesView {...listProps} />
+    </div>
+  )
+}
+
+function createLayoutProps(controller: UserArticlesController, view: UserArticlesLayoutProps): { editPanelProps: EditPanelProps; listProps: UserArticlesListProps } {
+  return { editPanelProps: buildEditPanelProps(controller), listProps: buildListProps(controller, view) }
+}
+
+type EditPanelProps = {
+  draft: ArticleDraft | null
+  editingArticleId: string | null
+  loading: boolean
+  error: string | null
+  onCancel: () => void
+  onDraftChange: (draft: ArticleDraft) => void
+  onSubmit: () => Promise<void>
+}
+
+function buildEditPanelProps(controller: UserArticlesController): EditPanelProps {
+  return {
+    draft: controller.editingDraft,
+    editingArticleId: controller.editingArticleId,
+    loading: controller.loading,
+    error: controller.error,
+    onCancel: controller.cancelEditing,
+    onDraftChange: controller.updateDraft,
+    onSubmit: controller.handleEditSubmit,
+  }
+}
+
+type UserArticlesListProps = {
+  articles: Article[]
+  loading: boolean
+  error: string | null
+  showEmptyMessage: boolean
+  unlockedArticles: Set<string>
+  onUnlock: (article: Article) => void
+  onEdit: (article: Article) => void
+  onDelete: (article: Article) => void
+  editingArticleId: string | null
+  currentPubkey: string | null
+  pendingDeleteId: string | null
+  requestDelete: (articleId: string) => void
+  onSelectSeries?: ((seriesId: string | undefined) => void) | undefined
+}
+
+function buildListProps(controller: UserArticlesController, view: UserArticlesLayoutProps): UserArticlesListProps {
+  const handlers = buildUserArticlesHandlers(controller)
+  return {
+    articles: controller.localArticles,
+    loading: view.loading,
+    error: view.error,
+    showEmptyMessage: view.showEmptyMessage,
+    unlockedArticles: controller.unlockedArticles,
+    onUnlock: handlers.onUnlock,
+    onEdit: handlers.onEdit,
+    onDelete: handlers.onDelete,
+    editingArticleId: controller.editingArticleId,
+    currentPubkey: view.currentPubkey,
+    pendingDeleteId: controller.pendingDeleteId,
+    requestDelete: controller.requestDelete,
+    ...(view.onSelectSeries ? { onSelectSeries: view.onSelectSeries } : {}),
+  }
+}
+
+function buildUserArticlesHandlers(controller: UserArticlesController): { onUnlock: (article: Article) => void; onEdit: (article: Article) => void; onDelete: (article: Article) => void } {
+  return {
+    onUnlock: (a: Article): void => void controller.handleUnlock(a),
+    onEdit: (a: Article): void => void controller.startEditing(a),
+    onDelete: (a: Article): void => void controller.handleDelete(a),
+  }
+}
diff --git a/components/userArticles/types.ts b/components/userArticles/types.ts
new file mode 100644
index 0000000..e886b8c
--- /dev/null
+++ b/components/userArticles/types.ts
@@ -0,0 +1,45 @@
+import type { Dispatch, SetStateAction } from 'react'
+import type { Article } from '@/types/nostr'
+import type { ArticleDraft } from '@/lib/articlePublisherTypes'
+import type { useArticleEditing } from '@/hooks/useArticleEditing'
+
+export interface UserArticlesProps {
+  articles: Article[]
+  loading: boolean
+  error: string | null
+  onLoadContent: (articleId: string, authorPubkey: string) => Promise<Article | null>
+  showEmptyMessage?: boolean
+  currentPubkey: string | null
+  onSelectSeries?: ((seriesId: string | undefined) => void) | undefined
+}
+
+export type UserArticlesController = {
+  localArticles: Article[]
+  unlockedArticles: Set<string>
+  pendingDeleteId: string | null
+  requestDelete: (id: string) => void
+  handleUnlock: (article: Article) => Promise<void>
+  handleDelete: (article: Article) => Promise<void>
+  handleEditSubmit: () => Promise<void>
+  editingDraft: ArticleDraft | null
+  editingArticleId: string | null
+  loading: boolean
+  error: string | null
+  updateDraft: (draft: ArticleDraft) => void
+  startEditing: (article: Article) => Promise<void>
+  cancelEditing: () => void
+  submitEdit: () => Promise<import('@/lib/articleMutations').ArticleUpdateResult | null>
+  deleteArticle: (id: string) => Promise<boolean>
+}
+
+export type UserArticlesControllerParams = {
+  articles: Article[]
+  onLoadContent: (articleId: string, authorPubkey: string) => Promise<Article | null>
+  currentPubkey: string | null
+}
+
+export type SetStringSet = Dispatch<SetStateAction<Set<string>>>
+export type SetStringOrNull = Dispatch<SetStateAction<string | null>>
+export type SetArticleMap = Dispatch<SetStateAction<Map<string, Article>>>
+
+export type EditingContext = ReturnType<typeof useArticleEditing>
diff --git a/hooks/useArticlePayment.ts b/hooks/useArticlePayment.ts
index aee41a4..fdbf83f 100644
--- a/hooks/useArticlePayment.ts
+++ b/hooks/useArticlePayment.ts
@@ -43,7 +43,8 @@ async function unlockArticlePayment(params: {
   setPaymentInvoice: (value: AlbyInvoice | null) => void
   setPaymentHash: (value: string | null) => void
 }): Promise<void> {
-  if (!params.pubkey) {
+  const {pubkey} = params
+  if (!pubkey) {
     await ensureConnectedOrError({
       connect: params.connect,
       setLoading: params.setLoading,
@@ -52,13 +53,40 @@ async function unlockArticlePayment(params: {
     return
   }
 
+  await startArticlePaymentFlow({
+    article: params.article,
+    pubkey,
+    onUnlockSuccess: params.onUnlockSuccess,
+    setLoading: params.setLoading,
+    setError: params.setError,
+    setPaymentInvoice: params.setPaymentInvoice,
+    setPaymentHash: params.setPaymentHash,
+  })
+}
+
+function readPaymentResult(value: Awaited<ReturnType<typeof paymentService.createArticlePayment>>): { invoice: AlbyInvoice; paymentHash: string } | null {
+  if (!value.success || !value.invoice || !value.paymentHash) {
+    return null
+  }
+  return { invoice: value.invoice, paymentHash: value.paymentHash }
+}
+
+async function startArticlePaymentFlow(params: {
+  article: Article
+  pubkey: string
+  onUnlockSuccess: (() => void) | undefined
+  setLoading: (value: boolean) => void
+  setError: (value: string | null) => void
+  setPaymentInvoice: (value: AlbyInvoice | null) => void
+  setPaymentHash: (value: string | null) => void
+}): Promise<void> {
   params.setLoading(true)
   params.setError(null)
   try {
-    const paymentResult = await paymentService.createArticlePayment({ article: params.article, userPubkey: params.pubkey })
-    const ok = readPaymentResult(paymentResult)
+    const result = await paymentService.createArticlePayment({ article: params.article, userPubkey: params.pubkey })
+    const ok = readPaymentResult(result)
     if (!ok) {
-      params.setError(paymentResult.error ?? 'Failed to create payment invoice')
+      params.setError(result.error ?? 'Failed to create payment invoice')
       return
     }
     params.setPaymentInvoice(ok.invoice)
@@ -73,13 +101,6 @@ async function unlockArticlePayment(params: {
   }
 }
 
-function readPaymentResult(value: Awaited<ReturnType<typeof paymentService.createArticlePayment>>): { invoice: AlbyInvoice; paymentHash: string } | null {
-  if (!value.success || !value.invoice || !value.paymentHash) {
-    return null
-  }
-  return { invoice: value.invoice, paymentHash: value.paymentHash }
-}
-
 async function ensureConnectedOrError(params: {
   connect: (() => Promise<void>) | undefined
   setLoading: (value: boolean) => void
diff --git a/lib/articleMutations.ts b/lib/articleMutations.ts
index f7251b8..502cfb8 100644
--- a/lib/articleMutations.ts
+++ b/lib/articleMutations.ts
@@ -1,675 +1,5 @@
-import { nostrService } from './nostr'
-import { createArticleInvoice, createPreviewEvent } from './articleInvoice'
-import { storePrivateContent, getStoredPrivateContent } from './articleStorage'
-import { buildTags } from './nostrTagSystem'
-import { PLATFORM_SERVICE } from './platformConfig'
-import { generateSeriesHashId, generatePublicationHashId } from './hashIdGenerator'
-import { buildObjectId } from './urlGenerator'
-import type { ArticleDraft, PublishedArticle } from './articlePublisher'
-import type { AlbyInvoice } from '@/types/alby'
-import type { Article, Review, Series } from '@/types/nostr'
-import { writeOrchestrator } from './writeOrchestrator'
-import { finalizeEvent, type EventTemplate } from 'nostr-tools'
-import { hexToBytes } from 'nostr-tools/utils'
-import { buildParsedArticleFromDraft as buildParsedArticleFromDraftCore } from './articleDraftToParsedArticle'
-import { getPublishRelays } from './relaySelection'
-
-export interface ArticleUpdateResult extends PublishedArticle {
-  originalArticleId: string
-}
-
-function ensureKeys(authorPubkey: string, authorPrivateKey?: string): void {
-  nostrService.setPublicKey(authorPubkey)
-  if (authorPrivateKey) {
-    nostrService.setPrivateKey(authorPrivateKey)
-  } else if (!nostrService.getPrivateKey()) {
-    throw new Error('Private key required for signing. Connect a wallet that can sign.')
-  }
-}
-
-function requireCategory(category?: ArticleDraft['category']): asserts category is NonNullable<ArticleDraft['category']> {
-  if (category !== 'science-fiction' && category !== 'scientific-research') {
-    throw new Error('Vous devez sélectionner une catégorie (science-fiction ou recherche scientifique).')
-  }
-}
-
-async function ensurePresentation(authorPubkey: string): Promise<string> {
-  const { articlePublisher } = await import('./articlePublisher')
-  const presentation = await articlePublisher.getAuthorPresentation(authorPubkey)
-  if (!presentation) {
-    throw new Error('Vous devez créer un article de présentation avant de publier des articles.')
-  }
-  return presentation.id
-}
-
-async function buildParsedArticleFromDraft(
-  draft: ArticleDraft,
-  invoice: AlbyInvoice,
-  authorPubkey: string
-): Promise<{ article: Article; hash: string; version: number; index: number }> {
-  return buildParsedArticleFromDraftCore({ draft, invoice, authorPubkey })
-}
-
-interface PublishPreviewWithInvoiceParams {
-  draft: ArticleDraft
-  invoice: AlbyInvoice
-  authorPubkey: string
-  presentationId: string
-  extraTags?: string[][]
-  customArticle?: Article
-}
-
-async function publishPreviewWithInvoice(
-  params: PublishPreviewWithInvoiceParams
-): Promise<import('nostr-tools').Event | null> {
-  const payload = await resolvePublicationPayload(params)
-
-  // Build event template
-  const previewEventTemplate = await createPreviewEvent({
-    draft: params.draft,
-    invoice: params.invoice,
-    authorPubkey: params.authorPubkey,
-    authorPresentationId: params.presentationId,
-    ...(params.extraTags ? { extraTags: params.extraTags } : {}),
-  })
-
-  // Set private key in orchestrator
-  const privateKey = nostrService.getPrivateKey()
-  if (!privateKey) {
-    throw new Error('Private key required for signing')
-  }
-  writeOrchestrator.setPrivateKey(privateKey)
-
-  // Finalize event
-  const secretKey = hexToBytes(privateKey)
-  const event = finalizeEvent(previewEventTemplate, secretKey)
-
-  return publishPublicationToRelays({ event, payload })
-}
-
-async function resolvePublicationPayload(params: PublishPreviewWithInvoiceParams): Promise<{
-  article: Article
-  hash: string
-  version: number
-  index: number
-}> {
-  if (params.customArticle) {
-    return {
-      article: params.customArticle,
-      hash: params.customArticle.hash,
-      version: params.customArticle.version,
-      index: params.customArticle.index ?? 0,
-    }
-  }
-  return buildParsedArticleFromDraft(params.draft, params.invoice, params.authorPubkey)
-}
-
-async function publishPublicationToRelays(params: {
-  event: import('nostr-tools').Event
-  payload: { article: Article; hash: string; version: number; index: number }
-}): Promise<import('nostr-tools').Event | null> {
-  const relays = await getPublishRelays()
-  const result = await writeOrchestrator.writeAndPublish(
-    {
-      objectType: 'publication',
-      hash: params.payload.hash,
-      event: params.event,
-      parsed: params.payload.article,
-      version: params.payload.version,
-      hidden: false,
-      index: params.payload.index,
-    },
-    relays
-  )
-  return result.success ? params.event : null
-}
-
-export async function publishSeries(params: {
-  title: string
-  description: string
-  preview?: string
-  coverUrl?: string
-  category: ArticleDraft['category']
-  authorPubkey: string
-  authorPrivateKey?: string
-}): Promise<Series> {
-  ensureKeys(params.authorPubkey, params.authorPrivateKey)
-  const category = requireSeriesCategory(params.category)
-  const newCategory = mapSeriesCategoryToTag(category)
-  const preview = buildSeriesPreview(params.preview, params.description)
-
-  const hashId = await generateSeriesHashId({
-    pubkey: params.authorPubkey,
-    title: params.title,
-    description: params.description,
-    category: newCategory,
-    ...(params.coverUrl ? { coverUrl: params.coverUrl } : {}),
-  })
-
-  const parsedSeries = buildParsedSeries({
-    authorPubkey: params.authorPubkey,
-    title: params.title,
-    description: params.description,
-    preview,
-    coverUrl: params.coverUrl,
-    category,
-    hashId,
-  })
-
-  const eventTemplate = buildSeriesEventTemplate({
-    authorPubkey: params.authorPubkey,
-    title: params.title,
-    description: params.description,
-    preview,
-    coverUrl: params.coverUrl,
-    category: newCategory,
-    hashId,
-  })
-
-  const event = finalizeEvent(eventTemplate, hexToBytes(getPrivateKeyForSigning(params.authorPrivateKey)))
-  const relays = await getPublishRelays()
-  const result = await writeOrchestrator.writeAndPublish(
-    {
-      objectType: 'series',
-      hash: parsedSeries.hash,
-      event,
-      parsed: parsedSeries,
-      version: parsedSeries.version,
-      hidden: false,
-      index: parsedSeries.index,
-    },
-    relays
-  )
-
-  if (!result.success) {
-    throw new Error('Failed to publish series')
-  }
-
-  return parsedSeries
-}
-
-function requireSeriesCategory(category: ArticleDraft['category']): NonNullable<ArticleDraft['category']> {
-  requireCategory(category)
-  return category
-}
-
-function mapSeriesCategoryToTag(category: NonNullable<ArticleDraft['category']>): 'sciencefiction' | 'research' {
-  return category === 'science-fiction' ? 'sciencefiction' : 'research'
-}
-
-function buildSeriesPreview(preview: string | undefined, description: string): string {
-  return preview ?? description.substring(0, 200)
-}
-
-function buildParsedSeries(params: {
-  authorPubkey: string
-  title: string
-  description: string
-  preview: string
-  coverUrl: string | undefined
-  category: NonNullable<ArticleDraft['category']>
-  hashId: string
-}): Series {
-  const hash = params.hashId
-  const version = 0
-  const index = 0
-  const id = buildObjectId(hash, index, version)
-  return {
-    id,
-    hash,
-    version,
-    index,
-    pubkey: params.authorPubkey,
-    title: params.title,
-    description: params.description,
-    preview: params.preview,
-    thumbnailUrl: params.coverUrl ?? '',
-    category: params.category,
-    ...(params.coverUrl ? { coverUrl: params.coverUrl } : {}),
-    kindType: 'series',
-  }
-}
-
-function buildSeriesEventTemplate(params: {
-  authorPubkey: string
-  title: string
-  description: string
-  preview: string
-  coverUrl: string | undefined
-  category: 'sciencefiction' | 'research'
-  hashId: string
-}): EventTemplate {
-  const tags = buildTags({
-    type: 'series',
-    category: params.category,
-    id: params.hashId,
-    service: PLATFORM_SERVICE,
-    version: 0,
-    hidden: false,
-    paywall: false,
-    title: params.title,
-    description: params.description,
-    preview: params.preview,
-    ...(params.coverUrl ? { coverUrl: params.coverUrl } : {}),
-  })
-  tags.push(['json', buildSeriesJson(params)])
-  return { kind: 1, created_at: Math.floor(Date.now() / 1000), content: params.preview, tags }
-}
-
-function buildSeriesJson(params: {
-  authorPubkey: string
-  title: string
-  description: string
-  preview: string
-  coverUrl: string | undefined
-  category: 'sciencefiction' | 'research'
-  hashId: string
-}): string {
-  return JSON.stringify({
-    type: 'series',
-    pubkey: params.authorPubkey,
-    title: params.title,
-    description: params.description,
-    preview: params.preview,
-    ...(params.coverUrl ? { coverUrl: params.coverUrl } : {}),
-    category: params.category,
-    id: params.hashId,
-    version: 0,
-    index: 0,
-  })
-}
-
-function getPrivateKeyForSigning(authorPrivateKey: string | undefined): string {
-  const privateKey = authorPrivateKey ?? nostrService.getPrivateKey()
-  if (!privateKey) {
-    throw new Error('Private key required for signing')
-  }
-  writeOrchestrator.setPrivateKey(privateKey)
-  return privateKey
-}
-
-export async function publishReview(params: {
-  articleId: string
-  seriesId: string
-  category: ArticleDraft['category']
-  authorPubkey: string
-  reviewerPubkey: string
-  content: string
-  title?: string
-  text?: string
-  authorPrivateKey?: string
-}): Promise<Review> {
-  ensureKeys(params.reviewerPubkey, params.authorPrivateKey)
-  const {category} = params
-  requireCategory(category)
-
-  // Generate hash ID from review data
-  const { generateReviewHashId } = await import('./hashIdGenerator')
-  const hashId = await generateReviewHashId({
-    pubkey: params.reviewerPubkey,
-    articleId: params.articleId,
-    reviewerPubkey: params.reviewerPubkey,
-    content: params.content,
-    ...(params.title ? { title: params.title } : {}),
-  })
-
-  const hash = hashId
-  const version = 0
-  const index = 0
-  const id = buildObjectId(hash, index, version)
-
-  // Build parsed Review object
-  const parsedReview: Review = {
-    id,
-    hash,
-    version,
-    index,
-    articleId: params.articleId,
-    authorPubkey: params.authorPubkey,
-    reviewerPubkey: params.reviewerPubkey,
-    content: params.content,
-    description: params.content.substring(0, 200),
-    createdAt: Math.floor(Date.now() / 1000),
-    ...(params.title ? { title: params.title } : {}),
-    ...(params.text ? { text: params.text } : {}),
-    kindType: 'review',
-  }
-
-  // Build event template
-  const eventTemplate = await buildReviewEvent(params, category)
-
-  // Set private key in orchestrator
-  const privateKey = params.authorPrivateKey ?? nostrService.getPrivateKey()
-  if (!privateKey) {
-    throw new Error('Private key required for signing')
-  }
-  writeOrchestrator.setPrivateKey(privateKey)
-
-  // Finalize event
-  const secretKey = hexToBytes(privateKey)
-  const event = finalizeEvent(eventTemplate, secretKey)
-
-  // Get active relays
-  const { relaySessionManager } = await import('./relaySessionManager')
-  const activeRelays = await relaySessionManager.getActiveRelays()
-  const { getPrimaryRelay } = await import('./config')
-  const relays = activeRelays.length > 0 ? activeRelays : [await getPrimaryRelay()]
-
-  // Publish via writeOrchestrator (parallel network + local write)
-  const result = await writeOrchestrator.writeAndPublish(
-    {
-      objectType: 'review',
-      hash,
-      event,
-      parsed: parsedReview,
-      version,
-      hidden: false,
-      index,
-    },
-    relays
-  )
-
-  if (!result.success) {
-    throw new Error('Failed to publish review')
-  }
-
-  return parsedReview
-}
-
-async function buildReviewEvent(
-  params: {
-    articleId: string
-    seriesId: string
-    authorPubkey: string
-    reviewerPubkey: string
-    content: string
-    title?: string
-    text?: string
-  },
-  category: NonNullable<ArticleDraft['category']>
-): Promise<{
-  kind: number
-  created_at: number
-  content: string
-  tags: string[][]
-}> {
-  // Map category to new system
-  const newCategory = category === 'science-fiction' ? 'sciencefiction' : 'research'
-
-  // Generate hash ID from review data
-  const { generateReviewHashId } = await import('./hashIdGenerator')
-  const hashId = await generateReviewHashId({
-    pubkey: params.reviewerPubkey,
-    articleId: params.articleId,
-    reviewerPubkey: params.reviewerPubkey,
-    content: params.content,
-    ...(params.title ? { title: params.title } : {}),
-  })
-
-  // Build JSON metadata
-  const reviewJson = JSON.stringify({
-    type: 'review',
-    pubkey: params.reviewerPubkey,
-    articleId: params.articleId,
-    reviewerPubkey: params.reviewerPubkey,
-    content: params.content,
-    title: params.title,
-    category: newCategory,
-    id: hashId,
-    version: 0,
-    index: 0,
-  })
-
-  const tags = buildTags({
-    type: 'quote',
-    category: newCategory,
-    id: hashId,
-    service: PLATFORM_SERVICE,
-    version: 0, // New object
-    hidden: false,
-    paywall: false,
-    articleId: params.articleId,
-    reviewerPubkey: params.reviewerPubkey,
-    ...(params.title ? { title: params.title } : {}),
-  })
-
-  // Add text tag if provided
-  if (params.text) {
-    tags.push(['text', params.text])
-  }
-
-  // Add JSON metadata as a tag
-  tags.push(['json', reviewJson])
-
-  return {
-    kind: 1,
-    created_at: Math.floor(Date.now() / 1000),
-    content: params.content,
-    tags,
-  }
-}
-
-async function buildUpdateTags(params: {
-  draft: ArticleDraft
-  originalArticleId: string
-  newCategory: 'sciencefiction' | 'research'
-  authorPubkey: string
-  currentVersion?: number
-}): Promise<string[][]> {
-  // Generate hash ID from publication data
-  const hashId = await generatePublicationHashId({
-    pubkey: params.authorPubkey,
-    title: params.draft.title,
-    preview: params.draft.preview,
-    category: params.newCategory,
-    seriesId: params.draft.seriesId ?? undefined,
-    bannerUrl: params.draft.bannerUrl ?? undefined,
-    zapAmount: params.draft.zapAmount,
-  })
-
-  // Increment version for update
-  const currentVersion = params.currentVersion ?? 0
-  const nextVersion = currentVersion + 1
-
-  const updateTags = buildTags({
-    type: 'publication',
-    category: params.newCategory,
-    id: hashId,
-    service: PLATFORM_SERVICE,
-    version: nextVersion,
-    hidden: false,
-    paywall: true,
-    title: params.draft.title,
-    preview: params.draft.preview,
-    zapAmount: params.draft.zapAmount,
-    ...(params.draft.seriesId ? { seriesId: params.draft.seriesId } : {}),
-    ...(params.draft.bannerUrl ? { bannerUrl: params.draft.bannerUrl } : {}),
-  })
-  updateTags.push(['e', params.originalArticleId], ['replace', 'article-update'])
-  return updateTags
-}
-
-async function publishUpdate(
-  draft: ArticleDraft,
-  authorPubkey: string,
-  originalArticleId: string
-): Promise<ArticleUpdateResult> {
-  const category = requireUpdateCategory(draft)
-  const originalArticle = await loadOriginalArticleForUpdate(originalArticleId)
-  if (!originalArticle) {
-    return updateFailure(originalArticleId, 'Original article not found in cache')
-  }
-  if (originalArticle.pubkey !== authorPubkey) {
-    return updateFailure(originalArticleId, 'Only the author can update this article')
-  }
-
-  const presentationId = await ensurePresentation(authorPubkey)
-  const invoice = await createArticleInvoice(draft)
-  const newCategory = mapPublicationCategoryToTag(category)
-  const currentVersion = originalArticle.version ?? 0
-
-  const updateTags = await buildUpdateTags({ draft, originalArticleId, newCategory, authorPubkey, currentVersion })
-  const updatedArticle = await buildUpdatedArticleForUpdate({ draft, invoice, authorPubkey, currentVersion })
-  const publishedEvent = await publishPreviewWithInvoice({ draft, invoice, authorPubkey, presentationId, extraTags: updateTags, customArticle: updatedArticle })
-  if (!publishedEvent) {
-    return updateFailure(originalArticleId, 'Failed to publish article update')
-  }
-
-  await storePrivateContent({ articleId: publishedEvent.id, content: draft.content, authorPubkey, invoice })
-  return { articleId: publishedEvent.id, previewEventId: publishedEvent.id, invoice, success: true, originalArticleId }
-}
-
-function requireUpdateCategory(draft: ArticleDraft): NonNullable<ArticleDraft['category']> {
-  requireCategory(draft.category)
-  return draft.category
-}
-
-async function loadOriginalArticleForUpdate(originalArticleId: string): Promise<Article | null> {
-  const { objectCache } = await import('./objectCache')
-  return (await objectCache.getById('publication', originalArticleId)) as Article | null
-}
-
-function mapPublicationCategoryToTag(category: NonNullable<ArticleDraft['category']>): 'sciencefiction' | 'research' {
-  return category === 'science-fiction' ? 'sciencefiction' : 'research'
-}
-
-async function buildUpdatedArticleForUpdate(params: {
-  draft: ArticleDraft
-  invoice: AlbyInvoice
-  authorPubkey: string
-  currentVersion: number
-}): Promise<Article> {
-  const { article } = await buildParsedArticleFromDraft(params.draft, params.invoice, params.authorPubkey)
-  return { ...article, version: params.currentVersion + 1 }
-}
-
-export async function publishArticleUpdate(
-  originalArticleId: string,
-  draft: ArticleDraft,
-  authorPubkey: string,
-  authorPrivateKey?: string
-): Promise<ArticleUpdateResult> {
-  try {
-    ensureKeys(authorPubkey, authorPrivateKey)
-    return publishUpdate(draft, authorPubkey, originalArticleId)
-  } catch (error) {
-    return updateFailure(originalArticleId, error instanceof Error ? error.message : 'Unknown error')
-  }
-}
-
-function updateFailure(originalArticleId: string, error?: string): ArticleUpdateResult {
-  return {
-    articleId: '',
-    previewEventId: '',
-    success: false,
-    originalArticleId,
-    ...(error ? { error } : {}),
-  }
-}
-
-export async function deleteArticleEvent(articleId: string, authorPubkey: string, authorPrivateKey?: string): Promise<void> {
-  ensureKeys(authorPubkey, authorPrivateKey)
-
-  const originalEvent = await getOriginalPublicationEventOrThrow(articleId)
-  assertAuthorOwnsEvent({ eventPubkey: originalEvent.pubkey, authorPubkey })
-
-  const deleteEventTemplate = await buildDeleteEventTemplateOrThrow({ originalEvent, authorPubkey })
-  const originalParsed = await parseOriginalArticleOrThrow(originalEvent)
-  const deletePayload = await buildDeletedArticlePayload({ originalParsed, deleteEventTemplate })
-
-  const event = await finalizeEventTemplate({ template: deleteEventTemplate, authorPrivateKey })
-  const relays = await getPublishRelays()
-  await publishDeletion({ event, relays, payload: deletePayload })
-}
-
-async function getOriginalPublicationEventOrThrow(articleId: string): Promise<import('nostr-tools').Event> {
-  const { objectCache } = await import('./objectCache')
-  const originalEvent = await objectCache.getEventById('publication', articleId)
-  if (!originalEvent) {
-    throw new Error('Article not found in cache')
-  }
-  return originalEvent
-}
-
-function assertAuthorOwnsEvent(params: { eventPubkey: string; authorPubkey: string }): void {
-  if (params.eventPubkey !== params.authorPubkey) {
-    throw new Error('Only the author can delete this article')
-  }
-}
-
-async function buildDeleteEventTemplateOrThrow(params: {
-  originalEvent: import('nostr-tools').Event
-  authorPubkey: string
-}): Promise<import('nostr-tools').EventTemplate> {
-  const { buildDeleteEvent } = await import('./objectModification')
-  const template = await buildDeleteEvent(params.originalEvent, params.authorPubkey)
-  if (!template) {
-    throw new Error('Failed to build delete event')
-  }
-  return template
-}
-
-async function parseOriginalArticleOrThrow(originalEvent: import('nostr-tools').Event): Promise<Article> {
-  const { parseArticleFromEvent } = await import('./nostrEventParsing')
-  const parsed = await parseArticleFromEvent(originalEvent)
-  if (!parsed) {
-    throw new Error('Failed to parse original article')
-  }
-  return parsed
-}
-
-async function buildDeletedArticlePayload(params: {
-  originalParsed: Article
-  deleteEventTemplate: import('nostr-tools').EventTemplate
-}): Promise<{ hash: string; index: number; version: number; parsed: Article }> {
-  const { extractTagsFromEvent } = await import('./nostrTagSystem')
-  const tags = extractTagsFromEvent(params.deleteEventTemplate)
-  const version = tags.version ?? params.originalParsed.version + 1
-  const index = params.originalParsed.index ?? 0
-  const parsed: Article = { ...params.originalParsed, version }
-  return { hash: params.originalParsed.hash, index, version, parsed }
-}
-
-async function finalizeEventTemplate(params: {
-  template: import('nostr-tools').EventTemplate
-  authorPrivateKey: string | undefined
-}): Promise<import('nostr-tools').Event> {
-  const privateKey = params.authorPrivateKey ?? nostrService.getPrivateKey()
-  if (!privateKey) {
-    throw new Error('Private key required for signing')
-  }
-  const { writeOrchestrator: writeOrchestratorInstance } = await import('./writeOrchestrator')
-  writeOrchestratorInstance.setPrivateKey(privateKey)
-
-  const { finalizeEvent: finalizeNostrEvent } = await import('nostr-tools')
-  const { hexToBytes: hexToBytesUtil } = await import('nostr-tools/utils')
-  const secretKey = hexToBytesUtil(privateKey)
-  return finalizeNostrEvent(params.template, secretKey)
-}
-
-async function publishDeletion(params: {
-  event: import('nostr-tools').Event
-  relays: string[]
-  payload: { hash: string; index: number; version: number; parsed: Article }
-}): Promise<void> {
-  const { writeOrchestrator: writeOrchestratorInstance } = await import('./writeOrchestrator')
-  const result = await writeOrchestratorInstance.writeAndPublish(
-    {
-      objectType: 'publication',
-      hash: params.payload.hash,
-      event: params.event,
-      parsed: params.payload.parsed,
-      version: params.payload.version,
-      hidden: true,
-      index: params.payload.index,
-    },
-    params.relays
-  )
-  if (!result.success) {
-    throw new Error('Failed to publish delete event')
-  }
-}
+export * from './articleMutations/index'
 
 // Re-export for convenience to avoid circular imports in hooks
 export { articlePublisher } from './articlePublisher'
-export const getStoredContent = getStoredPrivateContent
+export { getStoredPrivateContent as getStoredContent } from './articleStorage'
diff --git a/lib/articleMutations/delete.ts b/lib/articleMutations/delete.ts
new file mode 100644
index 0000000..525abd3
--- /dev/null
+++ b/lib/articleMutations/delete.ts
@@ -0,0 +1,85 @@
+import type { Article } from '@/types/nostr'
+import { nostrService } from '../nostr'
+import { getPublishRelays } from '../relaySelection'
+import { ensureKeys } from './shared'
+
+export async function deleteArticleEvent(articleId: string, authorPubkey: string, authorPrivateKey?: string): Promise<void> {
+  ensureKeys(authorPubkey, authorPrivateKey)
+  const originalEvent = await getOriginalPublicationEventOrThrow(articleId)
+  assertAuthorOwnsEvent({ eventPubkey: originalEvent.pubkey, authorPubkey })
+  const deleteEventTemplate = await buildDeleteEventTemplateOrThrow({ originalEvent, authorPubkey })
+  const originalParsed = await parseOriginalArticleOrThrow(originalEvent)
+  const deletePayload = await buildDeletedArticlePayload({ originalParsed, deleteEventTemplate })
+  const event = await finalizeEventTemplate({ template: deleteEventTemplate, authorPrivateKey })
+  const relays = await getPublishRelays()
+  await publishDeletion({ event, relays, payload: deletePayload })
+}
+
+async function getOriginalPublicationEventOrThrow(articleId: string): Promise<import('nostr-tools').Event> {
+  const { objectCache } = await import('../objectCache')
+  const originalEvent = await objectCache.getEventById('publication', articleId)
+  if (!originalEvent) {
+    throw new Error('Article not found in cache')
+  }
+  return originalEvent
+}
+
+function assertAuthorOwnsEvent(params: { eventPubkey: string; authorPubkey: string }): void {
+  if (params.eventPubkey !== params.authorPubkey) {
+    throw new Error('Only the author can delete this article')
+  }
+}
+
+async function buildDeleteEventTemplateOrThrow(params: { originalEvent: import('nostr-tools').Event; authorPubkey: string }): Promise<import('nostr-tools').EventTemplate> {
+  const { buildDeleteEvent } = await import('../objectModification')
+  const template = await buildDeleteEvent(params.originalEvent, params.authorPubkey)
+  if (!template) {
+    throw new Error('Failed to build delete event')
+  }
+  return template
+}
+
+async function parseOriginalArticleOrThrow(originalEvent: import('nostr-tools').Event): Promise<Article> {
+  const { parseArticleFromEvent } = await import('../nostrEventParsing')
+  const parsed = await parseArticleFromEvent(originalEvent)
+  if (!parsed) {
+    throw new Error('Failed to parse original article')
+  }
+  return parsed
+}
+
+async function buildDeletedArticlePayload(params: { originalParsed: Article; deleteEventTemplate: import('nostr-tools').EventTemplate }): Promise<{ hash: string; index: number; version: number; parsed: Article }> {
+  const { extractTagsFromEvent } = await import('../nostrTagSystem')
+  const tags = extractTagsFromEvent(params.deleteEventTemplate)
+  const version = tags.version ?? params.originalParsed.version + 1
+  const index = params.originalParsed.index ?? 0
+  const parsed: Article = { ...params.originalParsed, version }
+  return { hash: params.originalParsed.hash, index, version, parsed }
+}
+
+async function finalizeEventTemplate(params: { template: import('nostr-tools').EventTemplate; authorPrivateKey: string | undefined }): Promise<import('nostr-tools').Event> {
+  const privateKey = params.authorPrivateKey ?? nostrService.getPrivateKey()
+  if (!privateKey) {
+    throw new Error('Private key required for signing')
+  }
+  const { writeOrchestrator } = await import('../writeOrchestrator')
+  writeOrchestrator.setPrivateKey(privateKey)
+  const { finalizeEvent } = await import('nostr-tools')
+  const { hexToBytes } = await import('nostr-tools/utils')
+  return finalizeEvent(params.template, hexToBytes(privateKey))
+}
+
+async function publishDeletion(params: {
+  event: import('nostr-tools').Event
+  relays: string[]
+  payload: { hash: string; index: number; version: number; parsed: Article }
+}): Promise<void> {
+  const { writeOrchestrator } = await import('../writeOrchestrator')
+  const result = await writeOrchestrator.writeAndPublish(
+    { objectType: 'publication', hash: params.payload.hash, event: params.event, parsed: params.payload.parsed, version: params.payload.version, hidden: true, index: params.payload.index },
+    params.relays
+  )
+  if (!result.success) {
+    throw new Error('Failed to publish delete event')
+  }
+}
diff --git a/lib/articleMutations/index.ts b/lib/articleMutations/index.ts
new file mode 100644
index 0000000..87e0ffe
--- /dev/null
+++ b/lib/articleMutations/index.ts
@@ -0,0 +1,5 @@
+export type { ArticleUpdateResult } from './types'
+export { publishSeries } from './series'
+export { publishReview } from './review'
+export { publishArticleUpdate } from './update'
+export { deleteArticleEvent } from './delete'
diff --git a/lib/articleMutations/publicationPreview.ts b/lib/articleMutations/publicationPreview.ts
new file mode 100644
index 0000000..42c1f00
--- /dev/null
+++ b/lib/articleMutations/publicationPreview.ts
@@ -0,0 +1,57 @@
+import { createPreviewEvent } from '../articleInvoice'
+import type { ArticleDraft } from '../articlePublisher'
+import type { AlbyInvoice } from '@/types/alby'
+import type { Article } from '@/types/nostr'
+import { finalizeEvent } from 'nostr-tools'
+import { hexToBytes } from 'nostr-tools/utils'
+import { buildParsedArticleFromDraft as buildParsedArticleFromDraftCore } from '../articleDraftToParsedArticle'
+import { getPublishRelays } from '../relaySelection'
+import { writeOrchestrator } from '../writeOrchestrator'
+import { getPrivateKeyForSigning } from './shared'
+
+export async function buildParsedArticleFromDraft(
+  draft: ArticleDraft,
+  invoice: AlbyInvoice,
+  authorPubkey: string
+): Promise<{ article: Article; hash: string; version: number; index: number }> {
+  return buildParsedArticleFromDraftCore({ draft, invoice, authorPubkey })
+}
+
+export interface PublishPreviewWithInvoiceParams {
+  draft: ArticleDraft
+  invoice: AlbyInvoice
+  authorPubkey: string
+  presentationId: string
+  extraTags?: string[][]
+  customArticle?: Article
+}
+
+export async function publishPreviewWithInvoice(params: PublishPreviewWithInvoiceParams): Promise<import('nostr-tools').Event | null> {
+  const payload = await resolvePublicationPayload(params)
+  const previewEventTemplate = await createPreviewEvent({
+    draft: params.draft,
+    invoice: params.invoice,
+    authorPubkey: params.authorPubkey,
+    authorPresentationId: params.presentationId,
+    ...(params.extraTags ? { extraTags: params.extraTags } : {}),
+  })
+  const privateKey = getPrivateKeyForSigning(undefined)
+  const event = finalizeEvent(previewEventTemplate, hexToBytes(privateKey))
+  return publishPublicationToRelays({ event, payload })
+}
+
+async function resolvePublicationPayload(params: PublishPreviewWithInvoiceParams): Promise<{ article: Article; hash: string; version: number; index: number }> {
+  if (params.customArticle) {
+    return { article: params.customArticle, hash: params.customArticle.hash, version: params.customArticle.version, index: params.customArticle.index ?? 0 }
+  }
+  return buildParsedArticleFromDraft(params.draft, params.invoice, params.authorPubkey)
+}
+
+async function publishPublicationToRelays(params: { event: import('nostr-tools').Event; payload: { article: Article; hash: string; version: number; index: number } }): Promise<import('nostr-tools').Event | null> {
+  const relays = await getPublishRelays()
+  const result = await writeOrchestrator.writeAndPublish(
+    { objectType: 'publication', hash: params.payload.hash, event: params.event, parsed: params.payload.article, version: params.payload.version, hidden: false, index: params.payload.index },
+    relays
+  )
+  return result.success ? params.event : null
+}
diff --git a/lib/articleMutations/review.ts b/lib/articleMutations/review.ts
new file mode 100644
index 0000000..814892d
--- /dev/null
+++ b/lib/articleMutations/review.ts
@@ -0,0 +1,133 @@
+import type { ArticleDraft } from '../articlePublisher'
+import type { Review } from '@/types/nostr'
+import { buildTags } from '../nostrTagSystem'
+import { PLATFORM_SERVICE } from '../platformConfig'
+import { buildObjectId } from '../urlGenerator'
+import { getPublishRelays } from '../relaySelection'
+import { writeOrchestrator } from '../writeOrchestrator'
+import { finalizeEvent, type EventTemplate } from 'nostr-tools'
+import { hexToBytes } from 'nostr-tools/utils'
+import { ensureKeys, getPrivateKeyForSigning, mapDraftCategoryToTag, requireCategory } from './shared'
+
+export async function publishReview(params: {
+  articleId: string
+  seriesId: string
+  category: ArticleDraft['category']
+  authorPubkey: string
+  reviewerPubkey: string
+  content: string
+  title?: string
+  text?: string
+  authorPrivateKey?: string
+}): Promise<Review> {
+  ensureKeys(params.reviewerPubkey, params.authorPrivateKey)
+  requireCategory(params.category)
+  const hash = await buildReviewHashId({ reviewerPubkey: params.reviewerPubkey, articleId: params.articleId, content: params.content, ...(params.title ? { title: params.title } : {}) })
+  const parsedReview = buildParsedReview({ params, hash, version: 0, index: 0 })
+  const eventTemplate = await buildReviewEvent(params, params.category)
+  const privateKey = getPrivateKeyForSigning(params.authorPrivateKey)
+  const event = finalizeEvent(eventTemplate, hexToBytes(privateKey))
+  await publishReviewToRelays({ parsedReview, event })
+  return parsedReview
+}
+
+function buildParsedReview(params: {
+  params: { articleId: string; authorPubkey: string; reviewerPubkey: string; content: string; title?: string; text?: string }
+  hash: string
+  version: number
+  index: number
+}): Review {
+  return {
+    id: buildObjectId(params.hash, params.index, params.version),
+    hash: params.hash,
+    version: params.version,
+    index: params.index,
+    articleId: params.params.articleId,
+    authorPubkey: params.params.authorPubkey,
+    reviewerPubkey: params.params.reviewerPubkey,
+    content: params.params.content,
+    description: params.params.content.substring(0, 200),
+    createdAt: Math.floor(Date.now() / 1000),
+    ...(params.params.title ? { title: params.params.title } : {}),
+    ...(params.params.text ? { text: params.params.text } : {}),
+    kindType: 'review',
+  }
+}
+
+async function publishReviewToRelays(params: { parsedReview: Review; event: import('nostr-tools').Event }): Promise<void> {
+  const relays = await getPublishRelays()
+  const result = await writeOrchestrator.writeAndPublish(
+    { objectType: 'review', hash: params.parsedReview.hash, event: params.event, parsed: params.parsedReview, version: params.parsedReview.version, hidden: false, index: params.parsedReview.index },
+    relays
+  )
+  if (!result.success) {
+    throw new Error('Failed to publish review')
+  }
+}
+
+async function buildReviewEvent(
+  params: { articleId: string; seriesId: string; authorPubkey: string; reviewerPubkey: string; content: string; title?: string; text?: string },
+  category: NonNullable<ArticleDraft['category']>
+): Promise<Pick<EventTemplate, 'kind' | 'created_at' | 'content' | 'tags'>> {
+  const ctx = await buildReviewEventContext(params, category)
+  return { kind: 1, created_at: Math.floor(Date.now() / 1000), content: params.content, tags: ctx.tags }
+}
+
+async function buildReviewEventContext(
+  params: { articleId: string; reviewerPubkey: string; content: string; title?: string; text?: string },
+  category: NonNullable<ArticleDraft['category']>
+): Promise<{ tags: string[][] }> {
+  const newCategory = mapDraftCategoryToTag(category)
+  const hashId = await buildReviewHashId({ reviewerPubkey: params.reviewerPubkey, articleId: params.articleId, content: params.content, ...(params.title ? { title: params.title } : {}) })
+  const reviewJson = buildReviewJson({ reviewerPubkey: params.reviewerPubkey, articleId: params.articleId, content: params.content, ...(params.title ? { title: params.title } : {}), newCategory, hashId })
+  const tags = buildReviewTags({ newCategory, hashId, articleId: params.articleId, reviewerPubkey: params.reviewerPubkey, ...(params.title ? { title: params.title } : {}), ...(params.text ? { text: params.text } : {}), reviewJson })
+  return { tags }
+}
+
+async function buildReviewHashId(params: { reviewerPubkey: string; articleId: string; content: string; title?: string }): Promise<string> {
+  const { generateReviewHashId } = await import('../hashIdGenerator')
+  return generateReviewHashId({ pubkey: params.reviewerPubkey, articleId: params.articleId, reviewerPubkey: params.reviewerPubkey, content: params.content, ...(params.title ? { title: params.title } : {}) })
+}
+
+function buildReviewJson(params: { reviewerPubkey: string; articleId: string; content: string; title?: string; newCategory: 'sciencefiction' | 'research'; hashId: string }): string {
+  return JSON.stringify({
+    type: 'review',
+    pubkey: params.reviewerPubkey,
+    articleId: params.articleId,
+    reviewerPubkey: params.reviewerPubkey,
+    content: params.content,
+    title: params.title,
+    category: params.newCategory,
+    id: params.hashId,
+    version: 0,
+    index: 0,
+  })
+}
+
+function buildReviewTags(params: {
+  newCategory: 'sciencefiction' | 'research'
+  hashId: string
+  articleId: string
+  reviewerPubkey: string
+  title?: string
+  text?: string
+  reviewJson: string
+}): string[][] {
+  const tags = buildTags({
+    type: 'quote',
+    category: params.newCategory,
+    id: params.hashId,
+    service: PLATFORM_SERVICE,
+    version: 0,
+    hidden: false,
+    paywall: false,
+    articleId: params.articleId,
+    reviewerPubkey: params.reviewerPubkey,
+    ...(params.title ? { title: params.title } : {}),
+  })
+  if (params.text) {
+    tags.push(['text', params.text])
+  }
+  tags.push(['json', params.reviewJson])
+  return tags
+}
diff --git a/lib/articleMutations/series.ts b/lib/articleMutations/series.ts
new file mode 100644
index 0000000..56b3e9e
--- /dev/null
+++ b/lib/articleMutations/series.ts
@@ -0,0 +1,143 @@
+import { buildTags } from '../nostrTagSystem'
+import { PLATFORM_SERVICE } from '../platformConfig'
+import { generateSeriesHashId } from '../hashIdGenerator'
+import { buildObjectId } from '../urlGenerator'
+import type { ArticleDraft } from '../articlePublisher'
+import type { Series } from '@/types/nostr'
+import { getPublishRelays } from '../relaySelection'
+import { writeOrchestrator } from '../writeOrchestrator'
+import { finalizeEvent } from 'nostr-tools'
+import { hexToBytes } from 'nostr-tools/utils'
+import type { EventTemplate } from 'nostr-tools'
+import { ensureKeys, getPrivateKeyForSigning, mapDraftCategoryToTag, requireCategory } from './shared'
+
+export async function publishSeries(params: {
+  title: string
+  description: string
+  preview?: string
+  coverUrl?: string
+  category: ArticleDraft['category']
+  authorPubkey: string
+  authorPrivateKey?: string
+}): Promise<Series> {
+  ensureKeys(params.authorPubkey, params.authorPrivateKey)
+  const ctx = await buildSeriesPublishContext(params)
+  const event = finalizeEvent(ctx.eventTemplate, hexToBytes(getPrivateKeyForSigning(params.authorPrivateKey)))
+  await publishSeriesToRelays({ parsedSeries: ctx.parsedSeries, event })
+  return ctx.parsedSeries
+}
+
+function buildSeriesPreview(preview: string | undefined, description: string): string {
+  return preview ?? description.substring(0, 200)
+}
+
+async function buildSeriesPublishContext(params: {
+  title: string
+  description: string
+  preview?: string
+  coverUrl?: string
+  category: ArticleDraft['category']
+  authorPubkey: string
+}): Promise<{ parsedSeries: Series; eventTemplate: EventTemplate }> {
+  requireCategory(params.category)
+  const newCategory = mapDraftCategoryToTag(params.category)
+  const preview = buildSeriesPreview(params.preview, params.description)
+  const hashId = await generateSeriesHashId({
+    pubkey: params.authorPubkey,
+    title: params.title,
+    description: params.description,
+    category: newCategory,
+    ...(params.coverUrl ? { coverUrl: params.coverUrl } : {}),
+  })
+  const parsedSeries = buildParsedSeries({ authorPubkey: params.authorPubkey, title: params.title, description: params.description, preview, coverUrl: params.coverUrl, category: params.category, hashId })
+  const eventTemplate = buildSeriesEventTemplate({ authorPubkey: params.authorPubkey, title: params.title, description: params.description, preview, coverUrl: params.coverUrl, category: newCategory, hashId })
+  return { parsedSeries, eventTemplate }
+}
+
+async function publishSeriesToRelays(params: { parsedSeries: Series; event: import('nostr-tools').Event }): Promise<void> {
+  const relays = await getPublishRelays()
+  const result = await writeOrchestrator.writeAndPublish(
+    { objectType: 'series', hash: params.parsedSeries.hash, event: params.event, parsed: params.parsedSeries, version: params.parsedSeries.version, hidden: false, index: params.parsedSeries.index },
+    relays
+  )
+  if (!result.success) {
+    throw new Error('Failed to publish series')
+  }
+}
+
+function buildParsedSeries(params: {
+  authorPubkey: string
+  title: string
+  description: string
+  preview: string
+  coverUrl: string | undefined
+  category: NonNullable<ArticleDraft['category']>
+  hashId: string
+}): Series {
+  const hash = params.hashId
+  const version = 0
+  const index = 0
+  return {
+    id: buildObjectId(hash, index, version),
+    hash,
+    version,
+    index,
+    pubkey: params.authorPubkey,
+    title: params.title,
+    description: params.description,
+    preview: params.preview,
+    thumbnailUrl: params.coverUrl ?? '',
+    category: params.category,
+    ...(params.coverUrl ? { coverUrl: params.coverUrl } : {}),
+    kindType: 'series',
+  }
+}
+
+function buildSeriesEventTemplate(params: {
+  authorPubkey: string
+  title: string
+  description: string
+  preview: string
+  coverUrl: string | undefined
+  category: 'sciencefiction' | 'research'
+  hashId: string
+}): EventTemplate {
+  const tags = buildTags({
+    type: 'series',
+    category: params.category,
+    id: params.hashId,
+    service: PLATFORM_SERVICE,
+    version: 0,
+    hidden: false,
+    paywall: false,
+    title: params.title,
+    description: params.description,
+    preview: params.preview,
+    ...(params.coverUrl ? { coverUrl: params.coverUrl } : {}),
+  })
+  tags.push(['json', buildSeriesJson(params)])
+  return { kind: 1, created_at: Math.floor(Date.now() / 1000), content: params.preview, tags }
+}
+
+function buildSeriesJson(params: {
+  authorPubkey: string
+  title: string
+  description: string
+  preview: string
+  coverUrl: string | undefined
+  category: 'sciencefiction' | 'research'
+  hashId: string
+}): string {
+  return JSON.stringify({
+    type: 'series',
+    pubkey: params.authorPubkey,
+    title: params.title,
+    description: params.description,
+    preview: params.preview,
+    ...(params.coverUrl ? { coverUrl: params.coverUrl } : {}),
+    category: params.category,
+    id: params.hashId,
+    version: 0,
+    index: 0,
+  })
+}
diff --git a/lib/articleMutations/shared.ts b/lib/articleMutations/shared.ts
new file mode 100644
index 0000000..7fa05e8
--- /dev/null
+++ b/lib/articleMutations/shared.ts
@@ -0,0 +1,40 @@
+import { nostrService } from '../nostr'
+import type { ArticleDraft } from '../articlePublisher'
+import { writeOrchestrator } from '../writeOrchestrator'
+
+export function ensureKeys(authorPubkey: string, authorPrivateKey?: string): void {
+  nostrService.setPublicKey(authorPubkey)
+  if (authorPrivateKey) {
+    nostrService.setPrivateKey(authorPrivateKey)
+  } else if (!nostrService.getPrivateKey()) {
+    throw new Error('Private key required for signing. Connect a wallet that can sign.')
+  }
+}
+
+export function requireCategory(category?: ArticleDraft['category']): asserts category is NonNullable<ArticleDraft['category']> {
+  if (category !== 'science-fiction' && category !== 'scientific-research') {
+    throw new Error('Vous devez sélectionner une catégorie (science-fiction ou recherche scientifique).')
+  }
+}
+
+export async function ensurePresentation(authorPubkey: string): Promise<string> {
+  const { articlePublisher } = await import('../articlePublisher')
+  const presentation = await articlePublisher.getAuthorPresentation(authorPubkey)
+  if (!presentation) {
+    throw new Error('Vous devez créer un article de présentation avant de publier des articles.')
+  }
+  return presentation.id
+}
+
+export function mapDraftCategoryToTag(category: NonNullable<ArticleDraft['category']>): 'sciencefiction' | 'research' {
+  return category === 'science-fiction' ? 'sciencefiction' : 'research'
+}
+
+export function getPrivateKeyForSigning(authorPrivateKey: string | undefined): string {
+  const privateKey = authorPrivateKey ?? nostrService.getPrivateKey()
+  if (!privateKey) {
+    throw new Error('Private key required for signing')
+  }
+  writeOrchestrator.setPrivateKey(privateKey)
+  return privateKey
+}
diff --git a/lib/articleMutations/types.ts b/lib/articleMutations/types.ts
new file mode 100644
index 0000000..2cc4c37
--- /dev/null
+++ b/lib/articleMutations/types.ts
@@ -0,0 +1,5 @@
+import type { PublishedArticle } from '../articlePublisher'
+
+export interface ArticleUpdateResult extends PublishedArticle {
+  originalArticleId: string
+}
diff --git a/lib/articleMutations/update.ts b/lib/articleMutations/update.ts
new file mode 100644
index 0000000..9f0babe
--- /dev/null
+++ b/lib/articleMutations/update.ts
@@ -0,0 +1,100 @@
+import type { ArticleDraft } from '../articlePublisher'
+import type { AlbyInvoice } from '@/types/alby'
+import type { Article } from '@/types/nostr'
+import { createArticleInvoice } from '../articleInvoice'
+import { storePrivateContent } from '../articleStorage'
+import { buildTags } from '../nostrTagSystem'
+import { PLATFORM_SERVICE } from '../platformConfig'
+import { generatePublicationHashId } from '../hashIdGenerator'
+import { ensureKeys, ensurePresentation, mapDraftCategoryToTag, requireCategory } from './shared'
+import { buildParsedArticleFromDraft, publishPreviewWithInvoice } from './publicationPreview'
+import type { ArticleUpdateResult } from './types'
+
+export async function publishArticleUpdate(
+  originalArticleId: string,
+  draft: ArticleDraft,
+  authorPubkey: string,
+  authorPrivateKey?: string
+): Promise<ArticleUpdateResult> {
+  try {
+    ensureKeys(authorPubkey, authorPrivateKey)
+    return publishUpdate(draft, authorPubkey, originalArticleId)
+  } catch (error) {
+    return updateFailure(originalArticleId, error instanceof Error ? error.message : 'Unknown error')
+  }
+}
+
+async function publishUpdate(draft: ArticleDraft, authorPubkey: string, originalArticleId: string): Promise<ArticleUpdateResult> {
+  requireCategory(draft.category)
+  const originalArticle = await loadOriginalArticleForUpdate(originalArticleId)
+  if (!originalArticle) {
+    return updateFailure(originalArticleId, 'Original article not found in cache')
+  }
+  if (originalArticle.pubkey !== authorPubkey) {
+    return updateFailure(originalArticleId, 'Only the author can update this article')
+  }
+
+  const presentationId = await ensurePresentation(authorPubkey)
+  const invoice = await createArticleInvoice(draft)
+  const newCategory = mapDraftCategoryToTag(draft.category)
+  const currentVersion = originalArticle.version ?? 0
+
+  const updateTags = await buildUpdateTags({ draft, originalArticleId, newCategory, authorPubkey, currentVersion })
+  const updatedArticle = await buildUpdatedArticleForUpdate({ draft, invoice, authorPubkey, currentVersion })
+  const publishedEvent = await publishPreviewWithInvoice({ draft, invoice, authorPubkey, presentationId, extraTags: updateTags, customArticle: updatedArticle })
+  if (!publishedEvent) {
+    return updateFailure(originalArticleId, 'Failed to publish article update')
+  }
+  await storePrivateContent({ articleId: publishedEvent.id, content: draft.content, authorPubkey, invoice })
+  return { articleId: publishedEvent.id, previewEventId: publishedEvent.id, invoice, success: true, originalArticleId }
+}
+
+async function buildUpdateTags(params: {
+  draft: ArticleDraft
+  originalArticleId: string
+  newCategory: 'sciencefiction' | 'research'
+  authorPubkey: string
+  currentVersion?: number
+}): Promise<string[][]> {
+  const hashId = await generatePublicationHashId({
+    pubkey: params.authorPubkey,
+    title: params.draft.title,
+    preview: params.draft.preview,
+    category: params.newCategory,
+    seriesId: params.draft.seriesId ?? undefined,
+    bannerUrl: params.draft.bannerUrl ?? undefined,
+    zapAmount: params.draft.zapAmount,
+  })
+  const currentVersion = params.currentVersion ?? 0
+  const nextVersion = currentVersion + 1
+  const updateTags = buildTags({
+    type: 'publication',
+    category: params.newCategory,
+    id: hashId,
+    service: PLATFORM_SERVICE,
+    version: nextVersion,
+    hidden: false,
+    paywall: true,
+    title: params.draft.title,
+    preview: params.draft.preview,
+    zapAmount: params.draft.zapAmount,
+    ...(params.draft.seriesId ? { seriesId: params.draft.seriesId } : {}),
+    ...(params.draft.bannerUrl ? { bannerUrl: params.draft.bannerUrl } : {}),
+  })
+  updateTags.push(['e', params.originalArticleId], ['replace', 'article-update'])
+  return updateTags
+}
+
+async function loadOriginalArticleForUpdate(originalArticleId: string): Promise<Article | null> {
+  const { objectCache } = await import('../objectCache')
+  return (await objectCache.getById('publication', originalArticleId)) as Article | null
+}
+
+async function buildUpdatedArticleForUpdate(params: { draft: ArticleDraft; invoice: AlbyInvoice; authorPubkey: string; currentVersion: number }): Promise<Article> {
+  const { article } = await buildParsedArticleFromDraft(params.draft, params.invoice, params.authorPubkey)
+  return { ...article, version: params.currentVersion + 1 }
+}
+
+function updateFailure(originalArticleId: string, error?: string): ArticleUpdateResult {
+  return { articleId: '', previewEventId: '', success: false, originalArticleId, ...(error ? { error } : {}) }
+}
diff --git a/lib/articlePublisher.ts b/lib/articlePublisher.ts
index 9513e54..47075a5 100644
--- a/lib/articlePublisher.ts
+++ b/lib/articlePublisher.ts
@@ -1,16 +1,14 @@
 import { nostrService } from './nostr'
 import type { AlbyInvoice } from '@/types/alby'
 import { getStoredPrivateContent, getStoredInvoice, removeStoredPrivateContent } from './articleStorage'
-import { buildPresentationEvent, sendEncryptedContent } from './articlePublisherHelpers'
+import { sendEncryptedContent } from './articlePublisherHelpers'
 import type { ArticleDraft, AuthorPresentationDraft, PublishedArticle } from './articlePublisherTypes'
 import { prepareAuthorKeys, isValidCategory, type PublishValidationResult } from './articlePublisherValidation'
 import { buildFailure, encryptAndPublish } from './articlePublisherPublish'
 import { writeOrchestrator } from './writeOrchestrator'
-import { finalizeEvent } from 'nostr-tools'
+import { finalizeEvent, type Event, type EventTemplate } from 'nostr-tools'
 import { hexToBytes } from 'nostr-tools/utils'
-import { generateAuthorHashId } from './hashIdGenerator'
-import { buildObjectId } from './urlGenerator'
-import { extractAuthorNameFromTitle, parseAuthorPresentationDraft } from './authorPresentationParsing'
+import { buildPresentationPublishContext, getActiveRelaysOrPrimary } from './articlePublisherPresentationHelpers'
 
 export type { ArticleDraft, AuthorPresentationDraft, PublishedArticle } from './articlePublisherTypes'
 
@@ -215,114 +213,27 @@ async function publishPresentationArticleCore(params: {
   authorPubkey: string
   authorPrivateKey: string
 }): Promise<PublishedArticle> {
-  nostrService.setPublicKey(params.authorPubkey)
-  nostrService.setPrivateKey(params.authorPrivateKey)
-
-  const authorName = extractAuthorNameFromTitle(params.draft.title)
-  const { presentation, contentDescription } = parseAuthorPresentationDraft(params.draft)
-
-  const category = 'sciencefiction'
-  const version = 0
-  const index = 0
-
-  const hashId = await generateAuthorHashId({
-    pubkey: params.authorPubkey,
-    authorName,
-    presentation,
-    contentDescription,
-    mainnetAddress: params.draft.mainnetAddress ?? undefined,
-    pictureUrl: params.draft.pictureUrl ?? undefined,
-    category,
-  })
-
-  const hash = hashId
-  const id = buildObjectId(hash, index, version)
-
-  const parsedAuthor = buildParsedAuthorPresentation({
-    draft: params.draft,
-    authorPubkey: params.authorPubkey,
-    id,
-    hash,
-    version,
-    index,
-    presentation,
-    contentDescription,
-  })
-
-  const eventTemplate = await buildPresentationEvent({
-    draft: params.draft,
-    authorPubkey: params.authorPubkey,
-    authorName,
-    category,
-    version,
-    index,
-  })
-
+  initializeAuthorKeys({ authorPubkey: params.authorPubkey, authorPrivateKey: params.authorPrivateKey })
+  const ctx = await buildPresentationPublishContext({ draft: params.draft, authorPubkey: params.authorPubkey })
+  const event = finalizeEventFromTemplate({ eventTemplate: ctx.eventTemplate, authorPrivateKey: params.authorPrivateKey })
   writeOrchestrator.setPrivateKey(params.authorPrivateKey)
-  const secretKey = hexToBytes(params.authorPrivateKey)
-  const event = finalizeEvent(eventTemplate, secretKey)
 
   const relays = await getActiveRelaysOrPrimary()
   const result = await writeOrchestrator.writeAndPublish(
-    {
-      objectType: 'author',
-      hash,
-      event,
-      parsed: parsedAuthor,
-      version,
-      hidden: false,
-      index,
-    },
+    { objectType: 'author', hash: ctx.hash, event, parsed: ctx.parsedAuthor, version: ctx.version, hidden: false, index: ctx.index },
     relays
   )
-
-  if (!result.success) {
-    return buildFailure('Failed to publish presentation article')
-  }
-
-  return { articleId: event.id, previewEventId: event.id, success: true }
+  return result.success ? { articleId: event.id, previewEventId: event.id, success: true } : buildFailure('Failed to publish presentation article')
 }
 
-function buildParsedAuthorPresentation(params: {
-  draft: AuthorPresentationDraft
-  authorPubkey: string
-  id: string
-  hash: string
-  version: number
-  index: number
-  presentation: string
-  contentDescription: string
-}): import('@/types/nostr').AuthorPresentationArticle {
-  return {
-    id: params.id,
-    hash: params.hash,
-    version: params.version,
-    index: params.index,
-    pubkey: params.authorPubkey,
-    title: params.draft.title,
-    preview: params.draft.preview,
-    content: params.draft.content,
-    description: params.presentation,
-    contentDescription: params.contentDescription,
-    thumbnailUrl: params.draft.pictureUrl ?? '',
-    createdAt: Math.floor(Date.now() / 1000),
-    zapAmount: 0,
-    paid: true,
-    category: 'author-presentation',
-    isPresentation: true,
-    mainnetAddress: params.draft.mainnetAddress ?? '',
-    totalSponsoring: 0,
-    originalCategory: 'science-fiction',
-    ...(params.draft.pictureUrl ? { bannerUrl: params.draft.pictureUrl } : {}),
-  }
+function initializeAuthorKeys(params: { authorPubkey: string; authorPrivateKey: string }): void {
+  nostrService.setPublicKey(params.authorPubkey)
+  nostrService.setPrivateKey(params.authorPrivateKey)
 }
 
-async function getActiveRelaysOrPrimary(): Promise<string[]> {
-  const { relaySessionManager } = await import('./relaySessionManager')
-  const activeRelays = await relaySessionManager.getActiveRelays()
-  if (activeRelays.length > 0) {
-    return activeRelays
-  }
-  const { getPrimaryRelay } = await import('./config')
-  return [await getPrimaryRelay()]
+function finalizeEventFromTemplate(params: { eventTemplate: EventTemplate; authorPrivateKey: string }): Event {
+  const secretKey = hexToBytes(params.authorPrivateKey)
+  return finalizeEvent(params.eventTemplate, secretKey)
 }
+
+// moved to `articlePublisherPresentationHelpers.ts`
diff --git a/lib/articlePublisherHelpersPresentation.ts b/lib/articlePublisherHelpersPresentation.ts
index e01b11f..670e3ac 100644
--- a/lib/articlePublisherHelpersPresentation.ts
+++ b/lib/articlePublisherHelpersPresentation.ts
@@ -1,518 +1,3 @@
-import { type Event } from 'nostr-tools'
-import { nip19 } from 'nostr-tools'
-import type { AuthorPresentationDraft } from './articlePublisher'
-import type { SimplePoolWithSub } from '@/types/nostr-tools-extended'
-import { createSubscription } from '@/types/nostr-tools-extended'
-import { buildTags, extractTagsFromEvent, buildTagFilter } from './nostrTagSystem'
-import { getPrimaryRelaySync } from './config'
-import { PLATFORM_SERVICE, MIN_EVENT_DATE } from './platformConfig'
-import { generateAuthorHashId } from './hashIdGenerator'
-import { generateObjectUrl, buildObjectId, parseObjectId } from './urlGenerator'
-import { getLatestVersion } from './versionManager'
-import { objectCache } from './objectCache'
-import { parseAuthorPresentationDraft } from './authorPresentationParsing'
-
-interface BuildPresentationEventParams {
-  draft: AuthorPresentationDraft
-  authorPubkey: string
-  authorName: string
-  category?: 'sciencefiction' | 'research'
-  version?: number
-  index?: number
-}
-
-export async function buildPresentationEvent(
-  params: BuildPresentationEventParams
-): Promise<{
-  kind: 1
-  created_at: number
-  tags: string[][]
-  content: string
-}> {
-  const category = params.category ?? 'sciencefiction'
-  const version = params.version ?? 0
-  const index = params.index ?? 0
-
-  const { presentation, contentDescription } = parseAuthorPresentationDraft(params.draft)
-
-  // Generate hash ID from author data first (needed for URL)
-  const hashId = await generateAuthorHashId({
-    pubkey: params.authorPubkey,
-    authorName: params.authorName,
-    presentation,
-    contentDescription,
-    mainnetAddress: params.draft.mainnetAddress ?? undefined,
-    pictureUrl: params.draft.pictureUrl ?? undefined,
-    category,
-  })
-
-  // Build URL: https://zapwall.fr/author/<hash>_<index>_<version> (using hash ID)
-  const profileUrl = generateObjectUrl('author', hashId, index, version)
-
-  // Encode pubkey to npub (for metadata JSON)
-  const npub = nip19.npubEncode(params.authorPubkey)
-
-  const linkWithPreview = buildProfileLink({
-    profileUrl,
-    authorName: params.authorName,
-    pictureUrl: params.draft.pictureUrl,
-  })
-
-  const visibleContent = [
-    'Nouveau profil auteur publié sur zapwall.fr (plateforme de publications scientifiques)',
-    linkWithPreview,
-    `Présentation personnelle : ${presentation}`,
-    ...(contentDescription ? [`Description de votre contenu : ${contentDescription}`] : []),
-  ].join('\n')
-
-  // Build profile JSON for metadata (stored in tag, not in content)
-  const profileJson = JSON.stringify({
-    authorName: params.authorName,
-    npub,
-    pubkey: params.authorPubkey,
-    presentation,
-    contentDescription,
-    mainnetAddress: params.draft.mainnetAddress,
-    pictureUrl: params.draft.pictureUrl,
-    category,
-    url: profileUrl,
-    version,
-    index,
-  })
-
-  // Build tags (profile JSON is in tag, not in content)
-  const tags = buildTags({
-    type: 'author',
-    category,
-    id: hashId,
-    service: PLATFORM_SERVICE,
-    version,
-    hidden: false,
-    paywall: false,
-    title: params.draft.title,
-    preview: params.draft.preview,
-    mainnetAddress: params.draft.mainnetAddress,
-    ...(params.draft.pictureUrl ? { pictureUrl: params.draft.pictureUrl } : {}),
-  })
-
-  // Add JSON metadata as a tag (not in visible content)
-  tags.push(['json', profileJson])
-
-  return {
-    kind: 1 as const,
-    created_at: Math.floor(Date.now() / 1000),
-    tags,
-    content: visibleContent,
-  }
-}
-
-function buildProfileLink(params: { profileUrl: string; authorName: string; pictureUrl: string | undefined }): string {
-  if (params.pictureUrl) {
-    return `[![${params.authorName}](${params.pictureUrl})](${params.profileUrl})`
-  }
-  return params.profileUrl
-}
-
-export async function parsePresentationEvent(event: Event): Promise<import('@/types/nostr').AuthorPresentationArticle | null> {
-  const tags = extractTagsFromEvent(event)
-
-  // Check if it's an author type (tag is 'author' in English)
-  if (tags.type !== 'author') {
-    return null
-  }
-
-  const profileData = readPresentationProfileData(tags.json, event.content)
-  const originalCategory = mapTagCategoryToOriginalCategory(tags.category)
-  const { hash, version, index } = await resolvePresentationIdParts({ tags, event, profileData })
-  const id = buildObjectId(hash, index, version)
-
-  return buildPresentationArticle({
-    id,
-    hash,
-    version,
-    index,
-    event,
-    tags,
-    profileData,
-    originalCategory,
-  })
-}
-
-type PresentationProfileData = {
-  authorName?: string
-  presentation?: string
-  contentDescription?: string
-  mainnetAddress?: string
-  pictureUrl?: string
-  category?: string
-}
-
-function readPresentationProfileData(jsonTag: string | undefined, content: string): PresentationProfileData | null {
-  if (jsonTag) {
-    return parsePresentationProfileJson(jsonTag)
-  }
-
-  // Backward compatibility: invisible format (with zero-width characters)
-  const invisibleJsonMatch = content.match(/[\u200B\u200C]\[Metadata JSON\][\u200B\u200C]\n[\u200B\u200C](.+)[\u200B\u200C]$/s)
-  if (invisibleJsonMatch?.[1]) {
-    try {
-      const cleanedJson = invisibleJsonMatch[1].replace(/[\u200B\u200C\u200D\u200E\u200F]/g, '').trim()
-      return parsePresentationProfileJson(cleanedJson)
-    } catch (invisibleJsonError) {
-      console.error('Error parsing profile JSON from invisible content:', invisibleJsonError)
-    }
-  }
-
-  // Backward compatibility: visible format
-  const jsonMatch = content.match(/\[Metadata JSON\]\n(.+)$/s)
-  if (jsonMatch?.[1]) {
-    return parsePresentationProfileJson(jsonMatch[1].trim())
-  }
-
-  return null
-}
-
-function mapTagCategoryToOriginalCategory(category: unknown): 'science-fiction' | 'scientific-research' | undefined {
-  if (category === 'sciencefiction') {
-    return 'science-fiction'
-  }
-  if (category === 'research') {
-    return 'scientific-research'
-  }
-  return undefined
-}
-
-async function resolvePresentationIdParts(params: {
-  tags: ReturnType<typeof extractTagsFromEvent>
-  event: Event
-  profileData: PresentationProfileData | null
-}): Promise<{ hash: string; version: number; index: number }> {
-  const version = typeof params.tags.version === 'number' ? params.tags.version : 0
-  const index = 0
-
-  const fromIdTag = resolvePresentationIdPartsFromIdTag(params.tags.id, version, index)
-  if (fromIdTag) {
-    return fromIdTag
-  }
-
-  const mainnetAddress = resolvePresentationMainnetAddressCandidate(params.profileData, params.tags)
-  const pictureUrl = resolvePresentationPictureUrlCandidate(params.profileData, params.tags)
-
-  const hash = await generateAuthorHashId({
-    pubkey: params.event.pubkey,
-    authorName: resolveOptionalString(params.profileData?.authorName),
-    presentation: resolveOptionalString(params.profileData?.presentation),
-    contentDescription: resolveOptionalString(params.profileData?.contentDescription),
-    mainnetAddress,
-    pictureUrl,
-    category: resolvePresentationHashCategory(params.profileData, params.tags),
-  })
-
-  return { hash, version, index }
-}
-
-function resolvePresentationIdPartsFromIdTag(
-  idTag: string | undefined,
-  defaultVersion: number,
-  defaultIndex: number
-): { hash: string; version: number; index: number } | undefined {
-  if (!idTag) {
-    return undefined
-  }
-
-  const parsed = parseObjectId(idTag)
-  if (parsed.hash) {
-    return {
-      hash: parsed.hash,
-      version: parsed.version ?? defaultVersion,
-      index: parsed.index ?? defaultIndex,
-    }
-  }
-
-  return { hash: idTag, version: defaultVersion, index: defaultIndex }
-}
-
-function buildPresentationArticle(params: {
-  id: string
-  hash: string
-  version: number
-  index: number
-  event: Event
-  tags: ReturnType<typeof extractTagsFromEvent>
-  profileData: PresentationProfileData | null
-  originalCategory: 'science-fiction' | 'scientific-research' | undefined
-}): import('@/types/nostr').AuthorPresentationArticle {
-  const description = resolvePresentationDescription(params.profileData, params.tags)
-  const contentDescription = sanitizePresentationContentDescription(resolvePresentationContentDescriptionRaw(params.profileData, params.tags))
-  const thumbnailUrl = resolvePresentationThumbnailUrl(params.profileData, params.tags)
-  const mainnetAddress = resolvePresentationMainnetAddress(params.profileData, params.tags)
-  const bannerUrl = resolvePresentationBannerUrl(params.profileData, params.tags)
-  const title = resolvePresentationTitle(params.tags)
-  const preview = resolvePresentationPreview(params.tags, params.event.content)
-
-  return {
-    id: params.id,
-    hash: params.hash,
-    version: params.version,
-    index: params.index,
-    pubkey: params.event.pubkey,
-    title,
-    preview,
-    content: params.event.content,
-    description,
-    contentDescription,
-    thumbnailUrl,
-    createdAt: params.event.created_at,
-    zapAmount: 0,
-    paid: true,
-    category: 'author-presentation',
-    isPresentation: true,
-    mainnetAddress,
-    totalSponsoring: 0,
-    originalCategory: params.originalCategory ?? 'science-fiction',
-    ...(bannerUrl ? { bannerUrl } : {}),
-  }
-}
-
-function resolvePresentationTitle(tags: ReturnType<typeof extractTagsFromEvent>): string {
-  return typeof tags.title === 'string' && tags.title.length > 0 ? tags.title : 'Présentation'
-}
-
-function resolvePresentationPreview(tags: ReturnType<typeof extractTagsFromEvent>, content: string): string {
-  if (typeof tags.preview === 'string' && tags.preview.length > 0) {
-    return tags.preview
-  }
-  return content.substring(0, 200)
-}
-
-function resolvePresentationDescription(profileData: PresentationProfileData | null, tags: ReturnType<typeof extractTagsFromEvent>): string {
-  if (typeof profileData?.presentation === 'string') {
-    return profileData.presentation
-  }
-  return typeof tags.description === 'string' ? tags.description : ''
-}
-
-function resolvePresentationContentDescriptionRaw(profileData: PresentationProfileData | null, tags: ReturnType<typeof extractTagsFromEvent>): string {
-  if (typeof profileData?.contentDescription === 'string') {
-    return profileData.contentDescription
-  }
-  return typeof tags.description === 'string' ? tags.description : ''
-}
-
-function resolveOptionalString(value: unknown): string {
-  return typeof value === 'string' ? value : ''
-}
-
-function resolvePresentationMainnetAddressCandidate(
-  profileData: PresentationProfileData | null,
-  tags: ReturnType<typeof extractTagsFromEvent>
-): string | undefined {
-  if (typeof profileData?.mainnetAddress === 'string') {
-    return profileData.mainnetAddress
-  }
-  return typeof tags.mainnetAddress === 'string' ? tags.mainnetAddress : undefined
-}
-
-function resolvePresentationPictureUrlCandidate(
-  profileData: PresentationProfileData | null,
-  tags: ReturnType<typeof extractTagsFromEvent>
-): string | undefined {
-  if (typeof profileData?.pictureUrl === 'string') {
-    return profileData.pictureUrl
-  }
-  return typeof tags.pictureUrl === 'string' ? tags.pictureUrl : undefined
-}
-
-function resolvePresentationHashCategory(profileData: PresentationProfileData | null, tags: ReturnType<typeof extractTagsFromEvent>): string {
-  if (typeof profileData?.category === 'string') {
-    return profileData.category
-  }
-  return typeof tags.category === 'string' ? tags.category : 'sciencefiction'
-}
-
-function sanitizePresentationContentDescription(raw: string): string {
-  return raw
-    .split('\n')
-    .filter((line) => !line.includes('Adresse Bitcoin mainnet (pour le sponsoring)'))
-    .join('\n')
-    .trim()
-}
-
-function resolvePresentationThumbnailUrl(profileData: PresentationProfileData | null, tags: ReturnType<typeof extractTagsFromEvent>): string {
-  if (typeof profileData?.pictureUrl === 'string') {
-    return profileData.pictureUrl
-  }
-  return typeof tags.pictureUrl === 'string' ? tags.pictureUrl : ''
-}
-
-function resolvePresentationBannerUrl(profileData: PresentationProfileData | null, tags: ReturnType<typeof extractTagsFromEvent>): string | undefined {
-  if (typeof profileData?.pictureUrl === 'string' && profileData.pictureUrl.length > 0) {
-    return profileData.pictureUrl
-  }
-  return typeof tags.pictureUrl === 'string' ? tags.pictureUrl : undefined
-}
-
-function resolvePresentationMainnetAddress(profileData: PresentationProfileData | null, tags: ReturnType<typeof extractTagsFromEvent>): string {
-  const fromProfile = profileData?.mainnetAddress
-  if (typeof fromProfile === 'string') {
-    return fromProfile
-  }
-  return typeof tags.mainnetAddress === 'string' ? tags.mainnetAddress : ''
-}
-
-function parsePresentationProfileJson(json: string): {
-  authorName?: string
-  presentation?: string
-  contentDescription?: string
-  mainnetAddress?: string
-  pictureUrl?: string
-  category?: string
-} | null {
-  try {
-    const parsed: unknown = JSON.parse(json)
-    if (typeof parsed !== 'object' || parsed === null) {
-      return null
-    }
-
-    const obj = parsed as Record<string, unknown>
-    return {
-      ...readOptionalStringFields(obj, [
-        'authorName',
-        'presentation',
-        'contentDescription',
-        'mainnetAddress',
-        'pictureUrl',
-        'category',
-      ]),
-    }
-  } catch (error) {
-    console.error('Error parsing presentation profile JSON:', error)
-    return null
-  }
-}
-
-function readOptionalStringFields<TKeys extends readonly string[]>(
-  obj: Record<string, unknown>,
-  keys: TKeys
-): Partial<Record<TKeys[number], string>> {
-  const result: Partial<Record<TKeys[number], string>> = {}
-  for (const key of keys as ReadonlyArray<TKeys[number]>) {
-    const value = obj[key]
-    if (typeof value === 'string') {
-      result[key] = value
-    }
-  }
-  return result
-}
-
-export async function fetchAuthorPresentationFromPool(
-  pool: SimplePoolWithSub,
-  pubkey: string
-): Promise<import('@/types/nostr').AuthorPresentationArticle | null> {
-  // Check cache first - this is the primary source
-  const cached = await objectCache.getAuthorByPubkey(pubkey)
-  if (cached) {
-    // Calculate totalSponsoring from cache
-    const { getAuthorSponsoring } = await import('./sponsoring')
-    cached.totalSponsoring = await getAuthorSponsoring(pubkey)
-    return cached
-  }
-
-  const filters = [
-    {
-      ...buildTagFilter({
-        type: 'author',
-        authorPubkey: pubkey,
-        service: PLATFORM_SERVICE,
-      }),
-      since: MIN_EVENT_DATE,
-      limit: 100, // Get all versions to find the latest
-    },
-  ]
-
-  return new Promise<import('@/types/nostr').AuthorPresentationArticle | null>((resolve) => {
-    let resolved = false
-    const relayUrl = getPrimaryRelaySync()
-    const sub = createSubscription(pool, [relayUrl], filters)
-
-    const events: Event[] = []
-
-    const finalize = async (value: import('@/types/nostr').AuthorPresentationArticle | null): Promise<void> => {
-      if (resolved) {
-        return
-      }
-      resolved = true
-      sub.unsub()
-
-      // Cache the result if found
-      if (value && events.length > 0) {
-        const event = events.find((e) => e.id === value.id) ?? events[0]
-        if (event) {
-          const tags = extractTagsFromEvent(event)
-          if (value.hash) {
-            // Calculate totalSponsoring from cache before storing
-            const { getAuthorSponsoring } = await import('./sponsoring')
-            const totalSponsoring = await getAuthorSponsoring(value.pubkey)
-            const cachedValue: import('@/types/nostr').AuthorPresentationArticle = {
-              ...value,
-              totalSponsoring,
-            }
-            const { writeObjectToCache } = await import('./helpers/writeObjectHelper')
-            await writeObjectToCache({
-              objectType: 'author',
-              hash: value.hash,
-              event,
-              parsed: cachedValue,
-              version: tags.version,
-              hidden: tags.hidden,
-              index: value.index,
-            })
-
-            resolve(cachedValue)
-            return
-          }
-        }
-      }
-
-      resolve(value)
-    }
-
-    sub.on('event', (event: Event): void => {
-      // Collect all events first
-      const tags = extractTagsFromEvent(event)
-      if (tags.type === 'author' && !tags.hidden) {
-        events.push(event)
-      }
-    })
-
-    sub.on('eose', (): void => {
-      void (async (): Promise<void> => {
-        // Get the latest version from all collected events
-        const latestEvent = getLatestVersion(events)
-        if (latestEvent) {
-          const parsed = await parsePresentationEvent(latestEvent)
-          if (parsed) {
-            await finalize(parsed)
-            return
-          }
-        }
-        await finalize(null)
-      })()
-    })
-    // Reduced timeout for faster feedback when cache is empty
-    setTimeout((): void => {
-      void (async (): Promise<void> => {
-      // Get the latest version from all collected events
-      const latestEvent = getLatestVersion(events)
-      if (latestEvent) {
-        const parsed = await parsePresentationEvent(latestEvent)
-        if (parsed) {
-          await finalize(parsed)
-          return
-        }
-      }
-      await finalize(null)
-      })()
-    }, 2000).unref?.()
-  })
-}
+export { buildPresentationEvent } from './articlePublisherHelpersPresentation/buildPresentationEvent'
+export { parsePresentationEvent } from './articlePublisherHelpersPresentation/parsePresentationEvent'
+export { fetchAuthorPresentationFromPool } from './articlePublisherHelpersPresentation/fetchAuthorPresentationFromPool'
diff --git a/lib/articlePublisherHelpersPresentation/articleBuilder.ts b/lib/articlePublisherHelpersPresentation/articleBuilder.ts
new file mode 100644
index 0000000..59e7344
--- /dev/null
+++ b/lib/articlePublisherHelpersPresentation/articleBuilder.ts
@@ -0,0 +1,102 @@
+import type { Event } from 'nostr-tools'
+import { extractTagsFromEvent } from '../nostrTagSystem'
+import type { PresentationProfileData } from './profileJson'
+
+type ExtractedTags = ReturnType<typeof extractTagsFromEvent>
+
+export function buildPresentationArticle(params: {
+  id: string
+  hash: string
+  version: number
+  index: number
+  event: Event
+  tags: ExtractedTags
+  profileData: PresentationProfileData | null
+  originalCategory: 'science-fiction' | 'scientific-research' | undefined
+}): import('@/types/nostr').AuthorPresentationArticle {
+  const description = resolvePresentationDescription(params.profileData, params.tags)
+  const contentDescription = sanitizePresentationContentDescription(resolvePresentationContentDescriptionRaw(params.profileData, params.tags))
+  const thumbnailUrl = resolvePresentationThumbnailUrl(params.profileData, params.tags)
+  const mainnetAddress = resolvePresentationMainnetAddress(params.profileData, params.tags)
+  const bannerUrl = resolvePresentationBannerUrl(params.profileData, params.tags)
+  const title = resolvePresentationTitle(params.tags)
+  const preview = resolvePresentationPreview(params.tags, params.event.content)
+
+  return {
+    id: params.id,
+    hash: params.hash,
+    version: params.version,
+    index: params.index,
+    pubkey: params.event.pubkey,
+    title,
+    preview,
+    content: params.event.content,
+    description,
+    contentDescription,
+    thumbnailUrl,
+    createdAt: params.event.created_at,
+    zapAmount: 0,
+    paid: true,
+    category: 'author-presentation',
+    isPresentation: true,
+    mainnetAddress,
+    totalSponsoring: 0,
+    originalCategory: params.originalCategory ?? 'science-fiction',
+    ...(bannerUrl ? { bannerUrl } : {}),
+  }
+}
+
+function resolvePresentationTitle(tags: ExtractedTags): string {
+  return typeof tags.title === 'string' && tags.title.length > 0 ? tags.title : 'Présentation'
+}
+
+function resolvePresentationPreview(tags: ExtractedTags, content: string): string {
+  if (typeof tags.preview === 'string' && tags.preview.length > 0) {
+    return tags.preview
+  }
+  return content.substring(0, 200)
+}
+
+function resolvePresentationDescription(profileData: PresentationProfileData | null, tags: ExtractedTags): string {
+  if (typeof profileData?.presentation === 'string') {
+    return profileData.presentation
+  }
+  return typeof tags.description === 'string' ? tags.description : ''
+}
+
+function resolvePresentationContentDescriptionRaw(profileData: PresentationProfileData | null, tags: ExtractedTags): string {
+  if (typeof profileData?.contentDescription === 'string') {
+    return profileData.contentDescription
+  }
+  return typeof tags.description === 'string' ? tags.description : ''
+}
+
+function sanitizePresentationContentDescription(raw: string): string {
+  return raw
+    .split('\n')
+    .filter((line) => !line.includes('Adresse Bitcoin mainnet (pour le sponsoring)'))
+    .join('\n')
+    .trim()
+}
+
+function resolvePresentationThumbnailUrl(profileData: PresentationProfileData | null, tags: ExtractedTags): string {
+  if (typeof profileData?.pictureUrl === 'string') {
+    return profileData.pictureUrl
+  }
+  return typeof tags.pictureUrl === 'string' ? tags.pictureUrl : ''
+}
+
+function resolvePresentationBannerUrl(profileData: PresentationProfileData | null, tags: ExtractedTags): string | undefined {
+  if (typeof profileData?.pictureUrl === 'string' && profileData.pictureUrl.length > 0) {
+    return profileData.pictureUrl
+  }
+  return typeof tags.pictureUrl === 'string' ? tags.pictureUrl : undefined
+}
+
+function resolvePresentationMainnetAddress(profileData: PresentationProfileData | null, tags: ExtractedTags): string {
+  const fromProfile = profileData?.mainnetAddress
+  if (typeof fromProfile === 'string') {
+    return fromProfile
+  }
+  return typeof tags.mainnetAddress === 'string' ? tags.mainnetAddress : ''
+}
diff --git a/lib/articlePublisherHelpersPresentation/buildPresentationEvent.ts b/lib/articlePublisherHelpersPresentation/buildPresentationEvent.ts
new file mode 100644
index 0000000..d2b175f
--- /dev/null
+++ b/lib/articlePublisherHelpersPresentation/buildPresentationEvent.ts
@@ -0,0 +1,148 @@
+import { nip19 } from 'nostr-tools'
+import type { AuthorPresentationDraft } from '../articlePublisher'
+import { buildTags } from '../nostrTagSystem'
+import { PLATFORM_SERVICE } from '../platformConfig'
+import { generateAuthorHashId } from '../hashIdGenerator'
+import { generateObjectUrl } from '../urlGenerator'
+import { parseAuthorPresentationDraft } from '../authorPresentationParsing'
+
+interface BuildPresentationEventParams {
+  draft: AuthorPresentationDraft
+  authorPubkey: string
+  authorName: string
+  category?: 'sciencefiction' | 'research'
+  version?: number
+  index?: number
+}
+
+export async function buildPresentationEvent(
+  params: BuildPresentationEventParams
+): Promise<{ kind: 1; created_at: number; tags: string[][]; content: string }> {
+  const { category, version, index } = normalizeBuildPresentationEventParams(params)
+  const parsedDraft = parseAuthorPresentationDraft(params.draft)
+  const hashId = await generateAuthorHashIdForPresentation({
+    authorPubkey: params.authorPubkey,
+    authorName: params.authorName,
+    parsedDraft,
+    mainnetAddress: params.draft.mainnetAddress,
+    pictureUrl: params.draft.pictureUrl,
+    category,
+  })
+  const profileUrl = generateObjectUrl('author', hashId, index, version)
+  const visibleContent = buildPresentationVisibleContent({
+    profileUrl,
+    authorName: params.authorName,
+    pictureUrl: params.draft.pictureUrl,
+    presentation: parsedDraft.presentation,
+    contentDescription: parsedDraft.contentDescription,
+  })
+  const profileJson = buildPresentationProfileJson({
+    authorPubkey: params.authorPubkey,
+    authorName: params.authorName,
+    profileUrl,
+    presentation: parsedDraft.presentation,
+    contentDescription: parsedDraft.contentDescription,
+    mainnetAddress: params.draft.mainnetAddress,
+    pictureUrl: params.draft.pictureUrl,
+    category,
+    version,
+    index,
+  })
+  const tags = buildPresentationTags({ draft: params.draft, category, hashId, version, profileJson })
+  return { kind: 1 as const, created_at: Math.floor(Date.now() / 1000), tags, content: visibleContent }
+}
+
+function normalizeBuildPresentationEventParams(params: BuildPresentationEventParams): { category: 'sciencefiction' | 'research'; version: number; index: number } {
+  return { category: params.category ?? 'sciencefiction', version: params.version ?? 0, index: params.index ?? 0 }
+}
+
+async function generateAuthorHashIdForPresentation(params: {
+  authorPubkey: string
+  authorName: string
+  parsedDraft: { presentation: string; contentDescription: string }
+  mainnetAddress: string | undefined
+  pictureUrl: string | undefined
+  category: 'sciencefiction' | 'research'
+}): Promise<string> {
+  return generateAuthorHashId({
+    pubkey: params.authorPubkey,
+    authorName: params.authorName,
+    presentation: params.parsedDraft.presentation,
+    contentDescription: params.parsedDraft.contentDescription,
+    mainnetAddress: params.mainnetAddress ?? undefined,
+    pictureUrl: params.pictureUrl ?? undefined,
+    category: params.category,
+  })
+}
+
+function buildPresentationVisibleContent(params: {
+  profileUrl: string
+  authorName: string
+  pictureUrl: string | undefined
+  presentation: string
+  contentDescription: string
+}): string {
+  const linkWithPreview = buildProfileLink({ profileUrl: params.profileUrl, authorName: params.authorName, pictureUrl: params.pictureUrl })
+  const lines = [
+    'Nouveau profil auteur publié sur zapwall.fr (plateforme de publications scientifiques)',
+    linkWithPreview,
+    `Présentation personnelle : ${params.presentation}`,
+  ]
+  if (params.contentDescription) {
+    lines.push(`Description de votre contenu : ${params.contentDescription}`)
+  }
+  return lines.join('\n')
+}
+
+function buildPresentationProfileJson(params: {
+  authorPubkey: string
+  authorName: string
+  profileUrl: string
+  presentation: string
+  contentDescription: string
+  mainnetAddress: string | undefined
+  pictureUrl: string | undefined
+  category: 'sciencefiction' | 'research'
+  version: number
+  index: number
+}): string {
+  const npub = nip19.npubEncode(params.authorPubkey)
+  return JSON.stringify({
+    authorName: params.authorName,
+    npub,
+    pubkey: params.authorPubkey,
+    presentation: params.presentation,
+    contentDescription: params.contentDescription,
+    mainnetAddress: params.mainnetAddress,
+    pictureUrl: params.pictureUrl,
+    category: params.category,
+    url: params.profileUrl,
+    version: params.version,
+    index: params.index,
+  })
+}
+
+function buildPresentationTags(params: { draft: AuthorPresentationDraft; category: 'sciencefiction' | 'research'; hashId: string; version: number; profileJson: string }): string[][] {
+  const tags = buildTags({
+    type: 'author',
+    category: params.category,
+    id: params.hashId,
+    service: PLATFORM_SERVICE,
+    version: params.version,
+    hidden: false,
+    paywall: false,
+    title: params.draft.title,
+    preview: params.draft.preview,
+    mainnetAddress: params.draft.mainnetAddress,
+    ...(params.draft.pictureUrl ? { pictureUrl: params.draft.pictureUrl } : {}),
+  })
+  tags.push(['json', params.profileJson])
+  return tags
+}
+
+function buildProfileLink(params: { profileUrl: string; authorName: string; pictureUrl: string | undefined }): string {
+  if (params.pictureUrl) {
+    return `[![${params.authorName}](${params.pictureUrl})](${params.profileUrl})`
+  }
+  return params.profileUrl
+}
diff --git a/lib/articlePublisherHelpersPresentation/fetchAuthorPresentationFromPool.ts b/lib/articlePublisherHelpersPresentation/fetchAuthorPresentationFromPool.ts
new file mode 100644
index 0000000..cab1d1f
--- /dev/null
+++ b/lib/articlePublisherHelpersPresentation/fetchAuthorPresentationFromPool.ts
@@ -0,0 +1,122 @@
+import type { Event, Filter } from 'nostr-tools'
+import type { SimplePoolWithSub } from '@/types/nostr-tools-extended'
+import { createSubscription } from '@/types/nostr-tools-extended'
+import { buildTagFilter, extractTagsFromEvent } from '../nostrTagSystem'
+import { getPrimaryRelaySync } from '../config'
+import { MIN_EVENT_DATE, PLATFORM_SERVICE } from '../platformConfig'
+import { getLatestVersion } from '../versionManager'
+import { objectCache } from '../objectCache'
+import { parsePresentationEvent } from './parsePresentationEvent'
+
+export async function fetchAuthorPresentationFromPool(
+  pool: SimplePoolWithSub,
+  pubkey: string
+): Promise<import('@/types/nostr').AuthorPresentationArticle | null> {
+  const cached = await objectCache.getAuthorByPubkey(pubkey)
+  if (cached) {
+    return enrichAuthorPresentationWithSponsoring({ author: cached, pubkey })
+  }
+  const filters: Filter[] = [
+    {
+      ...buildTagFilter({ type: 'author', authorPubkey: pubkey, service: PLATFORM_SERVICE }),
+      since: MIN_EVENT_DATE,
+      limit: 100,
+    },
+  ]
+  return fetchAuthorPresentationFromRelay({ pool, pubkey, filters })
+}
+
+async function enrichAuthorPresentationWithSponsoring(params: {
+  author: import('@/types/nostr').AuthorPresentationArticle
+  pubkey: string
+}): Promise<import('@/types/nostr').AuthorPresentationArticle> {
+  const { getAuthorSponsoring } = await import('../sponsoring')
+  const totalSponsoring = await getAuthorSponsoring(params.pubkey)
+  return { ...params.author, totalSponsoring }
+}
+
+async function fetchAuthorPresentationFromRelay(params: {
+  pool: SimplePoolWithSub
+  pubkey: string
+  filters: Filter[]
+}): Promise<import('@/types/nostr').AuthorPresentationArticle | null> {
+  const relayUrl = getPrimaryRelaySync()
+  const events: Event[] = []
+  const sub = createSubscription(params.pool, [relayUrl], params.filters)
+  const finalize = createRelayFetchFinalizer({ pubkey: params.pubkey, sub, events })
+
+  return new Promise<import('@/types/nostr').AuthorPresentationArticle | null>((resolve) => {
+    const finalizeAndResolve = async (value: import('@/types/nostr').AuthorPresentationArticle | null): Promise<void> => {
+      const finalValue = await finalize(value)
+      resolve(finalValue)
+    }
+    sub.on('event', (event: Event): void => {
+      const tags = extractTagsFromEvent(event)
+      if (tags.type === 'author' && !tags.hidden) {
+        events.push(event)
+      }
+    })
+    sub.on('eose', (): void => {
+      void tryFinalizeFromLatestEvent({ events, finalize: finalizeAndResolve })
+    })
+    setTimeout((): void => {
+      void tryFinalizeFromLatestEvent({ events, finalize: finalizeAndResolve })
+    }, 2000).unref?.()
+  })
+}
+
+async function tryFinalizeFromLatestEvent(params: {
+  events: Event[]
+  finalize: (value: import('@/types/nostr').AuthorPresentationArticle | null) => Promise<void>
+}): Promise<void> {
+  const latestEvent = getLatestVersion(params.events)
+  if (!latestEvent) {
+    await params.finalize(null)
+    return
+  }
+  const parsed = await parsePresentationEvent(latestEvent)
+  await params.finalize(parsed)
+}
+
+function createRelayFetchFinalizer(params: {
+  pubkey: string
+  sub: import('@/types/nostr-tools-extended').Subscription
+  events: Event[]
+}): (value: import('@/types/nostr').AuthorPresentationArticle | null) => Promise<import('@/types/nostr').AuthorPresentationArticle | null> {
+  let resolved = false
+  return async (value: import('@/types/nostr').AuthorPresentationArticle | null): Promise<import('@/types/nostr').AuthorPresentationArticle | null> => {
+    if (resolved) {
+      return value
+    }
+    resolved = true
+    params.sub.unsub()
+    return cacheAuthorPresentationFromEvents({ value, events: params.events, pubkey: params.pubkey })
+  }
+}
+
+async function cacheAuthorPresentationFromEvents(params: {
+  value: import('@/types/nostr').AuthorPresentationArticle | null
+  events: Event[]
+  pubkey: string
+}): Promise<import('@/types/nostr').AuthorPresentationArticle | null> {
+  if (!params.value || params.events.length === 0 || !params.value.hash) {
+    return params.value
+  }
+  const event = params.events.find((e) => e.id === params.value?.id) ?? params.events[0]
+  if (!event) {
+    return params.value
+  }
+  const tags = extractTagsFromEvent(event)
+  const cachedValue = await enrichAuthorPresentationWithSponsoring({ author: params.value, pubkey: params.pubkey })
+  const { writeObjectToCache } = await import('../helpers/writeObjectHelper')
+  await writeObjectToCache({
+    objectType: 'author',
+    hash: params.value.hash,
+    event,
+    parsed: cachedValue,
+    version: tags.version,
+    hidden: tags.hidden,
+    index: params.value.index,
+  })
+  return cachedValue
+}
diff --git a/lib/articlePublisherHelpersPresentation/idResolution.ts b/lib/articlePublisherHelpersPresentation/idResolution.ts
new file mode 100644
index 0000000..d31f9f8
--- /dev/null
+++ b/lib/articlePublisherHelpersPresentation/idResolution.ts
@@ -0,0 +1,97 @@
+import type { Event } from 'nostr-tools'
+import { generateAuthorHashId } from '../hashIdGenerator'
+import { parseObjectId } from '../urlGenerator'
+import { extractTagsFromEvent } from '../nostrTagSystem'
+import type { PresentationProfileData } from './profileJson'
+
+type ExtractedTags = ReturnType<typeof extractTagsFromEvent>
+
+export function mapTagCategoryToOriginalCategory(category: unknown): 'science-fiction' | 'scientific-research' | undefined {
+  if (category === 'sciencefiction') {
+    return 'science-fiction'
+  }
+  if (category === 'research') {
+    return 'scientific-research'
+  }
+  return undefined
+}
+
+export async function resolvePresentationIdParts(params: {
+  tags: ExtractedTags
+  event: Event
+  profileData: PresentationProfileData | null
+}): Promise<{ hash: string; version: number; index: number }> {
+  const version = typeof params.tags.version === 'number' ? params.tags.version : 0
+  const index = 0
+
+  const fromIdTag = resolvePresentationIdPartsFromIdTag(params.tags.id, version, index)
+  if (fromIdTag) {
+    return fromIdTag
+  }
+
+  const mainnetAddress = resolvePresentationMainnetAddressCandidate(params.profileData, params.tags)
+  const pictureUrl = resolvePresentationPictureUrlCandidate(params.profileData, params.tags)
+
+  const hash = await generateAuthorHashId({
+    pubkey: params.event.pubkey,
+    authorName: resolveOptionalString(params.profileData?.authorName),
+    presentation: resolveOptionalString(params.profileData?.presentation),
+    contentDescription: resolveOptionalString(params.profileData?.contentDescription),
+    mainnetAddress,
+    pictureUrl,
+    category: resolvePresentationHashCategory(params.profileData, params.tags),
+  })
+
+  return { hash, version, index }
+}
+
+function resolvePresentationIdPartsFromIdTag(
+  idTag: string | undefined,
+  defaultVersion: number,
+  defaultIndex: number
+): { hash: string; version: number; index: number } | undefined {
+  if (!idTag) {
+    return undefined
+  }
+
+  const parsed = parseObjectId(idTag)
+  if (parsed.hash) {
+    return { hash: parsed.hash, version: parsed.version ?? defaultVersion, index: parsed.index ?? defaultIndex }
+  }
+
+  return { hash: idTag, version: defaultVersion, index: defaultIndex }
+}
+
+function resolveOptionalString(value: unknown): string {
+  return typeof value === 'string' ? value : ''
+}
+
+function resolvePresentationMainnetAddressCandidate(
+  profileData: PresentationProfileData | null,
+  tags: ExtractedTags
+): string | undefined {
+  if (typeof profileData?.mainnetAddress === 'string') {
+    return profileData.mainnetAddress
+  }
+  return typeof tags.mainnetAddress === 'string' ? tags.mainnetAddress : undefined
+}
+
+function resolvePresentationPictureUrlCandidate(
+  profileData: PresentationProfileData | null,
+  tags: ExtractedTags
+): string | undefined {
+  if (typeof profileData?.pictureUrl === 'string') {
+    return profileData.pictureUrl
+  }
+  return typeof tags.pictureUrl === 'string' ? tags.pictureUrl : undefined
+}
+
+function resolvePresentationHashCategory(
+  profileData: PresentationProfileData | null,
+  tags: ExtractedTags
+): string {
+  if (typeof profileData?.category === 'string') {
+    return profileData.category
+  }
+  return typeof tags.category === 'string' ? tags.category : 'sciencefiction'
+}
diff --git a/lib/articlePublisherHelpersPresentation/parsePresentationEvent.ts b/lib/articlePublisherHelpersPresentation/parsePresentationEvent.ts
new file mode 100644
index 0000000..55c1892
--- /dev/null
+++ b/lib/articlePublisherHelpersPresentation/parsePresentationEvent.ts
@@ -0,0 +1,18 @@
+import type { Event } from 'nostr-tools'
+import { extractTagsFromEvent } from '../nostrTagSystem'
+import { buildObjectId } from '../urlGenerator'
+import { readPresentationProfileData } from './profileData'
+import { mapTagCategoryToOriginalCategory, resolvePresentationIdParts } from './idResolution'
+import { buildPresentationArticle } from './articleBuilder'
+
+export async function parsePresentationEvent(event: Event): Promise<import('@/types/nostr').AuthorPresentationArticle | null> {
+  const tags = extractTagsFromEvent(event)
+  if (tags.type !== 'author') {
+    return null
+  }
+  const profileData = readPresentationProfileData(tags.json, event.content)
+  const originalCategory = mapTagCategoryToOriginalCategory(tags.category)
+  const { hash, version, index } = await resolvePresentationIdParts({ tags, event, profileData })
+  const id = buildObjectId(hash, index, version)
+  return buildPresentationArticle({ id, hash, version, index, event, tags, profileData, originalCategory })
+}
diff --git a/lib/articlePublisherHelpersPresentation/profileData.ts b/lib/articlePublisherHelpersPresentation/profileData.ts
new file mode 100644
index 0000000..0105d0e
--- /dev/null
+++ b/lib/articlePublisherHelpersPresentation/profileData.ts
@@ -0,0 +1,26 @@
+import { parsePresentationProfileJson, type PresentationProfileData } from './profileJson'
+
+export function readPresentationProfileData(jsonTag: string | undefined, content: string): PresentationProfileData | null {
+  if (jsonTag) {
+    return parsePresentationProfileJson(jsonTag)
+  }
+
+  // Backward compatibility: invisible format (with zero-width characters)
+  const invisibleJsonMatch = content.match(/[\u200B\u200C]\[Metadata JSON\][\u200B\u200C]\n[\u200B\u200C](.+)[\u200B\u200C]$/s)
+  if (invisibleJsonMatch?.[1]) {
+    try {
+      const cleanedJson = invisibleJsonMatch[1].replace(/[\u200B\u200C\u200D\u200E\u200F]/g, '').trim()
+      return parsePresentationProfileJson(cleanedJson)
+    } catch (invisibleJsonError) {
+      console.error('Error parsing profile JSON from invisible content:', invisibleJsonError)
+    }
+  }
+
+  // Backward compatibility: visible format
+  const jsonMatch = content.match(/\[Metadata JSON\]\n(.+)$/s)
+  if (jsonMatch?.[1]) {
+    return parsePresentationProfileJson(jsonMatch[1].trim())
+  }
+
+  return null
+}
diff --git a/lib/articlePublisherHelpersPresentation/profileJson.ts b/lib/articlePublisherHelpersPresentation/profileJson.ts
new file mode 100644
index 0000000..4e42ff0
--- /dev/null
+++ b/lib/articlePublisherHelpersPresentation/profileJson.ts
@@ -0,0 +1,38 @@
+export type PresentationProfileData = {
+  authorName?: string
+  presentation?: string
+  contentDescription?: string
+  mainnetAddress?: string
+  pictureUrl?: string
+  category?: string
+}
+
+export function parsePresentationProfileJson(json: string): PresentationProfileData | null {
+  try {
+    const parsed: unknown = JSON.parse(json)
+    if (typeof parsed !== 'object' || parsed === null) {
+      return null
+    }
+    const obj = parsed as Record<string, unknown>
+    return {
+      ...readOptionalStringFields(obj, ['authorName', 'presentation', 'contentDescription', 'mainnetAddress', 'pictureUrl', 'category']),
+    }
+  } catch (error) {
+    console.error('Error parsing presentation profile JSON:', error)
+    return null
+  }
+}
+
+function readOptionalStringFields<TKeys extends readonly string[]>(
+  obj: Record<string, unknown>,
+  keys: TKeys
+): Partial<Record<TKeys[number], string>> {
+  const result: Partial<Record<TKeys[number], string>> = {}
+  for (const key of keys as ReadonlyArray<TKeys[number]>) {
+    const value = obj[key]
+    if (typeof value === 'string') {
+      result[key] = value
+    }
+  }
+  return result
+}
diff --git a/lib/articlePublisherPresentationHelpers.ts b/lib/articlePublisherPresentationHelpers.ts
new file mode 100644
index 0000000..31a6650
--- /dev/null
+++ b/lib/articlePublisherPresentationHelpers.ts
@@ -0,0 +1,91 @@
+import type { AuthorPresentationDraft } from './articlePublisherTypes'
+import { buildPresentationEvent } from './articlePublisherHelpers'
+import { generateAuthorHashId } from './hashIdGenerator'
+import { buildObjectId } from './urlGenerator'
+import { extractAuthorNameFromTitle, parseAuthorPresentationDraft } from './authorPresentationParsing'
+import type { EventTemplate } from 'nostr-tools'
+
+export async function buildPresentationPublishContext(params: {
+  draft: AuthorPresentationDraft
+  authorPubkey: string
+}): Promise<{
+  hash: string
+  version: number
+  index: number
+  parsedAuthor: import('@/types/nostr').AuthorPresentationArticle
+  eventTemplate: EventTemplate
+}> {
+  const authorName = extractAuthorNameFromTitle(params.draft.title)
+  const { presentation, contentDescription } = parseAuthorPresentationDraft(params.draft)
+  const category = 'sciencefiction'
+  const version = 0
+  const index = 0
+
+  const hash = await generateAuthorHashId({
+    pubkey: params.authorPubkey,
+    authorName,
+    presentation,
+    contentDescription,
+    mainnetAddress: params.draft.mainnetAddress ?? undefined,
+    pictureUrl: params.draft.pictureUrl ?? undefined,
+    category,
+  })
+  const id = buildObjectId(hash, index, version)
+
+  const parsedAuthor = buildParsedAuthorPresentation({
+    draft: params.draft,
+    authorPubkey: params.authorPubkey,
+    id,
+    hash,
+    version,
+    index,
+    presentation,
+    contentDescription,
+  })
+  const eventTemplate = await buildPresentationEvent({ draft: params.draft, authorPubkey: params.authorPubkey, authorName, category, version, index })
+  return { hash, version, index, parsedAuthor, eventTemplate }
+}
+
+function buildParsedAuthorPresentation(params: {
+  draft: AuthorPresentationDraft
+  authorPubkey: string
+  id: string
+  hash: string
+  version: number
+  index: number
+  presentation: string
+  contentDescription: string
+}): import('@/types/nostr').AuthorPresentationArticle {
+  return {
+    id: params.id,
+    hash: params.hash,
+    version: params.version,
+    index: params.index,
+    pubkey: params.authorPubkey,
+    title: params.draft.title,
+    preview: params.draft.preview,
+    content: params.draft.content,
+    description: params.presentation,
+    contentDescription: params.contentDescription,
+    thumbnailUrl: params.draft.pictureUrl ?? '',
+    createdAt: Math.floor(Date.now() / 1000),
+    zapAmount: 0,
+    paid: true,
+    category: 'author-presentation',
+    isPresentation: true,
+    mainnetAddress: params.draft.mainnetAddress ?? '',
+    totalSponsoring: 0,
+    originalCategory: 'science-fiction',
+    ...(params.draft.pictureUrl ? { bannerUrl: params.draft.pictureUrl } : {}),
+  }
+}
+
+export async function getActiveRelaysOrPrimary(): Promise<string[]> {
+  const { relaySessionManager } = await import('./relaySessionManager')
+  const activeRelays = await relaySessionManager.getActiveRelays()
+  if (activeRelays.length > 0) {
+    return activeRelays
+  }
+  const { getPrimaryRelay } = await import('./config')
+  return [await getPrimaryRelay()]
+}
diff --git a/lib/helpers/indexedDBHelper.ts b/lib/helpers/indexedDBHelper.ts
index 1fe06d2..e727be0 100644
--- a/lib/helpers/indexedDBHelper.ts
+++ b/lib/helpers/indexedDBHelper.ts
@@ -1,616 +1 @@
-/**
- * Centralized IndexedDB helper for initialization and transaction management
- * Provides unified API for all IndexedDB operations across the application
- */
-
-export interface IndexedDBIndex {
-  name: string
-  keyPath: string | string[]
-  unique?: boolean
-}
-
-export interface IndexedDBConfig {
-  dbName: string
-  version: number
-  storeName: string
-  keyPath: string
-  indexes?: IndexedDBIndex[]
-  onUpgrade?: (db: IDBDatabase, event: IDBVersionChangeEvent) => void
-}
-
-export class IndexedDBError extends Error {
-  public readonly operation: string
-  public readonly storeName: string | undefined
-  public override readonly cause: unknown
-
-  public override readonly name = 'IndexedDBError'
-
-  constructor(message: string, operation: string, storeName?: string, cause?: unknown) {
-    super(message)
-    this.operation = operation
-    this.storeName = storeName
-    this.cause = cause
-    console.error(`[IndexedDBError] ${operation}${storeName ? ` on ${storeName}` : ''}: ${message}`, cause)
-  }
-}
-
-class IndexedDBHelper {
-  private db: IDBDatabase | null = null
-  private initPromise: Promise<void> | null = null
-  private readonly config: IndexedDBConfig
-
-  constructor(config: IndexedDBConfig) {
-    this.config = config
-  }
-
-  /**
-   * Initialize the IndexedDB database
-   */
-  async init(): Promise<IDBDatabase> {
-    if (this.db) {
-      return this.db
-    }
-
-    if (this.initPromise) {
-      await this.initPromise
-      if (this.db) {
-        return this.db
-      }
-      throw new IndexedDBError('Database initialization failed', 'init', this.config.storeName)
-    }
-
-    this.initPromise = this.openDatabase()
-
-    try {
-      await this.initPromise
-      if (!this.db) {
-        throw new IndexedDBError('Database not initialized after open', 'init', this.config.storeName)
-      }
-      return this.db
-    } catch (error) {
-      this.initPromise = null
-      throw new IndexedDBError(
-        error instanceof Error ? error.message : 'Unknown error',
-        'init',
-        this.config.storeName,
-        error
-      )
-    }
-  }
-
-  private openDatabase(): Promise<void> {
-    return new Promise((resolve, reject) => {
-      if (typeof window === 'undefined' || !window.indexedDB) {
-        reject(new IndexedDBError('IndexedDB is not available', 'openDatabase', this.config.storeName))
-        return
-      }
-
-      const request = window.indexedDB.open(this.config.dbName, this.config.version)
-
-      request.onerror = (): void => {
-        reject(
-          new IndexedDBError(
-            `Failed to open IndexedDB: ${request.error}`,
-            'openDatabase',
-            this.config.storeName,
-            request.error
-          )
-        )
-      }
-
-      request.onsuccess = (): void => {
-        this.db = request.result
-        resolve()
-      }
-
-      request.onupgradeneeded = (event: IDBVersionChangeEvent): void => {
-        this.handleUpgrade(event)
-      }
-    })
-  }
-
-  private handleUpgrade(event: IDBVersionChangeEvent): void {
-    const db = (event.target as IDBOpenDBRequest).result
-
-    // Create object store if it doesn't exist
-    if (!db.objectStoreNames.contains(this.config.storeName)) {
-      this.createObjectStore(db)
-    } else {
-      // Store exists, check for missing indexes
-      this.createMissingIndexes(db, event)
-    }
-
-    // Call custom upgrade handler if provided
-    if (this.config.onUpgrade) {
-      this.config.onUpgrade(db, event)
-    }
-  }
-
-  private createObjectStore(db: IDBDatabase): void {
-    const store = db.createObjectStore(this.config.storeName, { keyPath: this.config.keyPath })
-
-    // Create indexes
-    if (this.config.indexes) {
-      for (const index of this.config.indexes) {
-        if (!store.indexNames.contains(index.name)) {
-          store.createIndex(index.name, index.keyPath, { unique: index.unique ?? false })
-        }
-      }
-    }
-  }
-
-  private createMissingIndexes(_db: IDBDatabase, event: IDBVersionChangeEvent): void {
-    const target = event.target as IDBOpenDBRequest
-    const { transaction } = target
-    if (!transaction) {
-      return
-    }
-
-    const store = transaction.objectStore(this.config.storeName)
-    if (this.config.indexes) {
-      for (const index of this.config.indexes) {
-        if (!store.indexNames.contains(index.name)) {
-          store.createIndex(index.name, index.keyPath, { unique: index.unique ?? false })
-        }
-      }
-    }
-  }
-
-  /**
-   * Get object store for read operations
-   */
-  async getStore(mode: 'readonly'): Promise<IDBObjectStore> {
-    const db = await this.init()
-    const transaction = db.transaction([this.config.storeName], mode)
-    return transaction.objectStore(this.config.storeName)
-  }
-
-  /**
-   * Get object store for write operations
-   */
-  async getStoreWrite(mode: 'readwrite'): Promise<IDBObjectStore> {
-    const db = await this.init()
-    const transaction = db.transaction([this.config.storeName], mode)
-    return transaction.objectStore(this.config.storeName)
-  }
-
-  /**
-   * Get a value from the store by key
-   */
-  async get<T = unknown>(key: string | number): Promise<T | null> {
-    try {
-      const store = await this.getStore('readonly')
-      return new Promise<T | null>((resolve, reject) => {
-        const request = store.get(key)
-        request.onsuccess = (): void => {
-          resolve((request.result as T) ?? null)
-        }
-        request.onerror = (): void => {
-          reject(
-            new IndexedDBError(
-              `Failed to get value: ${request.error}`,
-              'get',
-              this.config.storeName,
-              request.error
-            )
-          )
-        }
-      })
-    } catch (error) {
-      if (error instanceof IndexedDBError) {
-        throw error
-      }
-      throw new IndexedDBError(
-        error instanceof Error ? error.message : 'Unknown error',
-        'get',
-        this.config.storeName,
-        error
-      )
-    }
-  }
-
-  /**
-   * Get a value from an index
-   */
-  async getByIndex<T = unknown>(indexName: string, key: string | number): Promise<T | null> {
-    try {
-      const store = await this.getStore('readonly')
-      const index = store.index(indexName)
-      return new Promise<T | null>((resolve, reject) => {
-        const request = index.get(key)
-        request.onsuccess = (): void => {
-          resolve((request.result as T) ?? null)
-        }
-        request.onerror = (): void => {
-          reject(
-            new IndexedDBError(
-              `Failed to get value by index: ${request.error}`,
-              'getByIndex',
-              this.config.storeName,
-              request.error
-            )
-          )
-        }
-      })
-    } catch (error) {
-      if (error instanceof IndexedDBError) {
-        throw error
-      }
-      throw new IndexedDBError(
-        error instanceof Error ? error.message : 'Unknown error',
-        'getByIndex',
-        this.config.storeName,
-        error
-      )
-    }
-  }
-
-  /**
-   * Get all values from an index
-   */
-  async getAllByIndex<T = unknown>(indexName: string, key?: IDBValidKey | IDBKeyRange): Promise<T[]> {
-    try {
-      const store = await this.getStore('readonly')
-      const index = store.index(indexName)
-      return new Promise<T[]>((resolve, reject) => {
-        const request = key !== undefined ? index.getAll(key) : index.getAll()
-        request.onsuccess = (): void => {
-          resolve((request.result as T[]) ?? [])
-        }
-        request.onerror = (): void => {
-          reject(
-            new IndexedDBError(
-              `Failed to get all values by index: ${request.error}`,
-              'getAllByIndex',
-              this.config.storeName,
-              request.error
-            )
-          )
-        }
-      })
-    } catch (error) {
-      if (error instanceof IndexedDBError) {
-        throw error
-      }
-      throw new IndexedDBError(
-        error instanceof Error ? error.message : 'Unknown error',
-        'getAllByIndex',
-        this.config.storeName,
-        error
-      )
-    }
-  }
-
-  /**
-   * Put a value in the store
-   */
-  async put<T = unknown>(value: T): Promise<void> {
-    try {
-      const store = await this.getStoreWrite('readwrite')
-      return new Promise<void>((resolve, reject) => {
-        const request = store.put(value)
-        request.onsuccess = (): void => {
-          resolve()
-        }
-        request.onerror = (): void => {
-          reject(
-            new IndexedDBError(
-              `Failed to put value: ${request.error}`,
-              'put',
-              this.config.storeName,
-              request.error
-            )
-          )
-        }
-      })
-    } catch (error) {
-      if (error instanceof IndexedDBError) {
-        throw error
-      }
-      throw new IndexedDBError(
-        error instanceof Error ? error.message : 'Unknown error',
-        'put',
-        this.config.storeName,
-        error
-      )
-    }
-  }
-
-  /**
-   * Add a value to the store (fails if key exists)
-   */
-  async add<T = unknown>(value: T): Promise<void> {
-    try {
-      const store = await this.getStoreWrite('readwrite')
-      return new Promise<void>((resolve, reject) => {
-        const request = store.add(value)
-        request.onsuccess = (): void => {
-          resolve()
-        }
-        request.onerror = (): void => {
-          reject(
-            new IndexedDBError(
-              `Failed to add value: ${request.error}`,
-              'add',
-              this.config.storeName,
-              request.error
-            )
-          )
-        }
-      })
-    } catch (error) {
-      if (error instanceof IndexedDBError) {
-        throw error
-      }
-      throw new IndexedDBError(
-        error instanceof Error ? error.message : 'Unknown error',
-        'add',
-        this.config.storeName,
-        error
-      )
-    }
-  }
-
-  /**
-   * Delete a value from the store by key
-   */
-  async delete(key: string | number): Promise<void> {
-    try {
-      const store = await this.getStoreWrite('readwrite')
-      return new Promise<void>((resolve, reject) => {
-        const request = store.delete(key)
-        request.onsuccess = (): void => {
-          resolve()
-        }
-        request.onerror = (): void => {
-          reject(
-            new IndexedDBError(
-              `Failed to delete value: ${request.error}`,
-              'delete',
-              this.config.storeName,
-              request.error
-            )
-          )
-        }
-      })
-    } catch (error) {
-      if (error instanceof IndexedDBError) {
-        throw error
-      }
-      throw new IndexedDBError(
-        error instanceof Error ? error.message : 'Unknown error',
-        'delete',
-        this.config.storeName,
-        error
-      )
-    }
-  }
-
-  /**
-   * Clear all values from the store
-   */
-  async clear(): Promise<void> {
-    try {
-      const store = await this.getStoreWrite('readwrite')
-      return new Promise<void>((resolve, reject) => {
-        const request = store.clear()
-        request.onsuccess = (): void => {
-          resolve()
-        }
-        request.onerror = (): void => {
-          reject(
-            new IndexedDBError(
-              `Failed to clear store: ${request.error}`,
-              'clear',
-              this.config.storeName,
-              request.error
-            )
-          )
-        }
-      })
-    } catch (error) {
-      if (error instanceof IndexedDBError) {
-        throw error
-      }
-      throw new IndexedDBError(
-        error instanceof Error ? error.message : 'Unknown error',
-        'clear',
-        this.config.storeName,
-        error
-      )
-    }
-  }
-
-  /**
-   * Open a cursor on the store
-   */
-  async openCursor(
-    direction?: IDBCursorDirection,
-    range?: IDBKeyRange
-  ): Promise<IDBCursorWithValue | null> {
-    try {
-      const store = await this.getStore('readonly')
-      return new Promise<IDBCursorWithValue | null>((resolve, reject) => {
-        const request = range ? store.openCursor(range, direction) : store.openCursor(direction)
-        request.onsuccess = (): void => {
-          resolve(request.result)
-        }
-        request.onerror = (): void => {
-          reject(
-            new IndexedDBError(
-              `Failed to open cursor: ${request.error}`,
-              'openCursor',
-              this.config.storeName,
-              request.error
-            )
-          )
-        }
-      })
-    } catch (error) {
-      if (error instanceof IndexedDBError) {
-        throw error
-      }
-      throw new IndexedDBError(
-        error instanceof Error ? error.message : 'Unknown error',
-        'openCursor',
-        this.config.storeName,
-        error
-      )
-    }
-  }
-
-  /**
-   * Open a cursor on an index
-   */
-  async openCursorOnIndex(
-    indexName: string,
-    direction?: IDBCursorDirection,
-    range?: IDBKeyRange
-  ): Promise<IDBCursorWithValue | null> {
-    try {
-      const store = await this.getStore('readonly')
-      const index = store.index(indexName)
-      return new Promise<IDBCursorWithValue | null>((resolve, reject) => {
-        const request = range ? index.openCursor(range, direction) : index.openCursor(direction)
-        request.onsuccess = (): void => {
-          resolve(request.result)
-        }
-        request.onerror = (): void => {
-          reject(
-            new IndexedDBError(
-              `Failed to open cursor on index: ${request.error}`,
-              'openCursorOnIndex',
-              this.config.storeName,
-              request.error
-            )
-          )
-        }
-      })
-    } catch (error) {
-      if (error instanceof IndexedDBError) {
-        throw error
-      }
-      throw new IndexedDBError(
-        error instanceof Error ? error.message : 'Unknown error',
-        'openCursorOnIndex',
-        this.config.storeName,
-        error
-      )
-    }
-  }
-
-  /**
-   * Count records in the store
-   */
-  async count(range?: IDBKeyRange): Promise<number> {
-    try {
-      const store = await this.getStore('readonly')
-      return new Promise<number>((resolve, reject) => {
-        const request = range ? store.count(range) : store.count()
-        request.onsuccess = (): void => {
-          resolve(request.result)
-        }
-        request.onerror = (): void => {
-          reject(
-            new IndexedDBError(
-              `Failed to count records: ${request.error}`,
-              'count',
-              this.config.storeName,
-              request.error
-            )
-          )
-        }
-      })
-    } catch (error) {
-      if (error instanceof IndexedDBError) {
-        throw error
-      }
-      throw new IndexedDBError(
-        error instanceof Error ? error.message : 'Unknown error',
-        'count',
-        this.config.storeName,
-        error
-      )
-    }
-  }
-
-  /**
-   * Count records in an index
-   */
-  async countByIndex(indexName: string, range?: IDBKeyRange): Promise<number> {
-    try {
-      const store = await this.getStore('readonly')
-      const index = store.index(indexName)
-      return new Promise<number>((resolve, reject) => {
-        const request = range ? index.count(range) : index.count()
-        request.onsuccess = (): void => {
-          resolve(request.result)
-        }
-        request.onerror = (): void => {
-          reject(
-            new IndexedDBError(
-              `Failed to count records by index: ${request.error}`,
-              'countByIndex',
-              this.config.storeName,
-              request.error
-            )
-          )
-        }
-      })
-    } catch (error) {
-      if (error instanceof IndexedDBError) {
-        throw error
-      }
-      throw new IndexedDBError(
-        error instanceof Error ? error.message : 'Unknown error',
-        'countByIndex',
-        this.config.storeName,
-        error
-      )
-    }
-  }
-
-  /**
-   * Get all values from the store
-   */
-  async getAll<T = unknown>(range?: IDBKeyRange, count?: number): Promise<T[]> {
-    try {
-      const store = await this.getStore('readonly')
-      return new Promise<T[]>((resolve, reject) => {
-        const request = range ? store.getAll(range, count) : store.getAll(undefined, count)
-        request.onsuccess = (): void => {
-          resolve((request.result as T[]) ?? [])
-        }
-        request.onerror = (): void => {
-          reject(
-            new IndexedDBError(
-              `Failed to get all values: ${request.error}`,
-              'getAll',
-              this.config.storeName,
-              request.error
-            )
-          )
-        }
-      })
-    } catch (error) {
-      if (error instanceof IndexedDBError) {
-        throw error
-      }
-      throw new IndexedDBError(
-        error instanceof Error ? error.message : 'Unknown error',
-        'getAll',
-        this.config.storeName,
-        error
-      )
-    }
-  }
-}
-
-/**
- * Create a new IndexedDB helper instance
- */
-export function createIndexedDBHelper(config: IndexedDBConfig): IndexedDBHelper {
-  return new IndexedDBHelper(config)
-}
-
-export { IndexedDBHelper }
+export * from './indexedDBHelper/index'
diff --git a/lib/helpers/indexedDBHelper/IndexedDBError.ts b/lib/helpers/indexedDBHelper/IndexedDBError.ts
new file mode 100644
index 0000000..f3d28e6
--- /dev/null
+++ b/lib/helpers/indexedDBHelper/IndexedDBError.ts
@@ -0,0 +1,15 @@
+export class IndexedDBError extends Error {
+  public readonly operation: string
+  public readonly storeName: string | undefined
+  public override readonly cause: unknown
+
+  public override readonly name = 'IndexedDBError'
+
+  constructor(message: string, operation: string, storeName?: string, cause?: unknown) {
+    super(message)
+    this.operation = operation
+    this.storeName = storeName
+    this.cause = cause
+    console.error(`[IndexedDBError] ${operation}${storeName ? ` on ${storeName}` : ''}: ${message}`, cause)
+  }
+}
diff --git a/lib/helpers/indexedDBHelper/IndexedDBHelper.ts b/lib/helpers/indexedDBHelper/IndexedDBHelper.ts
new file mode 100644
index 0000000..dc74aa7
--- /dev/null
+++ b/lib/helpers/indexedDBHelper/IndexedDBHelper.ts
@@ -0,0 +1,97 @@
+import type { IndexedDBConfig } from './types'
+import { IndexedDBError } from './IndexedDBError'
+import { initDatabase, type CoreAccessors } from './core'
+import { getObjectStore } from './store'
+import { getAll, getAllByIndex, getByIndex, getValue } from './read'
+import { addValue, clearStore, deleteValue, putValue } from './write'
+import { count, countByIndex, openCursor, openCursorOnIndex } from './cursor'
+
+export class IndexedDBHelper {
+  private db: IDBDatabase | null = null
+  private initPromise: Promise<void> | null = null
+  private readonly config: IndexedDBConfig
+
+  constructor(config: IndexedDBConfig) {
+    this.config = config
+  }
+
+  private accessors(): CoreAccessors {
+    return {
+      getDb: () => this.db,
+      setDb: (db) => {
+        this.db = db
+      },
+      getInitPromise: () => this.initPromise,
+      setInitPromise: (promise) => {
+        this.initPromise = promise
+      },
+      getConfig: () => this.config,
+    }
+  }
+
+  async init(): Promise<IDBDatabase> {
+    return initDatabase(this.accessors())
+  }
+
+  async getStore(mode: 'readonly'): Promise<IDBObjectStore> {
+    return getObjectStore(this.accessors(), mode)
+  }
+
+  async getStoreWrite(mode: 'readwrite'): Promise<IDBObjectStore> {
+    return getObjectStore(this.accessors(), mode)
+  }
+
+  async get<T = unknown>(key: string | number): Promise<T | null> {
+    return getValue<T>(this.accessors(), key)
+  }
+
+  async getByIndex<T = unknown>(indexName: string, key: string | number): Promise<T | null> {
+    return getByIndex<T>(this.accessors(), indexName, key)
+  }
+
+  async getAllByIndex<T = unknown>(indexName: string, key?: IDBValidKey | IDBKeyRange): Promise<T[]> {
+    return getAllByIndex<T>(this.accessors(), indexName, key)
+  }
+
+  async put<T = unknown>(value: T): Promise<void> {
+    return putValue<T>(this.accessors(), value)
+  }
+
+  async add<T = unknown>(value: T): Promise<void> {
+    return addValue<T>(this.accessors(), value)
+  }
+
+  async delete(key: string | number): Promise<void> {
+    return deleteValue(this.accessors(), key)
+  }
+
+  async clear(): Promise<void> {
+    return clearStore(this.accessors())
+  }
+
+  async openCursor(direction?: IDBCursorDirection, range?: IDBKeyRange): Promise<IDBCursorWithValue | null> {
+    return openCursor(this.accessors(), direction, range)
+  }
+
+  async openCursorOnIndex(indexName: string, direction?: IDBCursorDirection, range?: IDBKeyRange): Promise<IDBCursorWithValue | null> {
+    return openCursorOnIndex(this.accessors(), indexName, direction, range)
+  }
+
+  async count(range?: IDBKeyRange): Promise<number> {
+    return count(this.accessors(), range)
+  }
+
+  async countByIndex(indexName: string, range?: IDBKeyRange): Promise<number> {
+    return countByIndex(this.accessors(), indexName, range)
+  }
+
+  async getAll<T = unknown>(range?: IDBKeyRange, countParam?: number): Promise<T[]> {
+    return getAll<T>(this.accessors(), range, countParam)
+  }
+}
+
+export function assertIsIndexedDBError(error: unknown): asserts error is IndexedDBError {
+  if (!(error instanceof IndexedDBError)) {
+    throw error
+  }
+}
diff --git a/lib/helpers/indexedDBHelper/core.ts b/lib/helpers/indexedDBHelper/core.ts
new file mode 100644
index 0000000..bfce984
--- /dev/null
+++ b/lib/helpers/indexedDBHelper/core.ts
@@ -0,0 +1,97 @@
+import type { IndexedDBConfig } from './types'
+import { IndexedDBError } from './IndexedDBError'
+
+export type CoreAccessors = {
+  getDb: () => IDBDatabase | null
+  setDb: (db: IDBDatabase | null) => void
+  getInitPromise: () => Promise<void> | null
+  setInitPromise: (promise: Promise<void> | null) => void
+  getConfig: () => IndexedDBConfig
+}
+
+export async function initDatabase(accessors: CoreAccessors): Promise<IDBDatabase> {
+  const existing = accessors.getDb()
+  if (existing) {
+    return existing
+  }
+  const pending = accessors.getInitPromise()
+  if (pending) {
+    await pending
+    const db = accessors.getDb()
+    if (db) {
+      return db
+    }
+    throw new IndexedDBError('Database initialization failed', 'init', accessors.getConfig().storeName)
+  }
+
+  const initPromise = openDatabase(accessors)
+  accessors.setInitPromise(initPromise)
+  try {
+    await initPromise
+    const db = accessors.getDb()
+    if (!db) {
+      throw new IndexedDBError('Database not initialized after open', 'init', accessors.getConfig().storeName)
+    }
+    return db
+  } catch (error) {
+    accessors.setInitPromise(null)
+    throw new IndexedDBError(error instanceof Error ? error.message : 'Unknown error', 'init', accessors.getConfig().storeName, error)
+  }
+}
+
+export function openDatabase(accessors: CoreAccessors): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const config = accessors.getConfig()
+    if (typeof window === 'undefined' || !window.indexedDB) {
+      reject(new IndexedDBError('IndexedDB is not available', 'openDatabase', config.storeName))
+      return
+    }
+    const request = window.indexedDB.open(config.dbName, config.version)
+    request.onerror = (): void => {
+      reject(new IndexedDBError(`Failed to open IndexedDB: ${request.error}`, 'openDatabase', config.storeName, request.error))
+    }
+    request.onsuccess = (): void => {
+      accessors.setDb(request.result)
+      resolve()
+    }
+    request.onupgradeneeded = (event: IDBVersionChangeEvent): void => {
+      handleUpgrade({ config, event })
+    }
+  })
+}
+
+function handleUpgrade(params: { config: IndexedDBConfig; event: IDBVersionChangeEvent }): void {
+  const db = (params.event.target as IDBOpenDBRequest).result
+  if (!db.objectStoreNames.contains(params.config.storeName)) {
+    createObjectStore(db, params.config)
+  } else {
+    createMissingIndexes(db, params.event, params.config)
+  }
+  params.config.onUpgrade?.(db, params.event)
+}
+
+function createObjectStore(db: IDBDatabase, config: IndexedDBConfig): void {
+  const store = db.createObjectStore(config.storeName, { keyPath: config.keyPath })
+  if (!config.indexes) {
+    return
+  }
+  for (const index of config.indexes) {
+    if (!store.indexNames.contains(index.name)) {
+      store.createIndex(index.name, index.keyPath, { unique: index.unique ?? false })
+    }
+  }
+}
+
+function createMissingIndexes(_db: IDBDatabase, event: IDBVersionChangeEvent, config: IndexedDBConfig): void {
+  const target = event.target as IDBOpenDBRequest
+  const { transaction } = target
+  if (!transaction || !config.indexes) {
+    return
+  }
+  const store = transaction.objectStore(config.storeName)
+  for (const index of config.indexes) {
+    if (!store.indexNames.contains(index.name)) {
+      store.createIndex(index.name, index.keyPath, { unique: index.unique ?? false })
+    }
+  }
+}
diff --git a/lib/helpers/indexedDBHelper/cursor.ts b/lib/helpers/indexedDBHelper/cursor.ts
new file mode 100644
index 0000000..cffe02c
--- /dev/null
+++ b/lib/helpers/indexedDBHelper/cursor.ts
@@ -0,0 +1,77 @@
+import { IndexedDBError } from './IndexedDBError'
+import type { CoreAccessors } from './core'
+import { getObjectStore } from './store'
+
+export async function openCursor(accessors: CoreAccessors, direction?: IDBCursorDirection, range?: IDBKeyRange): Promise<IDBCursorWithValue | null> {
+  const {storeName} = accessors.getConfig()
+  try {
+    const store = await getObjectStore(accessors, 'readonly')
+    const request = range ? store.openCursor(range, direction) : store.openCursor(direction)
+    return await wrapCursorRequest(request, 'openCursor', storeName)
+  } catch (error) {
+    throw ensureIndexedDBError(error, 'openCursor', storeName)
+  }
+}
+
+export async function openCursorOnIndex(
+  accessors: CoreAccessors,
+  indexName: string,
+  direction?: IDBCursorDirection,
+  range?: IDBKeyRange
+): Promise<IDBCursorWithValue | null> {
+  const {storeName} = accessors.getConfig()
+  try {
+    const store = await getObjectStore(accessors, 'readonly')
+    const index = store.index(indexName)
+    const request = range ? index.openCursor(range, direction) : index.openCursor(direction)
+    return await wrapCursorRequest(request, 'openCursorOnIndex', storeName)
+  } catch (error) {
+    throw ensureIndexedDBError(error, 'openCursorOnIndex', storeName)
+  }
+}
+
+export async function count(accessors: CoreAccessors, range?: IDBKeyRange): Promise<number> {
+  const {storeName} = accessors.getConfig()
+  try {
+    const store = await getObjectStore(accessors, 'readonly')
+    const request = range ? store.count(range) : store.count()
+    return await wrapNumberRequest(request, 'count', storeName)
+  } catch (error) {
+    throw ensureIndexedDBError(error, 'count', storeName)
+  }
+}
+
+export async function countByIndex(accessors: CoreAccessors, indexName: string, range?: IDBKeyRange): Promise<number> {
+  const {storeName} = accessors.getConfig()
+  try {
+    const store = await getObjectStore(accessors, 'readonly')
+    const index = store.index(indexName)
+    const request = range ? index.count(range) : index.count()
+    return await wrapNumberRequest(request, 'countByIndex', storeName)
+  } catch (error) {
+    throw ensureIndexedDBError(error, 'countByIndex', storeName)
+  }
+}
+
+function wrapCursorRequest(requestParam: IDBRequest, operation: string, storeName: string): Promise<IDBCursorWithValue | null> {
+  return new Promise((resolve, reject) => {
+    const request = requestParam
+    request.onsuccess = (): void => resolve(request.result as IDBCursorWithValue | null)
+    request.onerror = (): void => reject(new IndexedDBError(`Failed to ${operation}: ${request.error}`, operation, storeName, request.error))
+  })
+}
+
+function wrapNumberRequest(requestParam: IDBRequest, operation: string, storeName: string): Promise<number> {
+  return new Promise((resolve, reject) => {
+    const request = requestParam
+    request.onsuccess = (): void => resolve(request.result as number)
+    request.onerror = (): void => reject(new IndexedDBError(`Failed to ${operation}: ${request.error}`, operation, storeName, request.error))
+  })
+}
+
+function ensureIndexedDBError(error: unknown, operation: string, storeName: string): IndexedDBError {
+  if (error instanceof IndexedDBError) {
+    return error
+  }
+  return new IndexedDBError(error instanceof Error ? error.message : 'Unknown error', operation, storeName, error)
+}
diff --git a/lib/helpers/indexedDBHelper/index.ts b/lib/helpers/indexedDBHelper/index.ts
new file mode 100644
index 0000000..29778b0
--- /dev/null
+++ b/lib/helpers/indexedDBHelper/index.ts
@@ -0,0 +1,10 @@
+export type { IndexedDBConfig, IndexedDBIndex } from './types'
+export { IndexedDBError } from './IndexedDBError'
+export { IndexedDBHelper } from './IndexedDBHelper'
+
+import type { IndexedDBConfig } from './types'
+import { IndexedDBHelper } from './IndexedDBHelper'
+
+export function createIndexedDBHelper(config: IndexedDBConfig): IndexedDBHelper {
+  return new IndexedDBHelper(config)
+}
diff --git a/lib/helpers/indexedDBHelper/read.ts b/lib/helpers/indexedDBHelper/read.ts
new file mode 100644
index 0000000..688f12d
--- /dev/null
+++ b/lib/helpers/indexedDBHelper/read.ts
@@ -0,0 +1,67 @@
+import { IndexedDBError } from './IndexedDBError'
+import type { CoreAccessors } from './core'
+import { getObjectStore } from './store'
+
+export async function getValue<T>(accessors: CoreAccessors, key: string | number): Promise<T | null> {
+  const {storeName} = accessors.getConfig()
+  try {
+    const store = await getObjectStore(accessors, 'readonly')
+    return await wrapRequest<T | null>(store.get(key), 'get', storeName, (r) => (r.result as T) ?? null)
+  } catch (error) {
+    throw ensureIndexedDBError(error, 'get', storeName)
+  }
+}
+
+export async function getByIndex<T>(accessors: CoreAccessors, indexName: string, key: string | number): Promise<T | null> {
+  const {storeName} = accessors.getConfig()
+  try {
+    const store = await getObjectStore(accessors, 'readonly')
+    const index = store.index(indexName)
+    return await wrapRequest<T | null>(index.get(key), 'getByIndex', storeName, (r) => (r.result as T) ?? null)
+  } catch (error) {
+    throw ensureIndexedDBError(error, 'getByIndex', storeName)
+  }
+}
+
+export async function getAllByIndex<T>(accessors: CoreAccessors, indexName: string, key?: IDBValidKey | IDBKeyRange): Promise<T[]> {
+  const {storeName} = accessors.getConfig()
+  try {
+    const store = await getObjectStore(accessors, 'readonly')
+    const index = store.index(indexName)
+    const request = key !== undefined ? index.getAll(key) : index.getAll()
+    return await wrapRequest<T[]>(request, 'getAllByIndex', storeName, (r) => (r.result as T[]) ?? [])
+  } catch (error) {
+    throw ensureIndexedDBError(error, 'getAllByIndex', storeName)
+  }
+}
+
+export async function getAll<T>(accessors: CoreAccessors, range?: IDBKeyRange, count?: number): Promise<T[]> {
+  const {storeName} = accessors.getConfig()
+  try {
+    const store = await getObjectStore(accessors, 'readonly')
+    const request = range ? store.getAll(range, count) : store.getAll(undefined, count)
+    return await wrapRequest<T[]>(request, 'getAll', storeName, (r) => (r.result as T[]) ?? [])
+  } catch (error) {
+    throw ensureIndexedDBError(error, 'getAll', storeName)
+  }
+}
+
+function wrapRequest<TResult>(
+  requestParam: IDBRequest,
+  operation: string,
+  storeName: string,
+  mapResult: (request: IDBRequest) => TResult
+): Promise<TResult> {
+  return new Promise<TResult>((resolve, reject) => {
+    const request = requestParam
+    request.onsuccess = (): void => resolve(mapResult(request))
+    request.onerror = (): void => reject(new IndexedDBError(`Failed to ${operation}: ${request.error}`, operation, storeName, request.error))
+  })
+}
+
+function ensureIndexedDBError(error: unknown, operation: string, storeName: string): IndexedDBError {
+  if (error instanceof IndexedDBError) {
+    return error
+  }
+  return new IndexedDBError(error instanceof Error ? error.message : 'Unknown error', operation, storeName, error)
+}
diff --git a/lib/helpers/indexedDBHelper/store.ts b/lib/helpers/indexedDBHelper/store.ts
new file mode 100644
index 0000000..d88b7e7
--- /dev/null
+++ b/lib/helpers/indexedDBHelper/store.ts
@@ -0,0 +1,14 @@
+import type { IndexedDBConfig } from './types'
+import { IndexedDBError } from './IndexedDBError'
+import { initDatabase, type CoreAccessors } from './core'
+
+export async function getObjectStore(accessors: CoreAccessors, mode: IDBTransactionMode): Promise<IDBObjectStore> {
+  const db = await initDatabase(accessors)
+  const config: IndexedDBConfig = accessors.getConfig()
+  try {
+    const transaction = db.transaction([config.storeName], mode)
+    return transaction.objectStore(config.storeName)
+  } catch (error) {
+    throw new IndexedDBError(error instanceof Error ? error.message : 'Unknown error', 'getStore', config.storeName, error)
+  }
+}
diff --git a/lib/helpers/indexedDBHelper/types.ts b/lib/helpers/indexedDBHelper/types.ts
new file mode 100644
index 0000000..ed4bc8e
--- /dev/null
+++ b/lib/helpers/indexedDBHelper/types.ts
@@ -0,0 +1,14 @@
+export interface IndexedDBIndex {
+  name: string
+  keyPath: string | string[]
+  unique?: boolean
+}
+
+export interface IndexedDBConfig {
+  dbName: string
+  version: number
+  storeName: string
+  keyPath: string
+  indexes?: IndexedDBIndex[]
+  onUpgrade?: (db: IDBDatabase, event: IDBVersionChangeEvent) => void
+}
diff --git a/lib/helpers/indexedDBHelper/write.ts b/lib/helpers/indexedDBHelper/write.ts
new file mode 100644
index 0000000..97002b4
--- /dev/null
+++ b/lib/helpers/indexedDBHelper/write.ts
@@ -0,0 +1,58 @@
+import { IndexedDBError } from './IndexedDBError'
+import type { CoreAccessors } from './core'
+import { getObjectStore } from './store'
+
+export async function putValue<T>(accessors: CoreAccessors, value: T): Promise<void> {
+  const {storeName} = accessors.getConfig()
+  try {
+    const store = await getObjectStore(accessors, 'readwrite')
+    await wrapVoidRequest(store.put(value), 'put', storeName)
+  } catch (error) {
+    throw ensureIndexedDBError(error, 'put', storeName)
+  }
+}
+
+export async function addValue<T>(accessors: CoreAccessors, value: T): Promise<void> {
+  const {storeName} = accessors.getConfig()
+  try {
+    const store = await getObjectStore(accessors, 'readwrite')
+    await wrapVoidRequest(store.add(value), 'add', storeName)
+  } catch (error) {
+    throw ensureIndexedDBError(error, 'add', storeName)
+  }
+}
+
+export async function deleteValue(accessors: CoreAccessors, key: string | number): Promise<void> {
+  const {storeName} = accessors.getConfig()
+  try {
+    const store = await getObjectStore(accessors, 'readwrite')
+    await wrapVoidRequest(store.delete(key), 'delete', storeName)
+  } catch (error) {
+    throw ensureIndexedDBError(error, 'delete', storeName)
+  }
+}
+
+export async function clearStore(accessors: CoreAccessors): Promise<void> {
+  const {storeName} = accessors.getConfig()
+  try {
+    const store = await getObjectStore(accessors, 'readwrite')
+    await wrapVoidRequest(store.clear(), 'clear', storeName)
+  } catch (error) {
+    throw ensureIndexedDBError(error, 'clear', storeName)
+  }
+}
+
+function wrapVoidRequest(requestParam: IDBRequest, operation: string, storeName: string): Promise<void> {
+  return new Promise<void>((resolve, reject) => {
+    const request = requestParam
+    request.onsuccess = (): void => resolve()
+    request.onerror = (): void => reject(new IndexedDBError(`Failed to ${operation}: ${request.error}`, operation, storeName, request.error))
+  })
+}
+
+function ensureIndexedDBError(error: unknown, operation: string, storeName: string): IndexedDBError {
+  if (error instanceof IndexedDBError) {
+    return error
+  }
+  return new IndexedDBError(error instanceof Error ? error.message : 'Unknown error', operation, storeName, error)
+}
diff --git a/lib/hooks/useSyncProgress.ts b/lib/hooks/useSyncProgress.ts
index 5eedfb0..cbba681 100644
--- a/lib/hooks/useSyncProgress.ts
+++ b/lib/hooks/useSyncProgress.ts
@@ -3,7 +3,7 @@
  * Centralizes the pattern of polling syncProgressManager and updating state
  */
 
-import { useState, useEffect, useRef, useCallback } from 'react'
+import { useState, useEffect, useRef, useCallback, type MutableRefObject } from 'react'
 import type { SyncProgress } from '../helpers/syncProgressHelper'
 
 export interface UseSyncProgressOptions {
@@ -23,85 +23,125 @@ export interface UseSyncProgressResult {
  * Hook to monitor sync progress from syncProgressManager
  */
 export function useSyncProgress(options: UseSyncProgressOptions = {}): UseSyncProgressResult {
-  const { onComplete, pollInterval = 500, maxDuration = 60000 } = options
+  const config = normalizeSyncProgressOptions(options)
+  const state = useSyncProgressState({ onComplete: config.onComplete })
+  const checkProgress = useCheckProgress({ onCompleteRef: state.onCompleteRef, setSyncProgress: state.setSyncProgress, setIsSyncing: state.setIsSyncing, stopMonitoring: state.stopMonitoring })
+  const startMonitoring = useStartMonitoring({ pollInterval: config.pollInterval, maxDuration: config.maxDuration, checkProgress, stopMonitoring: state.stopMonitoring, setIsSyncing: state.setIsSyncing, setSyncProgress: state.setSyncProgress, isMonitoringRef: state.isMonitoringRef, intervalRef: state.intervalRef, timeoutRef: state.timeoutRef })
+  useUnmountCleanup({ stopMonitoring: state.stopMonitoring })
+  return { syncProgress: state.syncProgress, isSyncing: state.isSyncing, startMonitoring, stopMonitoring: state.stopMonitoring }
+}
 
+function normalizeSyncProgressOptions(options: UseSyncProgressOptions): { onComplete: UseSyncProgressOptions['onComplete']; pollInterval: number; maxDuration: number } {
+  return { onComplete: options.onComplete, pollInterval: options.pollInterval ?? 500, maxDuration: options.maxDuration ?? 60000 }
+}
+
+function useSyncProgressState(params: { onComplete: UseSyncProgressOptions['onComplete'] }): {
+  syncProgress: SyncProgress | null
+  setSyncProgress: (value: SyncProgress | null) => void
+  isSyncing: boolean
+  setIsSyncing: (value: boolean) => void
+  intervalRef: MutableRefObject<ReturnType<typeof setInterval> | null>
+  timeoutRef: MutableRefObject<ReturnType<typeof setTimeout> | null>
+  isMonitoringRef: MutableRefObject<boolean>
+  onCompleteRef: MutableRefObject<UseSyncProgressOptions['onComplete']>
+  stopMonitoring: () => void
+} {
   const [syncProgress, setSyncProgress] = useState<SyncProgress | null>(null)
   const [isSyncing, setIsSyncing] = useState(false)
   const intervalRef = useRef<ReturnType<typeof setInterval> | null>(null)
   const timeoutRef = useRef<ReturnType<typeof setTimeout> | null>(null)
-  const onCompleteRef = useRef(onComplete)
   const isMonitoringRef = useRef(false)
+  const onCompleteRef = useRef(params.onComplete)
+
+  useEffect(() => {
+    onCompleteRef.current = params.onComplete
+  }, [params.onComplete])
 
   const stopMonitoring = useCallback((): void => {
     if (!isMonitoringRef.current) {
       return
     }
-
     isMonitoringRef.current = false
     setIsSyncing(false)
-
-    if (intervalRef.current) {
-      clearInterval(intervalRef.current)
-      intervalRef.current = null
-    }
-
-    if (timeoutRef.current) {
-      clearTimeout(timeoutRef.current)
-      timeoutRef.current = null
-    }
+    intervalRef.current = clearIntervalAndReturnNull(intervalRef.current)
+    timeoutRef.current = clearTimeoutAndReturnNull(timeoutRef.current)
   }, [])
 
-  // Update onComplete ref when it changes
-  useEffect(() => {
-    onCompleteRef.current = onComplete
-  }, [onComplete])
+  return { syncProgress, setSyncProgress, isSyncing, setIsSyncing, intervalRef, timeoutRef, isMonitoringRef, onCompleteRef, stopMonitoring }
+}
 
-  const checkProgress = useCallback(async (): Promise<void> => {
+function clearIntervalAndReturnNull(current: ReturnType<typeof setInterval> | null): null {
+  if (current) {
+    clearInterval(current)
+  }
+  return null
+}
+
+function clearTimeoutAndReturnNull(current: ReturnType<typeof setTimeout> | null): null {
+  if (current) {
+    clearTimeout(current)
+  }
+  return null
+}
+
+function useCheckProgress(params: {
+  onCompleteRef: MutableRefObject<UseSyncProgressOptions['onComplete']>
+  setSyncProgress: (value: SyncProgress | null) => void
+  setIsSyncing: (value: boolean) => void
+  stopMonitoring: () => void
+}): () => Promise<void> {
+  const { onCompleteRef, setSyncProgress, setIsSyncing, stopMonitoring } = params
+  return useCallback(async (): Promise<void> => {
     const { syncProgressManager } = await import('../syncProgressManager')
-    const currentProgress = syncProgressManager.getProgress()
-    if (currentProgress) {
-      setSyncProgress(currentProgress)
-      if (currentProgress.completed) {
-        setIsSyncing(false)
-        if (onCompleteRef.current) {
-          await onCompleteRef.current()
-        }
-        stopMonitoring()
-      }
+    const current = syncProgressManager.getProgress()
+    if (!current) {
+      return
     }
-  }, [stopMonitoring])
+    setSyncProgress(current)
+    if (!current.completed) {
+      return
+    }
+    setIsSyncing(false)
+    await onCompleteRef.current?.()
+    stopMonitoring()
+  }, [onCompleteRef, setIsSyncing, setSyncProgress, stopMonitoring])
+}
 
-  const startMonitoring = useCallback((): void => {
+function useStartMonitoring(params: {
+  pollInterval: number
+  maxDuration: number
+  checkProgress: () => Promise<void>
+  stopMonitoring: () => void
+  setIsSyncing: (value: boolean) => void
+  setSyncProgress: (value: SyncProgress | null) => void
+  isMonitoringRef: MutableRefObject<boolean>
+  intervalRef: MutableRefObject<ReturnType<typeof setInterval> | null>
+  timeoutRef: MutableRefObject<ReturnType<typeof setTimeout> | null>
+}): () => void {
+  const {
+    pollInterval,
+    maxDuration,
+    checkProgress,
+    stopMonitoring,
+    setIsSyncing,
+    setSyncProgress,
+    isMonitoringRef,
+    intervalRef,
+    timeoutRef,
+  } = params
+  return useCallback((): void => {
     if (isMonitoringRef.current) {
       return
     }
-
     isMonitoringRef.current = true
     setIsSyncing(true)
     setSyncProgress({ currentStep: 0, totalSteps: 7, completed: false })
-
-    // Poll progress periodically
-    intervalRef.current = setInterval(() => {
-      void checkProgress()
-    }, pollInterval)
-
-    // Cleanup after max duration
-    timeoutRef.current = setTimeout(() => {
-      stopMonitoring()
-    }, maxDuration)
-  }, [checkProgress, maxDuration, pollInterval, stopMonitoring])
-
-  // Cleanup on unmount
-  useEffect(() => {
-    return () => {
-      stopMonitoring()
-    }
-  }, [stopMonitoring])
-
-  return {
-    syncProgress,
-    isSyncing,
-    startMonitoring,
-    stopMonitoring,
-  }
+    intervalRef.current = setInterval(() => void checkProgress(), pollInterval)
+    timeoutRef.current = setTimeout(() => stopMonitoring(), maxDuration)
+  }, [checkProgress, intervalRef, isMonitoringRef, maxDuration, pollInterval, setIsSyncing, setSyncProgress, stopMonitoring, timeoutRef])
+}
+
+function useUnmountCleanup(params: { stopMonitoring: () => void }): void {
+  const { stopMonitoring } = params
+  useEffect(() => () => stopMonitoring(), [stopMonitoring])
 }
diff --git a/lib/keyManagementTwoLevel.ts b/lib/keyManagementTwoLevel.ts
index 65fdad1..dc61d59 100644
--- a/lib/keyManagementTwoLevel.ts
+++ b/lib/keyManagementTwoLevel.ts
@@ -1,439 +1 @@
-/**
- * Two-level encryption system for key management
- *
- * Level 1: Private key encrypted with KEK (Key Encryption Key)
- * Level 2: KEK encrypted with 4-word recovery phrase
- *
- * Flow:
- * - KEK is generated randomly and stored encrypted in Credentials API
- * - Private key is encrypted with KEK and stored in IndexedDB
- * - Recovery phrase (4 words) is used to encrypt/decrypt KEK
- */
-
-import type { EncryptedPayload } from './keyManagementEncryption'
-import { generateRecoveryPhrase } from './keyManagementBIP39'
-const PBKDF2_ITERATIONS = 100000
-const PBKDF2_HASH = 'SHA-256'
-
-/**
- * Generate a random KEK (Key Encryption Key)
- */
-async function generateKEK(): Promise<CryptoKey> {
-  return globalThis.crypto.subtle.generateKey(
-    { name: 'AES-GCM', length: 256 },
-    true, // extractable
-    ['encrypt', 'decrypt']
-  )
-}
-
-/**
- * Derive encryption key from recovery phrase using PBKDF2
- */
-async function deriveKeyFromPhrase(phrase: string[]): Promise<CryptoKey> {
-  const phraseString = phrase.join(' ')
-  const encoder = new TextEncoder()
-  const password = encoder.encode(phraseString)
-
-  // Generate deterministic salt from phrase
-  const saltBuffer = await globalThis.crypto.subtle.digest('SHA-256', password)
-  const saltArray = new Uint8Array(saltBuffer)
-  const salt = saltArray.slice(0, 32)
-
-  // Import password as key material
-  const keyMaterial = await globalThis.crypto.subtle.importKey(
-    'raw',
-    password,
-    'PBKDF2',
-    false,
-    ['deriveBits', 'deriveKey']
-  )
-
-  // Derive key using PBKDF2
-  const derivedKey = await globalThis.crypto.subtle.deriveKey(
-    {
-      name: 'PBKDF2',
-      salt,
-      iterations: PBKDF2_ITERATIONS,
-      hash: PBKDF2_HASH,
-    },
-    keyMaterial,
-    { name: 'AES-GCM', length: 256 },
-    false,
-    ['encrypt', 'decrypt']
-  )
-
-  return derivedKey
-}
-
-/**
- * Export KEK to raw bytes (for storage)
- */
-async function exportKEK(kek: CryptoKey): Promise<Uint8Array> {
-  const exported = await globalThis.crypto.subtle.exportKey('raw', kek)
-  return new Uint8Array(exported)
-}
-
-/**
- * Import KEK from raw bytes
- */
-async function importKEK(keyBytes: Uint8Array): Promise<CryptoKey> {
-  // Create a new ArrayBuffer from the Uint8Array
-  const buffer = new ArrayBuffer(keyBytes.length)
-  const view = new Uint8Array(buffer)
-  view.set(keyBytes)
-  return globalThis.crypto.subtle.importKey(
-    'raw',
-    buffer,
-    { name: 'AES-GCM' },
-    false,
-    ['encrypt', 'decrypt']
-  )
-}
-
-/**
- * Encrypt KEK with recovery phrase
- */
-async function encryptKEK(kek: CryptoKey, recoveryPhrase: string[]): Promise<EncryptedPayload> {
-  const phraseKey = await deriveKeyFromPhrase(recoveryPhrase)
-  const kekBytes = await exportKEK(kek)
-
-  const encoder = new TextEncoder()
-  const data = encoder.encode(Array.from(kekBytes).map(b => b.toString(16).padStart(2, '0')).join(''))
-  const iv = globalThis.crypto.getRandomValues(new Uint8Array(12))
-
-  const encrypted = await globalThis.crypto.subtle.encrypt(
-    { name: 'AES-GCM', iv },
-    phraseKey,
-    data
-  )
-
-  const encryptedArray = new Uint8Array(encrypted)
-
-  function toBase64(bytes: Uint8Array): string {
-    let binary = ''
-    bytes.forEach((b) => {
-      binary += String.fromCharCode(b)
-    })
-    return globalThis.btoa(binary)
-  }
-
-  return {
-    iv: toBase64(iv),
-    ciphertext: toBase64(encryptedArray),
-  }
-}
-
-/**
- * Decrypt KEK with recovery phrase
- */
-async function decryptKEK(encryptedKEK: EncryptedPayload, recoveryPhrase: string[]): Promise<CryptoKey> {
-  const phraseKey = await deriveKeyFromPhrase(recoveryPhrase)
-
-  function fromBase64(value: string): Uint8Array {
-    const binary = globalThis.atob(value)
-    const bytes = new Uint8Array(binary.length)
-    for (let i = 0; i < binary.length; i += 1) {
-      bytes[i] = binary.charCodeAt(i)
-    }
-    return bytes
-  }
-
-  const iv = fromBase64(encryptedKEK.iv)
-  const ciphertext = fromBase64(encryptedKEK.ciphertext)
-
-  // Create ArrayBuffer views for decrypt
-  const ivBuffer = new ArrayBuffer(iv.length)
-  const ivView = new Uint8Array(ivBuffer)
-  ivView.set(iv)
-
-  const cipherBuffer = new ArrayBuffer(ciphertext.length)
-  const cipherView = new Uint8Array(cipherBuffer)
-  cipherView.set(ciphertext)
-
-  const decrypted = await globalThis.crypto.subtle.decrypt(
-    { name: 'AES-GCM', iv: ivView },
-    phraseKey,
-    cipherBuffer
-  )
-
-  const decoder = new TextDecoder()
-  const hexString = decoder.decode(decrypted)
-
-  // Convert hex string back to bytes
-  const kekBytes = new Uint8Array(hexString.match(/.{1,2}/g)?.map(byte => parseInt(byte, 16)) ?? [])
-
-  return importKEK(kekBytes)
-}
-
-/**
- * Encrypt private key with KEK
- */
-async function encryptPrivateKeyWithKEK(privateKey: string, kek: CryptoKey): Promise<EncryptedPayload> {
-  const encoder = new TextEncoder()
-  const data = encoder.encode(privateKey)
-  const iv = globalThis.crypto.getRandomValues(new Uint8Array(12))
-
-  const encrypted = await globalThis.crypto.subtle.encrypt(
-    { name: 'AES-GCM', iv },
-    kek,
-    data
-  )
-
-  const encryptedArray = new Uint8Array(encrypted)
-
-  function toBase64(bytes: Uint8Array): string {
-    let binary = ''
-    bytes.forEach((b) => {
-      binary += String.fromCharCode(b)
-    })
-    return globalThis.btoa(binary)
-  }
-
-  return {
-    iv: toBase64(iv),
-    ciphertext: toBase64(encryptedArray),
-  }
-}
-
-/**
- * Decrypt private key with KEK
- */
-async function decryptPrivateKeyWithKEK(encryptedPrivateKey: EncryptedPayload, kek: CryptoKey): Promise<string> {
-  function fromBase64(value: string): Uint8Array {
-    const binary = globalThis.atob(value)
-    const bytes = new Uint8Array(binary.length)
-    for (let i = 0; i < binary.length; i += 1) {
-      bytes[i] = binary.charCodeAt(i)
-    }
-    return bytes
-  }
-
-  const iv = fromBase64(encryptedPrivateKey.iv)
-  const ciphertext = fromBase64(encryptedPrivateKey.ciphertext)
-
-  // Create ArrayBuffer views for decrypt
-  const ivBuffer = new ArrayBuffer(iv.length)
-  const ivView = new Uint8Array(ivBuffer)
-  ivView.set(iv)
-
-  const cipherBuffer = new ArrayBuffer(ciphertext.length)
-  const cipherView = new Uint8Array(cipherBuffer)
-  cipherView.set(ciphertext)
-
-  const decrypted = await globalThis.crypto.subtle.decrypt(
-    { name: 'AES-GCM', iv: ivView },
-    kek,
-    cipherBuffer
-  )
-
-  const decoder = new TextDecoder()
-  return decoder.decode(decrypted)
-}
-
-/**
- * Store encrypted KEK in Credentials API
- */
-async function storeEncryptedKEK(encryptedKEK: EncryptedPayload): Promise<void> {
-  if (typeof window === 'undefined') {
-    throw new Error('Window not available')
-  }
-
-  // Type definition for PasswordCredential
-  interface PasswordCredentialData {
-    id: string
-    name: string
-    password: string
-    iconURL?: string
-  }
-  type PasswordCredentialConstructorType = new (data: PasswordCredentialData) => Credential & { id: string; password: string }
-  const PasswordCredentialConstructor = (window as unknown as { PasswordCredential?: PasswordCredentialConstructorType }).PasswordCredential
-  if (!PasswordCredentialConstructor || !navigator.credentials?.store) {
-    throw new Error('PasswordCredential API not available')
-  }
-
-  // Store encrypted KEK as password in credential
-  // Type assertion for PasswordCredential
-  type PasswordCredentialType = new (data: PasswordCredentialData) => Credential & { id: string; password: string }
-  const PasswordCredentialClass = PasswordCredentialConstructor as PasswordCredentialType
-  const credential = new PasswordCredentialClass({
-    id: 'nostr_kek',
-    name: 'Nostr KEK',
-    password: JSON.stringify(encryptedKEK),
-    iconURL: `${window.location.origin  }/favicon.ico`,
-  })
-
-  await navigator.credentials.store(credential)
-}
-
-/**
- * Retrieve encrypted KEK from Credentials API
- */
-async function getEncryptedKEK(): Promise<EncryptedPayload | null> {
-  if (typeof window === 'undefined' || !navigator.credentials?.get) {
-    return null
-  }
-
-  try {
-    const credential = await navigator.credentials.get({
-      password: true,
-    } as CredentialRequestOptions)
-
-    if (credential && 'password' in credential && typeof credential.password === 'string' && credential.id === 'nostr_kek') {
-      return JSON.parse(credential.password) as EncryptedPayload
-    }
-
-    return null
-  } catch (e) {
-    console.error('Error retrieving encrypted KEK:', e)
-    return null
-  }
-}
-
-export interface CreateAccountResult {
-  recoveryPhrase: string[]
-  npub: string
-  publicKey: string
-}
-
-export interface UnlockAccountResult {
-  privateKey: string
-  publicKey: string
-  npub: string
-}
-
-/**
- * Create account with two-level encryption
- */
-export async function createAccountTwoLevel(
-  privateKeyHex: string,
-  getPublicKey: (secretKey: Uint8Array) => string,
-  encodeNpub: (publicKey: string) => string
-): Promise<CreateAccountResult> {
-  // Step 1: Generate recovery phrase (4 words from BIP39)
-  const recoveryPhrase = generateRecoveryPhrase()
-
-  // Step 2: Generate KEK (in memory)
-  const kek = await generateKEK()
-
-  // Step 3: Encrypt private key with KEK
-  const encryptedPrivateKey = await encryptPrivateKeyWithKEK(privateKeyHex, kek)
-
-  // Step 4: Encrypt KEK with recovery phrase
-  const encryptedKEK = await encryptKEK(kek, recoveryPhrase)
-
-  // Step 5: Store encrypted KEK in Credentials API
-  await storeEncryptedKEK(encryptedKEK)
-
-  // Step 6: Store encrypted private key in IndexedDB (via storage service)
-  const { storageService } = await import('./storage/indexedDB')
-  await storageService.set('nostr_encrypted_key', encryptedPrivateKey, 'nostr_key_storage')
-
-  // Step 7: Compute public key and npub
-  const { hexToBytes } = await import('nostr-tools/utils')
-  const secretKey = hexToBytes(privateKeyHex)
-  const publicKey = getPublicKey(secretKey)
-  const npub = encodeNpub(publicKey)
-
-  // Step 8: Store public keys in IndexedDB
-  await storageService.set('nostr_public_key', { publicKey, npub }, 'nostr_key_storage')
-
-  // Step 9: Store account flag in IndexedDB (not localStorage)
-  await storageService.set('nostr_account_exists', true, 'nostr_key_storage')
-
-  // Step 10: Clear KEK from memory (it's now encrypted and stored)
-  // Note: In JavaScript, we can't force garbage collection, but we can null the reference
-  // The KEK will be garbage collected automatically
-
-  return {
-    recoveryPhrase,
-    npub,
-    publicKey,
-  }
-}
-
-/**
- * Unlock account with two-level decryption
- */
-export async function unlockAccountTwoLevel(
-  recoveryPhrase: string[],
-  getPublicKey: (secretKey: Uint8Array) => string,
-  encodeNpub: (publicKey: string) => string
-): Promise<UnlockAccountResult> {
-  // Step 1: Get encrypted KEK from Credentials API
-  const encryptedKEK = await getEncryptedKEK()
-  if (!encryptedKEK) {
-    throw new Error('No encrypted KEK found in Credentials API')
-  }
-
-  // Step 2: Decrypt KEK with recovery phrase (in memory)
-  const kek = await decryptKEK(encryptedKEK, recoveryPhrase)
-
-  // Step 3: Clear recovery phrase from memory (set to empty)
-  // Note: In JavaScript, we can't force memory clearing, but we can overwrite
-  recoveryPhrase.fill('')
-
-  // Step 4: Get encrypted private key from IndexedDB
-  const { storageService: indexedDBStorage } = await import('./storage/indexedDB')
-  const encryptedPrivateKey = await indexedDBStorage.get<EncryptedPayload>('nostr_encrypted_key', 'nostr_key_storage')
-  if (!encryptedPrivateKey) {
-    throw new Error('No encrypted private key found in IndexedDB')
-  }
-
-  // Step 5: Decrypt private key with KEK (in memory)
-  const privateKeyHex = await decryptPrivateKeyWithKEK(encryptedPrivateKey, kek)
-
-  // Step 6: Clear KEK from memory
-  // Note: In JavaScript, we can't force memory clearing, but we can null the reference
-
-  // Step 7: Verify by computing public key
-  const { hexToBytes } = await import('nostr-tools/utils')
-  const secretKey = hexToBytes(privateKeyHex)
-  const publicKey = getPublicKey(secretKey)
-  const npub = encodeNpub(publicKey)
-
-  return {
-    privateKey: privateKeyHex,
-    publicKey,
-    npub,
-  }
-}
-
-/**
- * Check if account exists
- */
-export async function accountExistsTwoLevel(): Promise<boolean> {
-  try {
-    const { storageService: indexedDBStorage } = await import('./storage/indexedDB')
-    const exists = await indexedDBStorage.get<boolean>('nostr_account_exists', 'nostr_key_storage')
-    return exists === true
-  } catch {
-    return false
-  }
-}
-
-/**
- * Get public keys if account exists
- */
-export async function getPublicKeysTwoLevel(): Promise<{ publicKey: string; npub: string } | null> {
-  try {
-    const { storageService: indexedDBStorage } = await import('./storage/indexedDB')
-    return indexedDBStorage.get<{ publicKey: string; npub: string }>('nostr_public_key', 'nostr_key_storage')
-  } catch {
-    return null
-  }
-}
-
-/**
- * Delete account (remove all stored data)
- */
-export async function deleteAccountTwoLevel(): Promise<void> {
-  const { storageService: indexedDBStorage } = await import('./storage/indexedDB')
-  await indexedDBStorage.delete('nostr_encrypted_key')
-  await indexedDBStorage.delete('nostr_public_key')
-  await indexedDBStorage.delete('nostr_account_exists')
-
-  // Try to remove credential (may not be possible via API)
-  if (navigator.credentials?.preventSilentAccess) {
-    void navigator.credentials.preventSilentAccess()
-  }
-}
+export * from './keyManagementTwoLevel/api'
diff --git a/lib/keyManagementTwoLevel/api.ts b/lib/keyManagementTwoLevel/api.ts
new file mode 100644
index 0000000..1f392f5
--- /dev/null
+++ b/lib/keyManagementTwoLevel/api.ts
@@ -0,0 +1,94 @@
+import { generateRecoveryPhrase } from '../keyManagementBIP39'
+import type { EncryptedPayload } from '../keyManagementEncryption'
+import { generateKEK } from './crypto'
+import { decryptKEK, encryptKEK } from './kekEncryption'
+import { storeEncryptedKEK, getEncryptedKEK } from './credentials'
+import { decryptPrivateKeyWithKEK, encryptPrivateKeyWithKEK } from './privateKeyEncryption'
+
+export interface CreateAccountResult {
+  recoveryPhrase: string[]
+  npub: string
+  publicKey: string
+}
+
+export interface UnlockAccountResult {
+  privateKey: string
+  publicKey: string
+  npub: string
+}
+
+export async function createAccountTwoLevel(
+  privateKeyHex: string,
+  getPublicKey: (secretKey: Uint8Array) => string,
+  encodeNpub: (publicKey: string) => string
+): Promise<CreateAccountResult> {
+  const recoveryPhrase = generateRecoveryPhrase()
+  const kek = await generateKEK()
+  const encryptedPrivateKey = await encryptPrivateKeyWithKEK(privateKeyHex, kek)
+  const encryptedKEK = await encryptKEK(kek, recoveryPhrase)
+  await storeEncryptedKEK(encryptedKEK)
+  const { storageService } = await import('../storage/indexedDB')
+  await storageService.set('nostr_encrypted_key', encryptedPrivateKey, 'nostr_key_storage')
+  const { hexToBytes } = await import('nostr-tools/utils')
+  const secretKey = hexToBytes(privateKeyHex)
+  const publicKey = getPublicKey(secretKey)
+  const npub = encodeNpub(publicKey)
+  await storageService.set('nostr_public_key', { publicKey, npub }, 'nostr_key_storage')
+  await storageService.set('nostr_account_exists', true, 'nostr_key_storage')
+  return { recoveryPhrase, npub, publicKey }
+}
+
+export async function unlockAccountTwoLevel(
+  recoveryPhrase: string[],
+  getPublicKey: (secretKey: Uint8Array) => string,
+  encodeNpub: (publicKey: string) => string
+): Promise<UnlockAccountResult> {
+  const encryptedKEK = await getEncryptedKEK()
+  if (!encryptedKEK) {
+    throw new Error('No encrypted KEK found in Credentials API')
+  }
+  const kek = await decryptKEK(encryptedKEK, recoveryPhrase)
+  recoveryPhrase.fill('')
+  const { storageService: indexedDBStorage } = await import('../storage/indexedDB')
+  const encryptedPrivateKey = await indexedDBStorage.get<EncryptedPayload>('nostr_encrypted_key', 'nostr_key_storage')
+  if (!encryptedPrivateKey) {
+    throw new Error('No encrypted private key found in IndexedDB')
+  }
+  const privateKeyHex = await decryptPrivateKeyWithKEK(encryptedPrivateKey, kek)
+  const { hexToBytes } = await import('nostr-tools/utils')
+  const secretKey = hexToBytes(privateKeyHex)
+  const publicKey = getPublicKey(secretKey)
+  const npub = encodeNpub(publicKey)
+  return { privateKey: privateKeyHex, publicKey, npub }
+}
+
+export async function accountExistsTwoLevel(): Promise<boolean> {
+  try {
+    const { storageService: indexedDBStorage } = await import('../storage/indexedDB')
+    const exists = await indexedDBStorage.get<boolean>('nostr_account_exists', 'nostr_key_storage')
+    return exists === true
+  } catch (e) {
+    console.error('[keyManagementTwoLevel] Error checking account existence:', e)
+    return false
+  }
+}
+
+export async function getPublicKeysTwoLevel(): Promise<{ publicKey: string; npub: string } | null> {
+  try {
+    const { storageService: indexedDBStorage } = await import('../storage/indexedDB')
+    return indexedDBStorage.get<{ publicKey: string; npub: string }>('nostr_public_key', 'nostr_key_storage')
+  } catch (e) {
+    console.error('[keyManagementTwoLevel] Error reading public keys:', e)
+    return null
+  }
+}
+
+export async function deleteAccountTwoLevel(): Promise<void> {
+  const { storageService: indexedDBStorage } = await import('../storage/indexedDB')
+  await indexedDBStorage.delete('nostr_encrypted_key')
+  await indexedDBStorage.delete('nostr_public_key')
+  await indexedDBStorage.delete('nostr_account_exists')
+  if (navigator.credentials?.preventSilentAccess) {
+    void navigator.credentials.preventSilentAccess()
+  }
+}
diff --git a/lib/keyManagementTwoLevel/credentials.ts b/lib/keyManagementTwoLevel/credentials.ts
new file mode 100644
index 0000000..38cacfb
--- /dev/null
+++ b/lib/keyManagementTwoLevel/credentials.ts
@@ -0,0 +1,51 @@
+import type { EncryptedPayload } from '../keyManagementEncryption'
+
+type PasswordCredentialData = {
+  id: string
+  name: string
+  password: string
+  iconURL?: string
+}
+
+type PasswordCredentialType = new (data: PasswordCredentialData) => Credential & { id: string; password: string }
+
+function getPasswordCredentialConstructor(): PasswordCredentialType | undefined {
+  if (typeof window === 'undefined') {
+    return undefined
+  }
+  const ctor = (window as unknown as { PasswordCredential?: PasswordCredentialType }).PasswordCredential
+  return ctor
+}
+
+export async function storeEncryptedKEK(encryptedKEK: EncryptedPayload): Promise<void> {
+  if (typeof window === 'undefined') {
+    throw new Error('Window not available')
+  }
+  const PasswordCredentialConstructor = getPasswordCredentialConstructor()
+  if (!PasswordCredentialConstructor || !navigator.credentials?.store) {
+    throw new Error('PasswordCredential API not available')
+  }
+  const credential = new PasswordCredentialConstructor({
+    id: 'nostr_kek',
+    name: 'Nostr KEK',
+    password: JSON.stringify(encryptedKEK),
+    iconURL: `${window.location.origin}/favicon.ico`,
+  })
+  await navigator.credentials.store(credential)
+}
+
+export async function getEncryptedKEK(): Promise<EncryptedPayload | null> {
+  if (typeof window === 'undefined' || !navigator.credentials?.get) {
+    return null
+  }
+  try {
+    const credential = await navigator.credentials.get({ password: true } as CredentialRequestOptions)
+    if (credential && 'password' in credential && typeof credential.password === 'string' && credential.id === 'nostr_kek') {
+      return JSON.parse(credential.password) as EncryptedPayload
+    }
+    return null
+  } catch (e) {
+    console.error('[keyManagementTwoLevel] Error retrieving encrypted KEK:', e)
+    return null
+  }
+}
diff --git a/lib/keyManagementTwoLevel/crypto.ts b/lib/keyManagementTwoLevel/crypto.ts
new file mode 100644
index 0000000..30b6036
--- /dev/null
+++ b/lib/keyManagementTwoLevel/crypto.ts
@@ -0,0 +1,60 @@
+import { bytesToHex, hexToBytes } from './encoding'
+
+const PBKDF2_ITERATIONS = 100000
+const PBKDF2_HASH = 'SHA-256'
+
+export async function generateKEK(): Promise<CryptoKey> {
+  return globalThis.crypto.subtle.generateKey({ name: 'AES-GCM', length: 256 }, true, ['encrypt', 'decrypt'])
+}
+
+export async function deriveKeyFromPhrase(phrase: string[]): Promise<CryptoKey> {
+  const phraseString = phrase.join(' ')
+  const encoder = new TextEncoder()
+  const password = encoder.encode(phraseString)
+  const saltBuffer = await globalThis.crypto.subtle.digest('SHA-256', password)
+  const salt = new Uint8Array(saltBuffer).slice(0, 32)
+  const keyMaterial = await globalThis.crypto.subtle.importKey('raw', password, 'PBKDF2', false, ['deriveBits', 'deriveKey'])
+  return globalThis.crypto.subtle.deriveKey(
+    { name: 'PBKDF2', salt, iterations: PBKDF2_ITERATIONS, hash: PBKDF2_HASH },
+    keyMaterial,
+    { name: 'AES-GCM', length: 256 },
+    false,
+    ['encrypt', 'decrypt']
+  )
+}
+
+export async function exportKEK(kek: CryptoKey): Promise<Uint8Array> {
+  const exported = await globalThis.crypto.subtle.exportKey('raw', kek)
+  return new Uint8Array(exported)
+}
+
+export async function importKEK(keyBytes: Uint8Array): Promise<CryptoKey> {
+  const buffer = new ArrayBuffer(keyBytes.length)
+  new Uint8Array(buffer).set(keyBytes)
+  return globalThis.crypto.subtle.importKey('raw', buffer, { name: 'AES-GCM' }, false, ['encrypt', 'decrypt'])
+}
+
+export async function encryptWithAesGcm(params: { key: CryptoKey; plaintext: Uint8Array }): Promise<{ iv: Uint8Array; ciphertext: Uint8Array }> {
+  const iv = globalThis.crypto.getRandomValues(new Uint8Array(12))
+  const encrypted = await globalThis.crypto.subtle.encrypt({ name: 'AES-GCM', iv }, params.key, params.plaintext)
+  return { iv, ciphertext: new Uint8Array(encrypted) }
+}
+
+export async function decryptWithAesGcm(params: { key: CryptoKey; iv: Uint8Array; ciphertext: Uint8Array }): Promise<Uint8Array> {
+  const ivBuffer = new ArrayBuffer(params.iv.length)
+  new Uint8Array(ivBuffer).set(params.iv)
+  const cipherBuffer = new ArrayBuffer(params.ciphertext.length)
+  new Uint8Array(cipherBuffer).set(params.ciphertext)
+  const decrypted = await globalThis.crypto.subtle.decrypt({ name: 'AES-GCM', iv: new Uint8Array(ivBuffer) }, params.key, cipherBuffer)
+  return new Uint8Array(decrypted)
+}
+
+export function encodeKekBytesForStorage(bytes: Uint8Array): Uint8Array {
+  const encoder = new TextEncoder()
+  return encoder.encode(bytesToHex(bytes))
+}
+
+export function decodeKekBytesFromStorage(payload: Uint8Array): Uint8Array {
+  const decoder = new TextDecoder()
+  return hexToBytes(decoder.decode(payload))
+}
diff --git a/lib/keyManagementTwoLevel/encoding.ts b/lib/keyManagementTwoLevel/encoding.ts
new file mode 100644
index 0000000..cea899f
--- /dev/null
+++ b/lib/keyManagementTwoLevel/encoding.ts
@@ -0,0 +1,30 @@
+export function bytesToBase64(bytes: Uint8Array): string {
+  let binary = ''
+  bytes.forEach((b) => {
+    binary += String.fromCharCode(b)
+  })
+  return globalThis.btoa(binary)
+}
+
+export function base64ToBytes(value: string): Uint8Array {
+  const binary = globalThis.atob(value)
+  const bytes = new Uint8Array(binary.length)
+  for (let i = 0; i < binary.length; i += 1) {
+    bytes[i] = binary.charCodeAt(i)
+  }
+  return bytes
+}
+
+export function bytesToHex(bytes: Uint8Array): string {
+  return Array.from(bytes)
+    .map((b) => b.toString(16).padStart(2, '0'))
+    .join('')
+}
+
+export function hexToBytes(hexString: string): Uint8Array {
+  const parts = hexString.match(/.{1,2}/g)
+  if (!parts) {
+    return new Uint8Array([])
+  }
+  return new Uint8Array(parts.map((part) => Number.parseInt(part, 16)))
+}
diff --git a/lib/keyManagementTwoLevel/kekEncryption.ts b/lib/keyManagementTwoLevel/kekEncryption.ts
new file mode 100644
index 0000000..1c48979
--- /dev/null
+++ b/lib/keyManagementTwoLevel/kekEncryption.ts
@@ -0,0 +1,20 @@
+import type { EncryptedPayload } from '../keyManagementEncryption'
+import { base64ToBytes, bytesToBase64 } from './encoding'
+import { decodeKekBytesFromStorage, decryptWithAesGcm, deriveKeyFromPhrase, encodeKekBytesForStorage, encryptWithAesGcm, exportKEK, importKEK } from './crypto'
+
+export async function encryptKEK(kek: CryptoKey, recoveryPhrase: string[]): Promise<EncryptedPayload> {
+  const phraseKey = await deriveKeyFromPhrase(recoveryPhrase)
+  const kekBytes = await exportKEK(kek)
+  const plaintext = encodeKekBytesForStorage(kekBytes)
+  const { iv, ciphertext } = await encryptWithAesGcm({ key: phraseKey, plaintext })
+  return { iv: bytesToBase64(iv), ciphertext: bytesToBase64(ciphertext) }
+}
+
+export async function decryptKEK(encryptedKEK: EncryptedPayload, recoveryPhrase: string[]): Promise<CryptoKey> {
+  const phraseKey = await deriveKeyFromPhrase(recoveryPhrase)
+  const iv = base64ToBytes(encryptedKEK.iv)
+  const ciphertext = base64ToBytes(encryptedKEK.ciphertext)
+  const decrypted = await decryptWithAesGcm({ key: phraseKey, iv, ciphertext })
+  const kekBytes = decodeKekBytesFromStorage(decrypted)
+  return importKEK(kekBytes)
+}
diff --git a/lib/keyManagementTwoLevel/privateKeyEncryption.ts b/lib/keyManagementTwoLevel/privateKeyEncryption.ts
new file mode 100644
index 0000000..3becdee
--- /dev/null
+++ b/lib/keyManagementTwoLevel/privateKeyEncryption.ts
@@ -0,0 +1,18 @@
+import type { EncryptedPayload } from '../keyManagementEncryption'
+import { base64ToBytes, bytesToBase64 } from './encoding'
+import { decryptWithAesGcm, encryptWithAesGcm } from './crypto'
+
+export async function encryptPrivateKeyWithKEK(privateKey: string, kek: CryptoKey): Promise<EncryptedPayload> {
+  const encoder = new TextEncoder()
+  const plaintext = encoder.encode(privateKey)
+  const { iv, ciphertext } = await encryptWithAesGcm({ key: kek, plaintext })
+  return { iv: bytesToBase64(iv), ciphertext: bytesToBase64(ciphertext) }
+}
+
+export async function decryptPrivateKeyWithKEK(encryptedPrivateKey: EncryptedPayload, kek: CryptoKey): Promise<string> {
+  const iv = base64ToBytes(encryptedPrivateKey.iv)
+  const ciphertext = base64ToBytes(encryptedPrivateKey.ciphertext)
+  const decrypted = await decryptWithAesGcm({ key: kek, iv, ciphertext })
+  const decoder = new TextDecoder()
+  return decoder.decode(decrypted)
+}
diff --git a/lib/markdownRenderer.tsx b/lib/markdownRenderer.tsx
index 693f9b8..7d3f942 100644
--- a/lib/markdownRenderer.tsx
+++ b/lib/markdownRenderer.tsx
@@ -2,7 +2,7 @@ import React from 'react'
 import Link from 'next/link'
 
 interface RenderState {
-  currentList: string[]
+  currentList: Array<{ key: string; line: string }>
   inCodeBlock: boolean
   codeBlockContent: string[]
 }
@@ -41,7 +41,7 @@ function processLine(line: string, index: number, state: RenderState, elements:
   if (renderHeading(line, index, elements)) {
     return
   }
-  if (renderListLine(line, state)) {
+  if (renderListLine(line, index, state)) {
     return
   }
   if (renderLinkLine(line, index, elements)) {
@@ -73,9 +73,9 @@ function renderHeading(line: string, index: number, elements: React.ReactElement
   return false
 }
 
-function renderListLine(line: string, state: RenderState): boolean {
+function renderListLine(line: string, index: number, state: RenderState): boolean {
   if (line.startsWith('- ') || line.startsWith('* ')) {
-    state.currentList.push(line)
+    state.currentList.push({ key: `li-${index}-${line}`, line })
     return true
   }
   return false
@@ -140,8 +140,8 @@ function closeListIfNeeded(
   if (state.currentList.length > 0 && !line.startsWith('- ') && !line.startsWith('* ') && line.trim() !== '') {
     elements.push(
       <ul key={`list-${index}`} className="list-disc list-inside mb-4 space-y-1 text-cyber-accent marker:text-neon-cyan">
-        {state.currentList.map((item, i) => (
-          <li key={i} className="ml-4">{item.substring(2).trim()}</li>
+        {state.currentList.map((item) => (
+          <li key={item.key} className="ml-4">{item.line.substring(2).trim()}</li>
         ))}
       </ul>
     )
@@ -226,9 +226,12 @@ function renderBoldAndCode(line: string, index: number, elements: React.ReactEle
 
 function processBold(text: string, parts: (string | React.ReactElement)[]): void {
   const boldParts = text.split(/(\*\*[^*]+\*\*)/g)
-  boldParts.forEach((part, i) => {
+  const seen = new Map<string, number>()
+  boldParts.forEach((part) => {
     if (part.startsWith('**') && part.endsWith('**')) {
-      parts.push(<strong key={`bold-${i}`} className="text-neon-green font-semibold">{part.slice(2, -2)}</strong>)
+      const count = (seen.get(part) ?? 0) + 1
+      seen.set(part, count)
+      parts.push(<strong key={`bold-${count}-${part}`} className="text-neon-green font-semibold">{part.slice(2, -2)}</strong>)
     } else if (part) {
       parts.push(part)
     }
diff --git a/lib/metadataExtractor.ts b/lib/metadataExtractor.ts
index 709d16b..665ad04 100644
--- a/lib/metadataExtractor.ts
+++ b/lib/metadataExtractor.ts
@@ -1,751 +1 @@
-/**
- * Extract objects from invisible metadata in Nostr notes
- * Objects are stored in [Metadata JSON] sections in the note content
- */
-
-import type { Event } from 'nostr-tools'
-import { extractTagsFromEvent } from './nostrTagSystem'
-import { generateAuthorHashId, generateSeriesHashId, generatePublicationHashId, generateReviewHashId, generatePurchaseHashId, generateReviewTipHashId, generateSponsoringHashId } from './hashIdGenerator'
-
-export interface ExtractedAuthor {
-  type: 'author'
-  id: string
-  pubkey: string
-  authorName: string
-  presentation: string
-  contentDescription: string
-  mainnetAddress?: string
-  pictureUrl?: string
-  category: string
-  url?: string
-  eventId: string
-}
-
-export interface ExtractedSeries {
-  type: 'series'
-  id: string
-  pubkey: string
-  title: string
-  description: string
-  preview?: string
-  coverUrl?: string
-  category: string
-  eventId: string
-}
-
-export interface ExtractedPublication {
-  type: 'publication'
-  id: string
-  pubkey: string
-  title: string
-  preview: string
-  category: string
-  seriesId?: string
-  bannerUrl?: string
-  zapAmount: number
-  eventId: string
-}
-
-export interface ExtractedReview {
-  type: 'review'
-  id: string
-  pubkey: string
-  articleId: string
-  reviewerPubkey: string
-  content: string
-  title?: string
-  eventId: string
-}
-
-export interface ExtractedPurchase {
-  type: 'purchase'
-  id: string
-  payerPubkey: string
-  articleId: string
-  authorPubkey: string
-  amount: number
-  paymentHash: string
-  eventId: string
-}
-
-export interface ExtractedReviewTip {
-  type: 'review_tip'
-  id: string
-  payerPubkey: string
-  articleId: string
-  reviewId: string
-  reviewerPubkey: string
-  authorPubkey: string
-  amount: number
-  paymentHash: string
-  eventId: string
-}
-
-export interface ExtractedSponsoring {
-  type: 'sponsoring'
-  id: string
-  payerPubkey: string
-  authorPubkey: string
-  seriesId?: string
-  articleId?: string
-  amount: number
-  paymentHash: string
-  eventId: string
-}
-
-export type ExtractedObject =
-  | ExtractedAuthor
-  | ExtractedSeries
-  | ExtractedPublication
-  | ExtractedReview
-  | ExtractedPurchase
-  | ExtractedReviewTip
-  | ExtractedSponsoring
-
-/**
- * Extract JSON metadata from note content
- */
-function extractMetadataJsonFromTag(event: { tags: string[][] }): Record<string, unknown> | null {
-  const jsonTag = event.tags.find((tag) => tag[0] === 'json')
-  if (jsonTag?.[1]) {
-    try {
-      const parsed: unknown = JSON.parse(jsonTag[1])
-      return isRecord(parsed) ? parsed : null
-    } catch (e) {
-      console.error('Error parsing JSON metadata from tag:', e)
-      return null
-    }
-  }
-  return null
-}
-
-function extractMetadataJson(content: string): Record<string, unknown> | null {
-  // Try invisible format first (with zero-width characters) - for backward compatibility
-  const invisibleJsonMatch = content.match(/[\u200B\u200C]\[Metadata JSON\][\u200B\u200C]\n[\u200B\u200C](.+)[\u200B\u200C]$/s)
-  if (invisibleJsonMatch?.[1]) {
-    try {
-      // Remove zero-width characters from JSON
-      const cleanedJson = invisibleJsonMatch[1].replace(/[\u200B\u200C\u200D\u200E\u200F]/g, '').trim()
-      const parsed: unknown = JSON.parse(cleanedJson)
-      return isRecord(parsed) ? parsed : null
-    } catch (e) {
-      console.error('Error parsing metadata JSON from invisible content:', e)
-    }
-  }
-
-  // Fallback to visible format (for backward compatibility)
-  const jsonMatch = content.match(/\[Metadata JSON\]\n(.+)$/s)
-  if (jsonMatch?.[1]) {
-    try {
-      const parsed: unknown = JSON.parse(jsonMatch[1].trim())
-      return isRecord(parsed) ? parsed : null
-    } catch (e) {
-      console.error('Error parsing metadata JSON from content:', e)
-      return null
-    }
-  }
-  return null
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null && !Array.isArray(value)
-}
-
-/**
- * Extract author from event
- */
-export async function extractAuthorFromEvent(event: Event): Promise<ExtractedAuthor | null> {
-  const tags = extractTagsFromEvent(event)
-  if (tags.type !== 'author') {
-    return null
-  }
-
-  const metadata = getMetadataFromEvent(event)
-  if (metadata?.type === 'author') {
-    const authorData = buildAuthorDataFromMetadata({ event, tags, metadata })
-    const id = await generateAuthorHashId(authorData)
-    return buildExtractedAuthor({ eventId: event.id, id, data: authorData, metadata })
-  }
-
-  // Fallback: extract from tags and visible content
-  // This is a simplified extraction - full data should be in metadata JSON
-  return null
-}
-
-function buildAuthorDataFromMetadata(params: {
-  event: Event
-  tags: ReturnType<typeof extractTagsFromEvent>
-  metadata: Record<string, unknown>
-}): {
-  pubkey: string
-  authorName: string
-  presentation: string
-  contentDescription: string
-  mainnetAddress?: string
-  pictureUrl?: string
-  category: string
-} {
-  const pubkey = firstString(params.metadata.pubkey, params.event.pubkey) ?? params.event.pubkey
-  const mainnetAddress = firstString(params.metadata.mainnetAddress)
-  const pictureUrl = firstString(params.metadata.pictureUrl)
-  return {
-    pubkey,
-    authorName: firstString(params.metadata.authorName) ?? '',
-    presentation: firstString(params.metadata.presentation) ?? '',
-    contentDescription: firstString(params.metadata.contentDescription) ?? '',
-    ...(mainnetAddress ? { mainnetAddress } : {}),
-    ...(pictureUrl ? { pictureUrl } : {}),
-    category: firstString(params.metadata.category, params.tags.category, 'sciencefiction') ?? 'sciencefiction',
-  }
-}
-
-function buildExtractedAuthor(params: {
-  eventId: string
-  id: string
-  data: {
-    pubkey: string
-    authorName: string
-    presentation: string
-    contentDescription: string
-    mainnetAddress?: string
-    pictureUrl?: string
-    category: string
-  }
-  metadata: Record<string, unknown>
-}): ExtractedAuthor {
-  const url = firstString(params.metadata.url)
-  return {
-    type: 'author',
-    id: params.id,
-    pubkey: params.data.pubkey,
-    authorName: params.data.authorName,
-    presentation: params.data.presentation,
-    contentDescription: params.data.contentDescription,
-    category: params.data.category,
-    eventId: params.eventId,
-    ...(params.data.mainnetAddress ? { mainnetAddress: params.data.mainnetAddress } : {}),
-    ...(params.data.pictureUrl ? { pictureUrl: params.data.pictureUrl } : {}),
-    ...(url ? { url } : {}),
-  }
-}
-
-function firstString(...values: unknown[]): string | undefined {
-  for (const value of values) {
-    if (typeof value === 'string') {
-      return value
-    }
-  }
-  return undefined
-}
-
-/**
- * Extract series from event
- */
-export async function extractSeriesFromEvent(event: Event): Promise<ExtractedSeries | null> {
-  const tags = extractTagsFromEvent(event)
-  if (tags.type !== 'series') {
-    return null
-  }
-
-  const metadata = getMetadataFromEvent(event)
-  if (metadata?.type === 'series') {
-    const seriesData = buildSeriesDataFromMetadata({ event, tags, metadata })
-    const id = await generateSeriesHashId(seriesData)
-    return buildExtractedSeries({ eventId: event.id, id, data: seriesData })
-  }
-
-  // Fallback: extract from tags
-  if (tags.title && tags.description) {
-    const seriesData = {
-      pubkey: event.pubkey,
-      title: tags.title,
-      description: tags.description,
-      preview: (tags.preview as string) ?? event.content.substring(0, 200),
-      category: tags.category ?? 'sciencefiction',
-    }
-    const seriesDataWithOptionals = {
-      ...seriesData,
-      ...(tags.coverUrl ? { coverUrl: tags.coverUrl } : {}),
-    }
-
-    const id = await generateSeriesHashId(seriesDataWithOptionals)
-    return buildExtractedSeries({ eventId: event.id, id, data: seriesDataWithOptionals })
-  }
-
-  return null
-}
-
-/**
- * Extract publication from event
- */
-export async function extractPublicationFromEvent(event: Event): Promise<ExtractedPublication | null> {
-  const tags = extractTagsFromEvent(event)
-  if (tags.type !== 'publication') {
-    return null
-  }
-
-  const metadata = getMetadataFromEvent(event)
-  if (metadata?.type === 'publication') {
-    const publicationData = buildPublicationDataFromMetadata({ event, tags, metadata })
-    const id = await generatePublicationHashId(publicationData)
-    const pages = readPublicationPages(metadata)
-    return buildExtractedPublication({ eventId: event.id, id, data: publicationData, pages })
-  }
-
-  // Fallback: extract from tags
-  if (tags.title) {
-    const publicationData = {
-      pubkey: event.pubkey,
-      title: tags.title,
-      preview: (tags.preview as string) ?? event.content.substring(0, 200),
-      category: tags.category ?? 'sciencefiction',
-      zapAmount: tags.zapAmount ?? 800,
-    }
-    const publicationDataWithOptionals = {
-      ...publicationData,
-      ...(tags.seriesId ? { seriesId: tags.seriesId } : {}),
-      ...(tags.bannerUrl ? { bannerUrl: tags.bannerUrl } : {}),
-    }
-
-    const id = await generatePublicationHashId(publicationDataWithOptionals)
-    return buildExtractedPublication({ eventId: event.id, id, data: publicationDataWithOptionals, pages: undefined })
-  }
-
-  return null
-}
-
-/**
- * Extract review from event
- */
-export async function extractReviewFromEvent(event: Event): Promise<ExtractedReview | null> {
-  const tags = extractTagsFromEvent(event)
-  if (tags.type !== 'quote') {
-    return null
-  }
-
-  const metadata = getMetadataFromEvent(event)
-  const fromMetadata = await extractReviewFromMetadata({ event, tags, metadata })
-  if (fromMetadata) {
-    return fromMetadata
-  }
-
-  return extractReviewFromTags({ event, tags })
-}
-
-async function extractReviewFromMetadata(params: {
-  event: Event
-  tags: ReturnType<typeof extractTagsFromEvent>
-  metadata: Record<string, unknown> | null
-}): Promise<ExtractedReview | null> {
-  if (params.metadata?.type !== 'review') {
-    return null
-  }
-  const reviewData = buildReviewDataFromMetadata({ event: params.event, tags: params.tags, metadata: params.metadata })
-  if (!reviewData) {
-    return null
-  }
-  const id = await generateReviewHashId(reviewData)
-  return { type: 'review', id, ...reviewData, eventId: params.event.id }
-}
-
-async function extractReviewFromTags(params: {
-  event: Event
-  tags: ReturnType<typeof extractTagsFromEvent>
-}): Promise<ExtractedReview | null> {
-  if (!params.tags.articleId || !params.tags.reviewerPubkey) {
-    return null
-  }
-  const base = {
-    pubkey: params.event.pubkey,
-    articleId: params.tags.articleId,
-    reviewerPubkey: params.tags.reviewerPubkey,
-    content: params.event.content,
-    ...(params.tags.title ? { title: params.tags.title } : {}),
-  }
-  return buildExtractedReviewFromTags({ ...base, eventId: params.event.id })
-}
-
-async function buildExtractedReviewFromTags(params: {
-  pubkey: string
-  articleId: string
-  reviewerPubkey: string
-  content: string
-  title?: string
-  eventId: string
-}): Promise<ExtractedReview> {
-  const id = await generateReviewHashId({
-    pubkey: params.pubkey,
-    articleId: params.articleId,
-    reviewerPubkey: params.reviewerPubkey,
-    content: params.content,
-    ...(params.title ? { title: params.title } : {}),
-  })
-  return {
-    type: 'review',
-    id,
-    pubkey: params.pubkey,
-    articleId: params.articleId,
-    reviewerPubkey: params.reviewerPubkey,
-    content: params.content,
-    eventId: params.eventId,
-    ...(params.title ? { title: params.title } : {}),
-  }
-}
-
-function getMetadataFromEvent(event: Event): Record<string, unknown> | null {
-  return extractMetadataJsonFromTag(event) ?? extractMetadataJson(event.content)
-}
-
-function buildSeriesDataFromMetadata(params: {
-  event: Event
-  tags: ReturnType<typeof extractTagsFromEvent>
-  metadata: Record<string, unknown>
-}): { pubkey: string; title: string; description: string; preview: string; coverUrl?: string; category: string } {
-  const title = firstString(params.metadata.title, params.tags.title) ?? ''
-  const preview = firstString(params.metadata.preview, params.tags.preview) ?? params.event.content.substring(0, 200)
-  const pubkey = firstString(params.metadata.pubkey, params.event.pubkey) ?? params.event.pubkey
-  const coverUrl = firstString(params.metadata.coverUrl, params.tags.coverUrl)
-
-  const result: { pubkey: string; title: string; description: string; preview: string; coverUrl?: string; category: string } = {
-    pubkey,
-    title,
-    description: firstString(params.metadata.description) ?? '',
-    preview,
-    category: firstString(params.metadata.category, params.tags.category, 'sciencefiction') ?? 'sciencefiction',
-  }
-  if (coverUrl) {
-    result.coverUrl = coverUrl
-  }
-  return result
-}
-
-function buildExtractedSeries(params: {
-  eventId: string
-  id: string
-  data: { pubkey: string; title: string; description: string; preview: string; coverUrl?: string; category: string }
-}): ExtractedSeries {
-  return {
-    type: 'series',
-    id: params.id,
-    pubkey: params.data.pubkey,
-    title: params.data.title,
-    description: params.data.description,
-    category: params.data.category,
-    eventId: params.eventId,
-    ...(params.data.coverUrl ? { coverUrl: params.data.coverUrl } : {}),
-    ...(params.data.preview ? { preview: params.data.preview } : {}),
-  }
-}
-
-function buildPublicationDataFromMetadata(params: {
-  event: Event
-  tags: ReturnType<typeof extractTagsFromEvent>
-  metadata: Record<string, unknown>
-}): {
-  pubkey: string
-  title: string
-  preview: string
-  category: string
-  seriesId?: string
-  bannerUrl?: string
-  zapAmount: number
-} {
-  const result: {
-    pubkey: string
-    title: string
-    preview: string
-    category: string
-    seriesId?: string
-    bannerUrl?: string
-    zapAmount: number
-  } = {
-    pubkey: firstString(params.metadata.pubkey, params.event.pubkey) ?? params.event.pubkey,
-    title: firstString(params.metadata.title, params.tags.title) ?? '',
-    preview: firstString(params.metadata.preview, params.tags.preview) ?? params.event.content.substring(0, 200),
-    category: firstString(params.metadata.category, params.tags.category, 'sciencefiction') ?? 'sciencefiction',
-    zapAmount: firstNumber(params.metadata.zapAmount, params.tags.zapAmount) ?? 800,
-  }
-
-  const seriesId = firstString(params.metadata.seriesId, params.tags.seriesId)
-  if (seriesId) {
-    result.seriesId = seriesId
-  }
-  const bannerUrl = firstString(params.metadata.bannerUrl, params.tags.bannerUrl)
-  if (bannerUrl) {
-    result.bannerUrl = bannerUrl
-  }
-
-  return result
-}
-
-function readPublicationPages(metadata: Record<string, unknown>): Array<{ number: number; type: 'markdown' | 'image'; content: string }> | undefined {
-  const pages = metadata.pages as Array<{ number: number; type: 'markdown' | 'image'; content: string }> | undefined
-  return pages && Array.isArray(pages) && pages.length > 0 ? pages : undefined
-}
-
-function buildExtractedPublication(params: {
-  eventId: string
-  id: string
-  data: {
-    pubkey: string
-    title: string
-    preview: string
-    category: string
-    seriesId?: string
-    bannerUrl?: string
-    zapAmount: number
-  }
-  pages: Array<{ number: number; type: 'markdown' | 'image'; content: string }> | undefined
-}): ExtractedPublication {
-  return {
-    type: 'publication',
-    id: params.id,
-    pubkey: params.data.pubkey,
-    title: params.data.title,
-    preview: params.data.preview,
-    category: params.data.category,
-    zapAmount: params.data.zapAmount,
-    eventId: params.eventId,
-    ...(params.data.seriesId ? { seriesId: params.data.seriesId } : {}),
-    ...(params.data.bannerUrl ? { bannerUrl: params.data.bannerUrl } : {}),
-    ...(params.pages ? { pages: params.pages } : {}),
-  }
-}
-
-function buildReviewDataFromMetadata(params: {
-  event: Event
-  tags: ReturnType<typeof extractTagsFromEvent>
-  metadata: Record<string, unknown>
-}): { pubkey: string; articleId: string; reviewerPubkey: string; content: string; title?: string } | null {
-  const articleId = firstString(params.metadata.articleId, params.tags.articleId) ?? ''
-  const reviewerPubkey = firstString(params.metadata.reviewerPubkey, params.tags.reviewerPubkey, params.event.pubkey) ?? params.event.pubkey
-  if (!articleId || !reviewerPubkey) {
-    return null
-  }
-  const title = firstString(params.metadata.title, params.tags.title)
-  const base: { pubkey: string; articleId: string; reviewerPubkey: string; content: string; title?: string } = {
-    pubkey: firstString(params.metadata.pubkey, params.event.pubkey) ?? params.event.pubkey,
-    articleId,
-    reviewerPubkey,
-    content: firstString(params.metadata.content, params.event.content) ?? params.event.content,
-  }
-  if (title) {
-    base.title = title
-  }
-  return base
-}
-
-function firstNumber(...values: unknown[]): number | undefined {
-  for (const value of values) {
-    if (typeof value === 'number') {
-      return value
-    }
-  }
-  return undefined
-}
-
-/**
- * Extract purchase from zap receipt (kind 9735)
- */
-export async function extractPurchaseFromEvent(event: Event): Promise<ExtractedPurchase | null> {
-  const kind = readZapReceiptKind(event)
-  if (kind !== 'purchase') {
-    return null
-  }
-
-  const authorPubkey = readTagValue(event, 'p')
-  const articleId = readTagValue(event, 'e')
-  const amountSats = readAmountSats(event)
-  if (!authorPubkey || !articleId || amountSats === undefined) {
-    return null
-  }
-
-  const purchaseData = {
-    payerPubkey: event.pubkey,
-    articleId,
-    authorPubkey,
-    amount: amountSats,
-    paymentHash: readPaymentHash(event),
-  }
-
-  const id = await generatePurchaseHashId(purchaseData)
-  return { type: 'purchase', id, ...purchaseData, eventId: event.id }
-}
-
-/**
- * Extract review tip from zap receipt (kind 9735)
- */
-export async function extractReviewTipFromEvent(event: Event): Promise<ExtractedReviewTip | null> {
-  const kind = readZapReceiptKind(event)
-  if (kind !== 'review_tip') {
-    return null
-  }
-
-  const authorPubkey = readTagValue(event, 'p')
-  const articleId = readTagValue(event, 'e')
-  const reviewId = readTagValue(event, 'review_id')
-  const reviewerPubkey = readTagValue(event, 'reviewer')
-  const amountSats = readAmountSats(event)
-  if (!authorPubkey || !articleId || !reviewId || !reviewerPubkey || amountSats === undefined) {
-    return null
-  }
-
-  const tipData = {
-    payerPubkey: event.pubkey,
-    articleId,
-    reviewId,
-    reviewerPubkey,
-    authorPubkey,
-    amount: amountSats,
-    paymentHash: readPaymentHash(event),
-  }
-
-  const id = await generateReviewTipHashId(tipData)
-  return { type: 'review_tip', id, ...tipData, eventId: event.id }
-}
-
-/**
- * Extract sponsoring from zap receipt (kind 9735)
- */
-export async function extractSponsoringFromEvent(event: Event): Promise<ExtractedSponsoring | null> {
-  const kind = readZapReceiptKind(event)
-  if (kind !== 'sponsoring') {
-    return null
-  }
-
-  const authorPubkey = readTagValue(event, 'p')
-  const amountSats = readAmountSats(event)
-  if (!authorPubkey || amountSats === undefined) {
-    return null
-  }
-
-  const sponsoringData = buildSponsoringData({ event, authorPubkey, amountSats })
-  const id = await generateSponsoringHashId(buildSponsoringHashInput(sponsoringData))
-  return buildExtractedSponsoring({ id, eventId: event.id, sponsoringData })
-}
-
-function buildSponsoringData(params: { event: Event; authorPubkey: string; amountSats: number }): {
-  payerPubkey: string
-  authorPubkey: string
-  seriesId: string | undefined
-  articleId: string | undefined
-  amount: number
-  paymentHash: string
-} {
-  return {
-    payerPubkey: params.event.pubkey,
-    authorPubkey: params.authorPubkey,
-    seriesId: readTagValue(params.event, 'series'),
-    articleId: resolveSponsoringArticleId({
-      articleTag: readTagValue(params.event, 'article'),
-      eTag: readTagValue(params.event, 'e'),
-    }),
-    amount: params.amountSats,
-    paymentHash: readPaymentHash(params.event),
-  }
-}
-
-function buildSponsoringHashInput(params: {
-  payerPubkey: string
-  authorPubkey: string
-  seriesId: string | undefined
-  articleId: string | undefined
-  amount: number
-  paymentHash: string
-}): Parameters<typeof generateSponsoringHashId>[0] {
-  return {
-    payerPubkey: params.payerPubkey,
-    authorPubkey: params.authorPubkey,
-    amount: params.amount,
-    paymentHash: params.paymentHash,
-    ...(params.seriesId ? { seriesId: params.seriesId } : {}),
-    ...(params.articleId ? { articleId: params.articleId } : {}),
-  }
-}
-
-function buildExtractedSponsoring(params: {
-  id: string
-  eventId: string
-  sponsoringData: {
-    payerPubkey: string
-    authorPubkey: string
-    seriesId: string | undefined
-    articleId: string | undefined
-    amount: number
-    paymentHash: string
-  }
-}): ExtractedSponsoring {
-  return {
-    type: 'sponsoring',
-    id: params.id,
-    payerPubkey: params.sponsoringData.payerPubkey,
-    authorPubkey: params.sponsoringData.authorPubkey,
-    amount: params.sponsoringData.amount,
-    paymentHash: params.sponsoringData.paymentHash,
-    eventId: params.eventId,
-    ...(params.sponsoringData.seriesId ? { seriesId: params.sponsoringData.seriesId } : {}),
-    ...(params.sponsoringData.articleId ? { articleId: params.sponsoringData.articleId } : {}),
-  }
-}
-
-function readTagValue(event: Event, key: string): string | undefined {
-  return event.tags.find((tag) => tag[0] === key)?.[1]
-}
-
-function readZapReceiptKind(event: Event): string | undefined {
-  if (event.kind !== 9735) {
-    return undefined
-  }
-  return readTagValue(event, 'kind_type')
-}
-
-function readAmountSats(event: Event): number | undefined {
-  const amountTag = readTagValue(event, 'amount')
-  if (!amountTag) {
-    return undefined
-  }
-  const millisats = parseInt(amountTag, 10)
-  if (Number.isNaN(millisats)) {
-    return undefined
-  }
-  return millisats / 1000
-}
-
-function readPaymentHash(event: Event): string {
-  return readTagValue(event, 'payment_hash') ?? event.id
-}
-
-function resolveSponsoringArticleId(params: { articleTag: string | undefined; eTag: string | undefined }): string | undefined {
-  return params.articleTag ?? params.eTag
-}
-
-/**
- * Extract all objects from an event
- */
-export async function extractObjectsFromEvent(event: Event): Promise<ExtractedObject[]> {
-  const results: ExtractedObject[] = []
-
-  // Try to extract each type
-  const author = await extractAuthorFromEvent(event)
-  if (author) {results.push(author)}
-
-  const series = await extractSeriesFromEvent(event)
-  if (series) {results.push(series)}
-
-  const publication = await extractPublicationFromEvent(event)
-  if (publication) {results.push(publication)}
-
-  const review = await extractReviewFromEvent(event)
-  if (review) {results.push(review)}
-
-  const purchase = await extractPurchaseFromEvent(event)
-  if (purchase) {results.push(purchase)}
-
-  const reviewTip = await extractReviewTipFromEvent(event)
-  if (reviewTip) {results.push(reviewTip)}
-
-  const sponsoring = await extractSponsoringFromEvent(event)
-  if (sponsoring) {results.push(sponsoring)}
-
-  return results
-}
+export * from './metadataExtractor/index'
diff --git a/lib/metadataExtractor/author.ts b/lib/metadataExtractor/author.ts
new file mode 100644
index 0000000..08bdae1
--- /dev/null
+++ b/lib/metadataExtractor/author.ts
@@ -0,0 +1,79 @@
+import type { Event } from 'nostr-tools'
+import { extractTagsFromEvent } from '../nostrTagSystem'
+import { generateAuthorHashId } from '../hashIdGenerator'
+import type { ExtractedAuthor } from './types'
+import { getMetadataFromEvent } from './metadataJson'
+import { firstString } from './utils'
+
+export async function extractAuthorFromEvent(event: Event): Promise<ExtractedAuthor | null> {
+  const tags = extractTagsFromEvent(event)
+  if (tags.type !== 'author') {
+    return null
+  }
+
+  const metadata = getMetadataFromEvent(event)
+  if (metadata?.type !== 'author') {
+    return null
+  }
+
+  const data = buildAuthorDataFromMetadata({ event, tags, metadata })
+  const id = await generateAuthorHashId(data)
+  return buildExtractedAuthor({ eventId: event.id, id, data, metadata })
+}
+
+function buildAuthorDataFromMetadata(params: {
+  event: Event
+  tags: ReturnType<typeof extractTagsFromEvent>
+  metadata: Record<string, unknown>
+}): {
+  pubkey: string
+  authorName: string
+  presentation: string
+  contentDescription: string
+  mainnetAddress?: string
+  pictureUrl?: string
+  category: string
+} {
+  const pubkey = firstString(params.metadata.pubkey, params.event.pubkey) ?? params.event.pubkey
+  const mainnetAddress = firstString(params.metadata.mainnetAddress)
+  const pictureUrl = firstString(params.metadata.pictureUrl)
+  return {
+    pubkey,
+    authorName: firstString(params.metadata.authorName) ?? '',
+    presentation: firstString(params.metadata.presentation) ?? '',
+    contentDescription: firstString(params.metadata.contentDescription) ?? '',
+    ...(mainnetAddress ? { mainnetAddress } : {}),
+    ...(pictureUrl ? { pictureUrl } : {}),
+    category: firstString(params.metadata.category, params.tags.category, 'sciencefiction') ?? 'sciencefiction',
+  }
+}
+
+function buildExtractedAuthor(params: {
+  eventId: string
+  id: string
+  data: {
+    pubkey: string
+    authorName: string
+    presentation: string
+    contentDescription: string
+    mainnetAddress?: string
+    pictureUrl?: string
+    category: string
+  }
+  metadata: Record<string, unknown>
+}): ExtractedAuthor {
+  const url = firstString(params.metadata.url)
+  return {
+    type: 'author',
+    id: params.id,
+    pubkey: params.data.pubkey,
+    authorName: params.data.authorName,
+    presentation: params.data.presentation,
+    contentDescription: params.data.contentDescription,
+    category: params.data.category,
+    eventId: params.eventId,
+    ...(params.data.mainnetAddress ? { mainnetAddress: params.data.mainnetAddress } : {}),
+    ...(params.data.pictureUrl ? { pictureUrl: params.data.pictureUrl } : {}),
+    ...(url ? { url } : {}),
+  }
+}
diff --git a/lib/metadataExtractor/index.ts b/lib/metadataExtractor/index.ts
new file mode 100644
index 0000000..2217b0f
--- /dev/null
+++ b/lib/metadataExtractor/index.ts
@@ -0,0 +1,8 @@
+export type { ExtractedObject } from './types'
+export { extractAuthorFromEvent } from './author'
+export { extractSeriesFromEvent } from './series'
+export { extractPublicationFromEvent } from './publication'
+export { extractReviewFromEvent } from './review'
+export { extractPurchaseFromEvent } from './purchase'
+export { extractSponsoringFromEvent } from './sponsoring'
+export { extractReviewTipFromEvent } from './reviewTip'
diff --git a/lib/metadataExtractor/metadataJson.ts b/lib/metadataExtractor/metadataJson.ts
new file mode 100644
index 0000000..2a125aa
--- /dev/null
+++ b/lib/metadataExtractor/metadataJson.ts
@@ -0,0 +1,46 @@
+import type { MetadataEvent } from './types'
+import { isRecord } from './utils'
+
+export function extractMetadataJsonFromTag(event: MetadataEvent): Record<string, unknown> | null {
+  const jsonTag = event.tags.find((tag) => tag[0] === 'json')
+  if (!jsonTag?.[1]) {
+    return null
+  }
+  try {
+    const parsed: unknown = JSON.parse(jsonTag[1])
+    return isRecord(parsed) ? parsed : null
+  } catch (e) {
+    console.error('[metadataExtractor] Error parsing JSON metadata from tag:', e)
+    return null
+  }
+}
+
+export function extractMetadataJson(content: string): Record<string, unknown> | null {
+  const invisibleJsonMatch = content.match(/[\u200B\u200C]\[Metadata JSON\][\u200B\u200C]\n[\u200B\u200C](.+)[\u200B\u200C]$/s)
+  if (invisibleJsonMatch?.[1]) {
+    try {
+      const cleanedJson = invisibleJsonMatch[1].replace(/[\u200B\u200C\u200D\u200E\u200F]/g, '').trim()
+      const parsed: unknown = JSON.parse(cleanedJson)
+      return isRecord(parsed) ? parsed : null
+    } catch (e) {
+      console.error('[metadataExtractor] Error parsing metadata JSON from invisible content:', e)
+    }
+  }
+
+  const jsonMatch = content.match(/\[Metadata JSON\]\n(.+)$/s)
+  if (jsonMatch?.[1]) {
+    try {
+      const parsed: unknown = JSON.parse(jsonMatch[1].trim())
+      return isRecord(parsed) ? parsed : null
+    } catch (e) {
+      console.error('[metadataExtractor] Error parsing metadata JSON from content:', e)
+      return null
+    }
+  }
+
+  return null
+}
+
+export function getMetadataFromEvent(event: MetadataEvent & { content: string }): Record<string, unknown> | null {
+  return extractMetadataJsonFromTag(event) ?? extractMetadataJson(event.content)
+}
diff --git a/lib/metadataExtractor/publication.ts b/lib/metadataExtractor/publication.ts
new file mode 100644
index 0000000..ebd3391
--- /dev/null
+++ b/lib/metadataExtractor/publication.ts
@@ -0,0 +1,109 @@
+import type { Event } from 'nostr-tools'
+import { extractTagsFromEvent } from '../nostrTagSystem'
+import { generatePublicationHashId } from '../hashIdGenerator'
+import type { ExtractedPublication } from './types'
+import { getMetadataFromEvent } from './metadataJson'
+import { firstNumber, firstString } from './utils'
+
+type PublicationPages = Array<{ number: number; type: 'markdown' | 'image'; content: string }>
+
+export async function extractPublicationFromEvent(event: Event): Promise<ExtractedPublication | null> {
+  const tags = extractTagsFromEvent(event)
+  if (tags.type !== 'publication') {
+    return null
+  }
+  const metadata = getMetadataFromEvent(event)
+  if (metadata?.type === 'publication') {
+    const publicationData = buildPublicationDataFromMetadata({ event, tags, metadata })
+    const id = await generatePublicationHashId(publicationData)
+    const pages = readPublicationPages(metadata)
+    return buildExtractedPublication({ eventId: event.id, id, data: publicationData, pages })
+  }
+  if (!tags.title) {
+    return null
+  }
+  const publicationData = {
+    pubkey: event.pubkey,
+    title: tags.title,
+    preview: (tags.preview as string) ?? event.content.substring(0, 200),
+    category: tags.category ?? 'sciencefiction',
+    zapAmount: tags.zapAmount ?? 800,
+    ...(tags.seriesId ? { seriesId: tags.seriesId } : {}),
+    ...(tags.bannerUrl ? { bannerUrl: tags.bannerUrl } : {}),
+  }
+  const id = await generatePublicationHashId(publicationData)
+  return buildExtractedPublication({ eventId: event.id, id, data: publicationData, pages: undefined })
+}
+
+function buildPublicationDataFromMetadata(params: {
+  event: Event
+  tags: ReturnType<typeof extractTagsFromEvent>
+  metadata: Record<string, unknown>
+}): {
+  pubkey: string
+  title: string
+  preview: string
+  category: string
+  seriesId?: string
+  bannerUrl?: string
+  zapAmount: number
+} {
+  const base: {
+    pubkey: string
+    title: string
+    preview: string
+    category: string
+    seriesId?: string
+    bannerUrl?: string
+    zapAmount: number
+  } = {
+    pubkey: firstString(params.metadata.pubkey, params.event.pubkey) ?? params.event.pubkey,
+    title: firstString(params.metadata.title, params.tags.title) ?? '',
+    preview: firstString(params.metadata.preview, params.tags.preview) ?? params.event.content.substring(0, 200),
+    category: firstString(params.metadata.category, params.tags.category, 'sciencefiction') ?? 'sciencefiction',
+    zapAmount: firstNumber(params.metadata.zapAmount, params.tags.zapAmount) ?? 800,
+  }
+  const seriesId = firstString(params.metadata.seriesId, params.tags.seriesId)
+  if (seriesId) {
+    base.seriesId = seriesId
+  }
+  const bannerUrl = firstString(params.metadata.bannerUrl, params.tags.bannerUrl)
+  if (bannerUrl) {
+    base.bannerUrl = bannerUrl
+  }
+  return base
+}
+
+function readPublicationPages(metadata: Record<string, unknown>): PublicationPages | undefined {
+  const pages = metadata.pages as PublicationPages | undefined
+  return pages && Array.isArray(pages) && pages.length > 0 ? pages : undefined
+}
+
+function buildExtractedPublication(params: {
+  eventId: string
+  id: string
+  data: {
+    pubkey: string
+    title: string
+    preview: string
+    category: string
+    seriesId?: string
+    bannerUrl?: string
+    zapAmount: number
+  }
+  pages: PublicationPages | undefined
+}): ExtractedPublication {
+  return {
+    type: 'publication',
+    id: params.id,
+    pubkey: params.data.pubkey,
+    title: params.data.title,
+    preview: params.data.preview,
+    category: params.data.category,
+    zapAmount: params.data.zapAmount,
+    eventId: params.eventId,
+    ...(params.data.seriesId ? { seriesId: params.data.seriesId } : {}),
+    ...(params.data.bannerUrl ? { bannerUrl: params.data.bannerUrl } : {}),
+    ...(params.pages ? { pages: params.pages } : {}),
+  }
+}
diff --git a/lib/metadataExtractor/purchase.ts b/lib/metadataExtractor/purchase.ts
new file mode 100644
index 0000000..ced4dca
--- /dev/null
+++ b/lib/metadataExtractor/purchase.ts
@@ -0,0 +1,23 @@
+import type { Event } from 'nostr-tools'
+import { generatePurchaseHashId } from '../hashIdGenerator'
+import type { ExtractedPurchase } from './types'
+import { readAmountSats, readPaymentHash, readPayerPubkeyFromZapReceipt, readTagValue, readZapReceiptKind } from './utils'
+
+export async function extractPurchaseFromEvent(event: Event): Promise<ExtractedPurchase | null> {
+  if (event.kind !== 9735 || readZapReceiptKind(event) !== 'purchase') {
+    return null
+  }
+
+  const payerPubkey = readPayerPubkeyFromZapReceipt(event)
+  const authorPubkey = readTagValue(event, 'author') ?? readTagValue(event, 'p')
+  const articleId = readTagValue(event, 'article') ?? readTagValue(event, 'e')
+  const amount = readAmountSats(event)
+  if (!payerPubkey || !authorPubkey || !articleId || amount === undefined) {
+    console.error('[metadataExtractor] Invalid purchase zap receipt: missing required fields', { eventId: event.id })
+    return null
+  }
+
+  const paymentHash = readPaymentHash(event)
+  const id = await generatePurchaseHashId({ payerPubkey, articleId, authorPubkey, amount, paymentHash })
+  return { type: 'purchase', id, payerPubkey, articleId, authorPubkey, amount, paymentHash, eventId: event.id }
+}
diff --git a/lib/metadataExtractor/review.ts b/lib/metadataExtractor/review.ts
new file mode 100644
index 0000000..1c92f3b
--- /dev/null
+++ b/lib/metadataExtractor/review.ts
@@ -0,0 +1,93 @@
+import type { Event } from 'nostr-tools'
+import { extractTagsFromEvent } from '../nostrTagSystem'
+import { generateReviewHashId } from '../hashIdGenerator'
+import type { ExtractedReview } from './types'
+import { getMetadataFromEvent } from './metadataJson'
+import { firstString } from './utils'
+
+export async function extractReviewFromEvent(event: Event): Promise<ExtractedReview | null> {
+  const tags = extractTagsFromEvent(event)
+  if (tags.type !== 'quote') {
+    return null
+  }
+
+  const metadata = getMetadataFromEvent(event)
+  const fromMetadata = await extractReviewFromMetadata({ event, tags, metadata })
+  if (fromMetadata) {
+    return fromMetadata
+  }
+
+  return extractReviewFromTags({ event, tags })
+}
+
+async function extractReviewFromMetadata(params: {
+  event: Event
+  tags: ReturnType<typeof extractTagsFromEvent>
+  metadata: Record<string, unknown> | null
+}): Promise<ExtractedReview | null> {
+  if (params.metadata?.type !== 'review') {
+    return null
+  }
+  const reviewData = buildReviewDataFromMetadata({ event: params.event, tags: params.tags, metadata: params.metadata })
+  if (!reviewData) {
+    return null
+  }
+  const id = await generateReviewHashId(reviewData)
+  return { type: 'review', id, ...reviewData, eventId: params.event.id }
+}
+
+async function extractReviewFromTags(params: { event: Event; tags: ReturnType<typeof extractTagsFromEvent> }): Promise<ExtractedReview | null> {
+  if (!params.tags.articleId || !params.tags.reviewerPubkey) {
+    return null
+  }
+  const base = {
+    pubkey: params.event.pubkey,
+    articleId: params.tags.articleId,
+    reviewerPubkey: params.tags.reviewerPubkey,
+    content: params.event.content,
+    ...(params.tags.title ? { title: params.tags.title } : {}),
+    eventId: params.event.id,
+  }
+  return buildExtractedReviewFromTags(base)
+}
+
+function buildReviewDataFromMetadata(params: {
+  event: Event
+  tags: ReturnType<typeof extractTagsFromEvent>
+  metadata: Record<string, unknown>
+}): { pubkey: string; articleId: string; reviewerPubkey: string; content: string; title?: string } | null {
+  const articleId = firstString(params.metadata.articleId, params.tags.articleId) ?? ''
+  const reviewerPubkey = firstString(params.metadata.reviewerPubkey, params.tags.reviewerPubkey, params.event.pubkey) ?? params.event.pubkey
+  if (!articleId || !reviewerPubkey) {
+    return null
+  }
+  const title = firstString(params.metadata.title, params.tags.title)
+  const base: { pubkey: string; articleId: string; reviewerPubkey: string; content: string; title?: string } = {
+    pubkey: firstString(params.metadata.pubkey, params.event.pubkey) ?? params.event.pubkey,
+    articleId,
+    reviewerPubkey,
+    content: firstString(params.metadata.content, params.event.content) ?? params.event.content,
+  }
+  if (title) {
+    base.title = title
+  }
+  return base
+}
+
+async function buildExtractedReviewFromTags(params: {
+  pubkey: string
+  articleId: string
+  reviewerPubkey: string
+  content: string
+  title?: string
+  eventId: string
+}): Promise<ExtractedReview> {
+  const id = await generateReviewHashId({
+    pubkey: params.pubkey,
+    articleId: params.articleId,
+    reviewerPubkey: params.reviewerPubkey,
+    content: params.content,
+    ...(params.title ? { title: params.title } : {}),
+  })
+  return { type: 'review', id, pubkey: params.pubkey, articleId: params.articleId, reviewerPubkey: params.reviewerPubkey, content: params.content, eventId: params.eventId, ...(params.title ? { title: params.title } : {}) }
+}
diff --git a/lib/metadataExtractor/reviewTip.ts b/lib/metadataExtractor/reviewTip.ts
new file mode 100644
index 0000000..2aefe0a
--- /dev/null
+++ b/lib/metadataExtractor/reviewTip.ts
@@ -0,0 +1,40 @@
+import type { Event } from 'nostr-tools'
+import { generateReviewTipHashId } from '../hashIdGenerator'
+import type { ExtractedReviewTip } from './types'
+import { readAmountSats, readPaymentHash, readPayerPubkeyFromZapReceipt, readTagValue, readZapReceiptKind } from './utils'
+
+export async function extractReviewTipFromEvent(event: Event): Promise<ExtractedReviewTip | null> {
+  if (event.kind !== 9735 || readZapReceiptKind(event) !== 'review_tip') {
+    return null
+  }
+
+  const extracted = readReviewTipFields(event)
+  if (!extracted) {
+    return null
+  }
+
+  const id = await generateReviewTipHashId(extracted)
+  return { type: 'review_tip', id, ...extracted, eventId: event.id }
+}
+
+function readReviewTipFields(event: Event): Omit<ExtractedReviewTip, 'type' | 'id' | 'eventId'> | null {
+  const payerPubkey = readPayerPubkeyFromZapReceipt(event)
+  const amount = readAmountSats(event)
+  const paymentHash = readPaymentHash(event)
+  const reviewerPubkey = readTagValue(event, 'reviewer') ?? readTagValue(event, 'p')
+  const authorPubkey = readTagValue(event, 'author')
+  const articleId = readTagValue(event, 'article')
+  const reviewId = readTagValue(event, 'review_id') ?? readTagValue(event, 'e')
+
+  const required = { payerPubkey, reviewerPubkey, authorPubkey, articleId, reviewId }
+  if (!areAllNonEmptyStrings(required) || amount === undefined) {
+    console.error('[metadataExtractor] Invalid review_tip zap receipt: missing required fields', { eventId: event.id })
+    return null
+  }
+
+  return { ...required, amount, paymentHash }
+}
+
+function areAllNonEmptyStrings(values: Record<string, string | undefined>): values is Record<string, string> {
+  return Object.values(values).every((value) => typeof value === 'string' && value.length > 0)
+}
diff --git a/lib/metadataExtractor/series.ts b/lib/metadataExtractor/series.ts
new file mode 100644
index 0000000..e3a741e
--- /dev/null
+++ b/lib/metadataExtractor/series.ts
@@ -0,0 +1,73 @@
+import type { Event } from 'nostr-tools'
+import { extractTagsFromEvent } from '../nostrTagSystem'
+import { generateSeriesHashId } from '../hashIdGenerator'
+import type { ExtractedSeries } from './types'
+import { getMetadataFromEvent } from './metadataJson'
+import { firstString } from './utils'
+
+export async function extractSeriesFromEvent(event: Event): Promise<ExtractedSeries | null> {
+  const tags = extractTagsFromEvent(event)
+  if (tags.type !== 'series') {
+    return null
+  }
+  const metadata = getMetadataFromEvent(event)
+  if (metadata?.type === 'series') {
+    const seriesData = buildSeriesDataFromMetadata({ event, tags, metadata })
+    const id = await generateSeriesHashId(seriesData)
+    return buildExtractedSeries({ eventId: event.id, id, data: seriesData })
+  }
+
+  if (!tags.title || !tags.description) {
+    return null
+  }
+  const base = {
+    pubkey: event.pubkey,
+    title: tags.title,
+    description: tags.description,
+    preview: (tags.preview as string) ?? event.content.substring(0, 200),
+    category: tags.category ?? 'sciencefiction',
+    ...(tags.coverUrl ? { coverUrl: tags.coverUrl } : {}),
+  }
+  const id = await generateSeriesHashId(base)
+  return buildExtractedSeries({ eventId: event.id, id, data: base })
+}
+
+function buildSeriesDataFromMetadata(params: {
+  event: Event
+  tags: ReturnType<typeof extractTagsFromEvent>
+  metadata: Record<string, unknown>
+}): { pubkey: string; title: string; description: string; preview: string; coverUrl?: string; category: string } {
+  const title = firstString(params.metadata.title, params.tags.title) ?? ''
+  const preview = firstString(params.metadata.preview, params.tags.preview) ?? params.event.content.substring(0, 200)
+  const pubkey = firstString(params.metadata.pubkey, params.event.pubkey) ?? params.event.pubkey
+  const coverUrl = firstString(params.metadata.coverUrl, params.tags.coverUrl)
+  const result: { pubkey: string; title: string; description: string; preview: string; coverUrl?: string; category: string } = {
+    pubkey,
+    title,
+    description: firstString(params.metadata.description) ?? '',
+    preview,
+    category: firstString(params.metadata.category, params.tags.category, 'sciencefiction') ?? 'sciencefiction',
+  }
+  if (coverUrl) {
+    result.coverUrl = coverUrl
+  }
+  return result
+}
+
+function buildExtractedSeries(params: {
+  eventId: string
+  id: string
+  data: { pubkey: string; title: string; description: string; preview: string; coverUrl?: string; category: string }
+}): ExtractedSeries {
+  return {
+    type: 'series',
+    id: params.id,
+    pubkey: params.data.pubkey,
+    title: params.data.title,
+    description: params.data.description,
+    category: params.data.category,
+    eventId: params.eventId,
+    ...(params.data.coverUrl ? { coverUrl: params.data.coverUrl } : {}),
+    ...(params.data.preview ? { preview: params.data.preview } : {}),
+  }
+}
diff --git a/lib/metadataExtractor/sponsoring.ts b/lib/metadataExtractor/sponsoring.ts
new file mode 100644
index 0000000..2169d38
--- /dev/null
+++ b/lib/metadataExtractor/sponsoring.ts
@@ -0,0 +1,48 @@
+import type { Event } from 'nostr-tools'
+import { generateSponsoringHashId } from '../hashIdGenerator'
+import type { ExtractedSponsoring } from './types'
+import {
+  readAmountSats,
+  readPaymentHash,
+  readPayerPubkeyFromZapReceipt,
+  readTagValue,
+  readZapReceiptKind,
+  resolveSponsoringArticleId,
+} from './utils'
+
+export async function extractSponsoringFromEvent(event: Event): Promise<ExtractedSponsoring | null> {
+  if (event.kind !== 9735 || readZapReceiptKind(event) !== 'sponsoring') {
+    return null
+  }
+
+  const extracted = readSponsoringFields(event)
+  if (!extracted) {
+    return null
+  }
+
+  const id = await generateSponsoringHashId(extracted)
+  return { type: 'sponsoring', id, ...extracted, eventId: event.id }
+}
+
+function readSponsoringFields(event: Event): Omit<ExtractedSponsoring, 'type' | 'id' | 'eventId'> | null {
+  const payerPubkey = readPayerPubkeyFromZapReceipt(event)
+  const authorPubkey = readTagValue(event, 'author') ?? readTagValue(event, 'p')
+  const amount = readAmountSats(event)
+  if (!payerPubkey || !authorPubkey || amount === undefined) {
+    console.error('[metadataExtractor] Invalid sponsoring zap receipt: missing required fields', { eventId: event.id })
+    return null
+  }
+
+  const paymentHash = readPaymentHash(event)
+  const seriesId = readTagValue(event, 'series')
+  const articleId = resolveSponsoringArticleId({ articleTag: readTagValue(event, 'article'), eTag: readTagValue(event, 'e') })
+
+  return {
+    payerPubkey,
+    authorPubkey,
+    amount,
+    paymentHash,
+    ...(seriesId ? { seriesId } : {}),
+    ...(articleId ? { articleId } : {}),
+  }
+}
diff --git a/lib/metadataExtractor/types.ts b/lib/metadataExtractor/types.ts
new file mode 100644
index 0000000..27b5574
--- /dev/null
+++ b/lib/metadataExtractor/types.ts
@@ -0,0 +1,99 @@
+import type { Event } from 'nostr-tools'
+
+export interface ExtractedAuthor {
+  type: 'author'
+  id: string
+  pubkey: string
+  authorName: string
+  presentation: string
+  contentDescription: string
+  mainnetAddress?: string
+  pictureUrl?: string
+  category: string
+  url?: string
+  eventId: string
+}
+
+export interface ExtractedSeries {
+  type: 'series'
+  id: string
+  pubkey: string
+  title: string
+  description: string
+  preview?: string
+  coverUrl?: string
+  category: string
+  eventId: string
+}
+
+export interface ExtractedPublication {
+  type: 'publication'
+  id: string
+  pubkey: string
+  title: string
+  preview: string
+  category: string
+  seriesId?: string
+  bannerUrl?: string
+  zapAmount: number
+  eventId: string
+  pages?: Array<{ number: number; type: 'markdown' | 'image'; content: string }>
+}
+
+export interface ExtractedReview {
+  type: 'review'
+  id: string
+  pubkey: string
+  articleId: string
+  reviewerPubkey: string
+  content: string
+  title?: string
+  eventId: string
+}
+
+export interface ExtractedPurchase {
+  type: 'purchase'
+  id: string
+  payerPubkey: string
+  articleId: string
+  authorPubkey: string
+  amount: number
+  paymentHash: string
+  eventId: string
+}
+
+export interface ExtractedReviewTip {
+  type: 'review_tip'
+  id: string
+  payerPubkey: string
+  articleId: string
+  reviewId: string
+  reviewerPubkey: string
+  authorPubkey: string
+  amount: number
+  paymentHash: string
+  eventId: string
+}
+
+export interface ExtractedSponsoring {
+  type: 'sponsoring'
+  id: string
+  payerPubkey: string
+  authorPubkey: string
+  seriesId?: string
+  articleId?: string
+  amount: number
+  paymentHash: string
+  eventId: string
+}
+
+export type ExtractedObject =
+  | ExtractedAuthor
+  | ExtractedSeries
+  | ExtractedPublication
+  | ExtractedReview
+  | ExtractedPurchase
+  | ExtractedReviewTip
+  | ExtractedSponsoring
+
+export type MetadataEvent = Pick<Event, 'content' | 'tags'>
diff --git a/lib/metadataExtractor/utils.ts b/lib/metadataExtractor/utils.ts
new file mode 100644
index 0000000..5add2a7
--- /dev/null
+++ b/lib/metadataExtractor/utils.ts
@@ -0,0 +1,68 @@
+import type { Event } from 'nostr-tools'
+
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null && !Array.isArray(value)
+}
+
+export function readPayerPubkeyFromZapReceipt(event: Event): string | undefined {
+  const descriptionTag = readTagValue(event, 'description')
+  if (!descriptionTag) {
+    return undefined
+  }
+  try {
+    const parsed: unknown = JSON.parse(descriptionTag)
+    return isRecord(parsed) && typeof parsed.pubkey === 'string' ? parsed.pubkey : undefined
+  } catch (e) {
+    console.error('[metadataExtractor] Error parsing zap receipt description tag:', e)
+    return undefined
+  }
+}
+
+export function firstString(...values: unknown[]): string | undefined {
+  for (const value of values) {
+    if (typeof value === 'string') {
+      return value
+    }
+  }
+  return undefined
+}
+
+export function firstNumber(...values: unknown[]): number | undefined {
+  for (const value of values) {
+    if (typeof value === 'number') {
+      return value
+    }
+  }
+  return undefined
+}
+
+export function readTagValue(event: Event, key: string): string | undefined {
+  return event.tags.find((tag) => tag[0] === key)?.[1]
+}
+
+export function readZapReceiptKind(event: Event): string | undefined {
+  if (event.kind !== 9735) {
+    return undefined
+  }
+  return readTagValue(event, 'kind_type')
+}
+
+export function readAmountSats(event: Event): number | undefined {
+  const amountTag = readTagValue(event, 'amount')
+  if (!amountTag) {
+    return undefined
+  }
+  const millisats = Number.parseInt(amountTag, 10)
+  if (Number.isNaN(millisats)) {
+    return undefined
+  }
+  return millisats / 1000
+}
+
+export function readPaymentHash(event: Event): string {
+  return readTagValue(event, 'payment_hash') ?? event.id
+}
+
+export function resolveSponsoringArticleId(params: { articleTag: string | undefined; eTag: string | undefined }): string | undefined {
+  return params.articleTag ?? params.eTag
+}
diff --git a/lib/nostr.ts b/lib/nostr.ts
index 4533f83..e792350 100644
--- a/lib/nostr.ts
+++ b/lib/nostr.ts
@@ -1,501 +1 @@
-import { Event, EventTemplate, finalizeEvent, nip19, SimplePool } from 'nostr-tools'
-import { hexToBytes } from 'nostr-tools/utils'
-import type { Article, NostrProfile } from '@/types/nostr'
-import { createSubscription } from '@/types/nostr-tools-extended'
-import { parseArticleFromEvent } from './nostrEventParsing'
-import { parsePresentationEvent } from './articlePublisherHelpersPresentation'
-import {
-  getPrivateContent as getPrivateContentFromPool,
-  getDecryptionKey,
-  decryptArticleContentWithKey,
-} from './nostrPrivateMessages'
-import { checkZapReceipt as checkZapReceiptHelper } from './nostrZapVerification'
-import { getPrimaryRelay, getPrimaryRelaySync } from './config'
-import { buildTagFilter } from './nostrTagSystem'
-import { PLATFORM_SERVICE, MIN_EVENT_DATE } from './platformConfig'
-import type { PublishResult, RelayPublishStatus } from './publishResult'
-import { objectCache, type CachedObject } from './objectCache'
-
-class NostrService {
-  private pool: SimplePool | null = null
-  private privateKey: string | null = null
-  private publicKey: string | null = null
-
-  constructor() {
-    if (typeof window !== 'undefined') {
-      this.initializePool()
-    }
-  }
-
-  private initializePool(): void {
-    this.pool = new SimplePool()
-  }
-
-  setPrivateKey(privateKey: string): void {
-    this.privateKey = privateKey
-    try {
-      const decoded = nip19.decode(privateKey)
-      if (decoded.type === 'nsec' && typeof decoded.data === 'string') {
-        this.privateKey = decoded.data
-      }
-    } catch {
-      // Assume it's already a hex string
-    }
-  }
-
-  getPrivateKey(): string | null {
-    return this.privateKey
-  }
-
-  getPublicKey(): string | null {
-    return this.publicKey
-  }
-
-  setPublicKey(publicKey: string): void {
-    this.publicKey = publicKey
-    try {
-      const decoded = nip19.decode(publicKey)
-      if (decoded.type === 'npub' && typeof decoded.data === 'string') {
-        this.publicKey = decoded.data
-      }
-    } catch {
-      // Assume it's already a hex string
-    }
-  }
-
-  async publishEvent(eventTemplate: EventTemplate): Promise<Event | null>
-  async publishEvent(eventTemplate: EventTemplate, returnStatus: false): Promise<Event | null>
-  async publishEvent(eventTemplate: EventTemplate, returnStatus: true): Promise<PublishResult>
-  async publishEvent(eventTemplate: EventTemplate, returnStatus: boolean = false): Promise<Event | null | PublishResult> {
-    if (!this.privateKey || !this.pool) {
-      throw new Error('Private key not set or pool not initialized')
-    }
-
-    const unsignedEvent: EventTemplate = {
-      ...eventTemplate,
-      created_at: eventTemplate.created_at ?? Math.floor(Date.now() / 1000),
-    }
-
-    const secretKey = hexToBytes(this.privateKey)
-    const event = finalizeEvent(unsignedEvent, secretKey)
-
-    // Publish to all active relays (enabled and not marked inactive for this session)
-    // Each event has a unique ID based on content, so publishing to multiple relays
-    // doesn't create duplicates - it's the same event stored redundantly
-    // Network failures do not block - we return the event and status immediately
-    const { relaySessionManager } = await import('./relaySessionManager')
-    const activeRelays = await relaySessionManager.getActiveRelays()
-
-    const relayStatuses: RelayPublishStatus[] = []
-
-    // Start publishing asynchronously (don't await - non-blocking)
-    void this.publishEventNonBlocking({ event, activeRelays, relaySessionManager })
-
-    // Build statuses for return (synchronous, before network completes)
-    if (returnStatus) {
-      // Return statuses immediately (will be updated asynchronously)
-      activeRelays.forEach((relayUrl) => {
-        relayStatuses.push({
-          relayUrl,
-          success: false, // Will be updated asynchronously
-        })
-      })
-      return {
-        event,
-        relayStatuses,
-      }
-    }
-
-    // Return event immediately (non-blocking)
-    return event
-  }
-
-  private async publishEventNonBlocking(params: {
-    event: Event
-    activeRelays: string[]
-    relaySessionManager: typeof import('./relaySessionManager').relaySessionManager
-  }): Promise<void> {
-    try {
-      const successfulRelays = await this.publishToRelaysAndLog({
-        event: params.event,
-        relays: params.activeRelays.length > 0 ? params.activeRelays : [await getPrimaryRelay()],
-        relaySessionManager: params.relaySessionManager,
-      })
-      await this.updatePublishedStatus(params.event.id, successfulRelays.length > 0 ? successfulRelays : false)
-    } catch (publishError) {
-      console.error(`[NostrService] Error during publish (non-blocking):`, publishError)
-      await this.updatePublishedStatus(params.event.id, false)
-    }
-  }
-
-  private async publishToRelaysAndLog(params: {
-    event: Event
-    relays: string[]
-    relaySessionManager: typeof import('./relaySessionManager').relaySessionManager
-  }): Promise<string[]> {
-    if (!this.pool) {
-      throw new Error('Pool not initialized')
-    }
-    const pubs = this.pool.publish(params.relays, params.event)
-    const results = await Promise.allSettled(pubs)
-    const successfulRelays: string[] = []
-    const { publishLog } = await import('./publishLog')
-    results.forEach((result, index) => {
-      const relayUrl = params.relays[index]
-      if (!relayUrl) {
-        return
-      }
-      if (result.status === 'fulfilled') {
-        successfulRelays.push(relayUrl)
-        void publishLog.logPublication({ eventId: params.event.id, relayUrl, success: true })
-        return
-      }
-      const errorMessage = result.reason instanceof Error ? result.reason.message : String(result.reason)
-      console.error(`[NostrService] Relay ${relayUrl} failed during publish:`, result.reason)
-      params.relaySessionManager.markRelayFailed(relayUrl)
-      void publishLog.logPublication({ eventId: params.event.id, relayUrl, success: false, error: errorMessage })
-    })
-    return successfulRelays
-  }
-
-  private createArticleSubscription(pool: SimplePool, limit: number): ReturnType<typeof createSubscription> {
-    // Subscribe to both 'publication' and 'author' type events
-    // Authors are identified by tag type='author' in the tag system
-    // Filter by service='zapwall.fr' to only get notes from this platform
-    // Limit to events published on or after January 6, 2026
-    const filters = [
-      {
-        ...buildTagFilter({
-          type: 'publication',
-          service: PLATFORM_SERVICE,
-        }),
-        since: MIN_EVENT_DATE,
-        limit,
-      },
-      {
-        ...buildTagFilter({
-          type: 'author',
-          service: PLATFORM_SERVICE,
-        }),
-        since: MIN_EVENT_DATE,
-        limit,
-      },
-    ]
-    const relayUrl = getPrimaryRelaySync()
-    return createSubscription(pool, [relayUrl], filters)
-  }
-
-  subscribeToArticles(callback: (article: Article) => void, limit: number = 100): () => void {
-    if (typeof window === 'undefined') {
-      throw new Error('Cannot subscribe on server side')
-    }
-
-    if (!this.pool) {
-      this.initializePool()
-    }
-
-    if (!this.pool) {
-      throw new Error('Pool not initialized')
-    }
-
-    const sub = this.createArticleSubscription(this.pool, limit)
-
-    sub.on('event', (event: Event): void => {
-      void (async (): Promise<void> => {
-        try {
-        // Try to parse as regular article first
-        let article = await parseArticleFromEvent(event)
-        // If not a regular article, try to parse as author presentation
-        if (!article) {
-          const presentation = await parsePresentationEvent(event)
-          if (presentation) {
-            article = presentation
-          }
-        }
-        if (article) {
-          callback(article)
-        }
-      } catch (parseError) {
-        console.error('Error parsing article:', parseError)
-      }
-      })()
-    })
-
-    return (): void => {
-      sub.unsub()
-    }
-  }
-
-  async getArticleById(eventId: string): Promise<Article | null> {
-    // Read only from IndexedDB cache
-    // Try by ID first
-    const cachedById = await objectCache.getById('publication', eventId)
-    if (cachedById) {
-      return cachedById as Article
-    }
-
-    // Also try by hash if eventId is a hash
-    const cachedByHash = await objectCache.get('publication', eventId)
-    if (cachedByHash) {
-      return cachedByHash as Article
-    }
-
-    // Also check author presentations
-    const cachedAuthor = await objectCache.getById('author', eventId)
-    if (cachedAuthor) {
-      return cachedAuthor as Article
-    }
-
-    const cachedAuthorByHash = await objectCache.get('author', eventId)
-    if (cachedAuthorByHash) {
-      return cachedAuthorByHash as Article
-    }
-
-    // Not found in cache - return null (no network request)
-    return null
-  }
-
-  getPrivateContent(eventId: string, authorPubkey: string): Promise<string | null> {
-    if (!this.privateKey || !this.pool || !this.publicKey) {
-      throw new Error('Private key not set or pool not initialized')
-    }
-
-    return getPrivateContentFromPool({
-      pool: this.pool,
-      eventId,
-      authorPubkey,
-      privateKey: this.privateKey,
-      publicKey: this.publicKey,
-    })
-  }
-
-  /**
-   * Get and decrypt article content using decryption key from private message
-   * First retrieves the article event to get the encrypted content,
-   * then retrieves the decryption key from private messages,
-   * and finally decrypts the content
-   */
-  private async retrieveDecryptionKey(eventId: string, authorPubkey: string): Promise<{ key: string; iv: string } | null> {
-    if (!this.privateKey || !this.pool || !this.publicKey) {
-      return null
-    }
-    return getDecryptionKey({
-      pool: this.pool,
-      eventId,
-      authorPubkey,
-      recipientPrivateKey: this.privateKey,
-      recipientPublicKey: this.publicKey,
-    })
-  }
-
-  async getDecryptedArticleContent(eventId: string, authorPubkey: string): Promise<string | null> {
-    if (!this.privateKey || !this.pool || !this.publicKey) {
-      throw new Error('Private key not set or pool not initialized')
-    }
-
-    try {
-      const event = await this.getEventById(eventId)
-      if (!event) {
-        console.error('Event not found', { eventId, authorPubkey })
-        return null
-      }
-
-      const decryptionKey = await this.retrieveDecryptionKey(eventId, authorPubkey)
-      if (!decryptionKey) {
-        console.warn('Decryption key not found in private messages', { eventId, authorPubkey })
-        return null
-      }
-
-      return decryptArticleContentWithKey(event.content, decryptionKey)
-    } catch (decryptError) {
-      console.error('Error decrypting article content', {
-        eventId,
-        authorPubkey,
-        error: decryptError instanceof Error ? decryptError.message : 'Unknown error',
-      })
-      return null
-    }
-  }
-
-  /**
-   * Get event by ID (helper method)
-   * Reads only from IndexedDB cache
-   */
-  private async getEventById(eventId: string): Promise<Event | null> {
-    // Read only from IndexedDB cache
-    // Try publication cache first
-    const eventFromPublication = await objectCache.getEventById('publication', eventId)
-    if (eventFromPublication) {
-      return eventFromPublication
-    }
-
-    // Try author cache
-    const eventFromAuthor = await objectCache.getEventById('author', eventId)
-    if (eventFromAuthor) {
-      return eventFromAuthor
-    }
-
-    // Not found in cache - return null (no network request)
-    return null
-  }
-
-  async getProfile(_pubkey: string): Promise<NostrProfile | null> {
-    // Read only from IndexedDB cache
-    // Profiles (kind 0) are not currently cached in objectCache
-    // Return null if profile is not in cache (no network request)
-    // TODO: Add profile caching to objectCache if needed
-    return null
-  }
-
-  /**
-   * Update Nostr profile (kind 0) with new metadata
-   * Merges new fields with existing profile data
-   */
-  async updateProfile(updates: Partial<NostrProfile>): Promise<void> {
-    if (!this.privateKey || !this.publicKey) {
-      throw new Error('Private key and public key must be set to update profile')
-    }
-
-    // Get existing profile to merge with updates
-    const existingProfile = await this.getProfile(this.publicKey)
-    const currentProfile: NostrProfile = existingProfile ?? {
-      pubkey: this.publicKey,
-    }
-
-    // Merge updates with existing profile
-    const updatedProfile: NostrProfile = {
-      ...currentProfile,
-      ...updates,
-      pubkey: this.publicKey, // Always use current pubkey
-    }
-
-    // Create kind 0 event
-    const profileEvent: EventTemplate = {
-      kind: 0,
-      created_at: Math.floor(Date.now() / 1000),
-      tags: [],
-      content: JSON.stringify({
-        name: updatedProfile.name,
-        about: updatedProfile.about,
-        picture: updatedProfile.picture,
-        nip05: updatedProfile.nip05,
-        lud16: updatedProfile.lud16,
-        lud06: updatedProfile.lud06,
-      }),
-    }
-
-    await this.publishEvent(profileEvent)
-  }
-
-
-  async createZapRequest(
-    targetPubkey: string,
-    targetEventId: string,
-    amount: number,
-    extraTags: string[][] = []
-  ): Promise<Event> {
-    if (!this.privateKey) {
-      throw new Error('Private key not set')
-    }
-
-    const relayUrl = await getPrimaryRelay()
-
-    const zapRequest: EventTemplate = {
-      kind: 9734, // Zap request
-      created_at: Math.floor(Date.now() / 1000),
-      tags: [
-        ['p', targetPubkey],
-        ['e', targetEventId],
-        ['amount', amount.toString()],
-        ['relays', relayUrl],
-        ...extraTags,
-      ],
-      content: '',
-    }
-
-    const event = await this.publishEvent(zapRequest)
-    if (!event) {
-      throw new Error('Failed to create zap request')
-    }
-    return event
-  }
-
-  // Check if user has paid for an article by looking for zap receipts
-  checkZapReceipt(
-    targetPubkey: string,
-    targetEventId: string,
-    amount: number,
-    userPubkey?: string
-  ): Promise<boolean> {
-    if (!this.publicKey || !this.pool) {
-      return Promise.resolve(false)
-    }
-
-    // Use provided userPubkey or fall back to current public key
-    const checkPubkey = userPubkey ?? this.publicKey
-
-    return checkZapReceiptHelper({
-      pool: this.pool,
-      targetPubkey,
-      targetEventId,
-      amount,
-      userPubkey: checkPubkey,
-    })
-  }
-
-  /**
-   * Get the pool instance (for use by other services)
-   */
-  getPool(): SimplePool | null {
-    return this.pool
-  }
-
-  /**
-   * Update published status in IndexedDB for an event
-   * Searches all object types to find and update the event
-   */
-  private async updatePublishedStatus(eventId: string, published: false | string[]): Promise<void> {
-    const { objectCache: objectCacheModule } = await import('./objectCache')
-    const objectTypes: Array<import('./objectCache').ObjectType> = ['author', 'series', 'publication', 'review', 'purchase', 'sponsoring', 'review_tip', 'payment_note']
-
-    // Load writeService once
-    const { writeService } = await import('./writeService')
-
-    // First try to find in unpublished objects (faster)
-    for (const objectType of objectTypes) {
-      try {
-        const unpublished = await objectCacheModule.getUnpublished(objectType)
-        const matching = unpublished.find((obj) => obj.event.id === eventId)
-        if (matching) {
-          await writeService.updatePublished(objectType, matching.id, published)
-          return
-        }
-      } catch (error) {
-        console.warn(`[NostrService] Error checking unpublished in ${objectType}:`, error)
-        // Continue to next object type on error
-      }
-    }
-
-    // If not found in unpublished, search all objects
-    for (const objectType of objectTypes) {
-      try {
-        // Use getAll to search all objects
-        const allObjects = await objectCacheModule.getAll(objectType)
-        const matching = allObjects.find((obj) => {
-          const cachedObj = obj as CachedObject
-          return cachedObj.event?.id === eventId
-        })
-        if (matching) {
-          const cachedObj = matching as CachedObject
-          await writeService.updatePublished(objectType, cachedObj.id, published)
-          return
-        }
-      } catch (error) {
-        console.warn(`[NostrService] Error searching for event in ${objectType}:`, error)
-        // Continue to next object type on error
-      }
-    }
-  }
-}
-
-export const nostrService = new NostrService()
+export { nostrService } from './nostr/service'
diff --git a/lib/nostr/articles.ts b/lib/nostr/articles.ts
new file mode 100644
index 0000000..aab70e1
--- /dev/null
+++ b/lib/nostr/articles.ts
@@ -0,0 +1,35 @@
+import type { Event } from 'nostr-tools'
+import type { Article } from '@/types/nostr'
+import { createSubscription } from '@/types/nostr-tools-extended'
+import { parseArticleFromEvent } from '../nostrEventParsing'
+import { parsePresentationEvent } from '../articlePublisherHelpersPresentation'
+import { buildTagFilter } from '../nostrTagSystem'
+import { MIN_EVENT_DATE, PLATFORM_SERVICE } from '../platformConfig'
+import { getPrimaryRelaySync } from '../config'
+
+export function createArticleSubscription(params: {
+  pool: import('nostr-tools').SimplePool
+  limit: number
+}): ReturnType<typeof createSubscription> {
+  const filters = [
+    { ...buildTagFilter({ type: 'publication', service: PLATFORM_SERVICE }), since: MIN_EVENT_DATE, limit: params.limit },
+    { ...buildTagFilter({ type: 'author', service: PLATFORM_SERVICE }), since: MIN_EVENT_DATE, limit: params.limit },
+  ]
+  return createSubscription(params.pool, [getPrimaryRelaySync()], filters)
+}
+
+export async function parseArticleOrPresentationFromEvent(event: Event): Promise<Article | null> {
+  try {
+    let article = await parseArticleFromEvent(event)
+    if (!article) {
+      const presentation = await parsePresentationEvent(event)
+      if (presentation) {
+        article = presentation
+      }
+    }
+    return article
+  } catch (parseError) {
+    console.error('[NostrService] Error parsing article:', parseError)
+    return null
+  }
+}
diff --git a/lib/nostr/cache.ts b/lib/nostr/cache.ts
new file mode 100644
index 0000000..2f1a727
--- /dev/null
+++ b/lib/nostr/cache.ts
@@ -0,0 +1,35 @@
+import type { Article } from '@/types/nostr'
+import type { Event } from 'nostr-tools'
+import { objectCache } from '../objectCache'
+
+export async function getCachedArticleById(eventId: string): Promise<Article | null> {
+  const cachedById = await objectCache.getById('publication', eventId)
+  if (cachedById) {
+    return cachedById as Article
+  }
+  const cachedByHash = await objectCache.get('publication', eventId)
+  if (cachedByHash) {
+    return cachedByHash as Article
+  }
+  const cachedAuthor = await objectCache.getById('author', eventId)
+  if (cachedAuthor) {
+    return cachedAuthor as Article
+  }
+  const cachedAuthorByHash = await objectCache.get('author', eventId)
+  if (cachedAuthorByHash) {
+    return cachedAuthorByHash as Article
+  }
+  return null
+}
+
+export async function getCachedEventById(eventId: string): Promise<Event | null> {
+  const eventFromPublication = await objectCache.getEventById('publication', eventId)
+  if (eventFromPublication) {
+    return eventFromPublication
+  }
+  const eventFromAuthor = await objectCache.getEventById('author', eventId)
+  if (eventFromAuthor) {
+    return eventFromAuthor
+  }
+  return null
+}
diff --git a/lib/nostr/decryption.ts b/lib/nostr/decryption.ts
new file mode 100644
index 0000000..83070dc
--- /dev/null
+++ b/lib/nostr/decryption.ts
@@ -0,0 +1,74 @@
+import type { Event } from 'nostr-tools'
+import { decryptArticleContentWithKey, getDecryptionKey, getPrivateContent as getPrivateContentFromPool } from '../nostrPrivateMessages'
+import { getCachedEventById } from './cache'
+
+export async function getPrivateContent(params: {
+  pool: import('nostr-tools').SimplePool
+  eventId: string
+  authorPubkey: string
+  privateKey: string
+  publicKey: string
+}): Promise<string | null> {
+  return getPrivateContentFromPool({
+    pool: params.pool,
+    eventId: params.eventId,
+    authorPubkey: params.authorPubkey,
+    privateKey: params.privateKey,
+    publicKey: params.publicKey,
+  })
+}
+
+export async function getDecryptedArticleContent(params: {
+  pool: import('nostr-tools').SimplePool
+  eventId: string
+  authorPubkey: string
+  privateKey: string
+  publicKey: string
+}): Promise<string | null> {
+  try {
+    const event = await getEventById(params.eventId)
+    if (!event) {
+      console.error('[NostrService] Event not found', { eventId: params.eventId, authorPubkey: params.authorPubkey })
+      return null
+    }
+    const decryptionKey = await retrieveDecryptionKey({
+      pool: params.pool,
+      eventId: params.eventId,
+      authorPubkey: params.authorPubkey,
+      recipientPrivateKey: params.privateKey,
+      recipientPublicKey: params.publicKey,
+    })
+    if (!decryptionKey) {
+      console.warn('[NostrService] Decryption key not found in private messages', { eventId: params.eventId, authorPubkey: params.authorPubkey })
+      return null
+    }
+    return decryptArticleContentWithKey(event.content, decryptionKey)
+  } catch (decryptError) {
+    console.error('[NostrService] Error decrypting article content', {
+      eventId: params.eventId,
+      authorPubkey: params.authorPubkey,
+      error: decryptError instanceof Error ? decryptError.message : 'Unknown error',
+    })
+    return null
+  }
+}
+
+async function retrieveDecryptionKey(params: {
+  pool: import('nostr-tools').SimplePool
+  eventId: string
+  authorPubkey: string
+  recipientPrivateKey: string
+  recipientPublicKey: string
+}): Promise<{ key: string; iv: string } | null> {
+  return getDecryptionKey({
+    pool: params.pool,
+    eventId: params.eventId,
+    authorPubkey: params.authorPubkey,
+    recipientPrivateKey: params.recipientPrivateKey,
+    recipientPublicKey: params.recipientPublicKey,
+  })
+}
+
+async function getEventById(eventId: string): Promise<Event | null> {
+  return getCachedEventById(eventId)
+}
diff --git a/lib/nostr/publish.ts b/lib/nostr/publish.ts
new file mode 100644
index 0000000..d5531a5
--- /dev/null
+++ b/lib/nostr/publish.ts
@@ -0,0 +1,68 @@
+import type { Event, EventTemplate } from 'nostr-tools'
+import type { PublishResult, RelayPublishStatus } from '../publishResult'
+import { updatePublishedStatus } from './publishedStatus'
+
+export type PublishEventResult =
+  | { kind: 'event'; event: Event }
+  | { kind: 'status'; result: PublishResult }
+
+export async function publishEventNonBlocking(params: {
+  pool: import('nostr-tools').SimplePool
+  event: Event
+  activeRelays: string[]
+  relaySessionManager: typeof import('../relaySessionManager').relaySessionManager
+}): Promise<void> {
+  try {
+    const successfulRelays = await publishToRelaysAndLog({
+      pool: params.pool,
+      event: params.event,
+      relays: params.activeRelays.length > 0 ? params.activeRelays : [await getPrimaryRelay()],
+      relaySessionManager: params.relaySessionManager,
+    })
+    await updatePublishedStatus({ eventId: params.event.id, published: successfulRelays.length > 0 ? successfulRelays : false })
+  } catch (publishError) {
+    console.error('[NostrService] Error during publish (non-blocking):', publishError)
+    await updatePublishedStatus({ eventId: params.event.id, published: false })
+  }
+}
+
+export async function buildImmediatePublishStatuses(activeRelays: string[]): Promise<RelayPublishStatus[]> {
+  return activeRelays.map((relayUrl) => ({ relayUrl, success: false }))
+}
+
+async function publishToRelaysAndLog(params: {
+  pool: import('nostr-tools').SimplePool
+  event: Event
+  relays: string[]
+  relaySessionManager: typeof import('../relaySessionManager').relaySessionManager
+}): Promise<string[]> {
+  const pubs = params.pool.publish(params.relays, params.event)
+  const results = await Promise.allSettled(pubs)
+  const successfulRelays: string[] = []
+  const { publishLog } = await import('../publishLog')
+  results.forEach((result, index) => {
+    const relayUrl = params.relays[index]
+    if (!relayUrl) {
+      return
+    }
+    if (result.status === 'fulfilled') {
+      successfulRelays.push(relayUrl)
+      void publishLog.logPublication({ eventId: params.event.id, relayUrl, success: true })
+      return
+    }
+    const errorMessage = result.reason instanceof Error ? result.reason.message : String(result.reason)
+    console.error(`[NostrService] Relay ${relayUrl} failed during publish:`, result.reason)
+    params.relaySessionManager.markRelayFailed(relayUrl)
+    void publishLog.logPublication({ eventId: params.event.id, relayUrl, success: false, error: errorMessage })
+  })
+  return successfulRelays
+}
+
+async function getPrimaryRelay(): Promise<string> {
+  const { getPrimaryRelay: getPrimaryRelayFromConfig } = await import('../config')
+  return getPrimaryRelayFromConfig()
+}
+
+export function buildUnsignedEventTemplate(eventTemplate: EventTemplate): EventTemplate {
+  return { ...eventTemplate, created_at: eventTemplate.created_at ?? Math.floor(Date.now() / 1000) }
+}
diff --git a/lib/nostr/publishedStatus.ts b/lib/nostr/publishedStatus.ts
new file mode 100644
index 0000000..eb943de
--- /dev/null
+++ b/lib/nostr/publishedStatus.ts
@@ -0,0 +1,69 @@
+import type { ObjectType } from '../objectCache'
+
+const OBJECT_TYPES: ObjectType[] = ['author', 'series', 'publication', 'review', 'purchase', 'sponsoring', 'review_tip', 'payment_note']
+
+export async function updatePublishedStatus(params: { eventId: string; published: false | string[] }): Promise<void> {
+  const { objectCache } = await import('../objectCache')
+  const { writeService } = await import('../writeService')
+
+  const updatedFromUnpublished = await tryUpdateFromUnpublished({ objectCache, writeService, eventId: params.eventId, published: params.published })
+  if (updatedFromUnpublished) {
+    return
+  }
+
+  await tryUpdateFromAllObjects({ objectCache, writeService, eventId: params.eventId, published: params.published })
+}
+
+async function tryUpdateFromUnpublished(params: {
+  objectCache: typeof import('../objectCache').objectCache
+  writeService: typeof import('../writeService').writeService
+  eventId: string
+  published: false | string[]
+}): Promise<boolean> {
+  for (const objectType of OBJECT_TYPES) {
+    try {
+      const unpublished = await params.objectCache.getUnpublished(objectType)
+      const matching = unpublished.find((obj) => isCacheObjectWithEventId(obj, params.eventId))
+      if (matching) {
+        await params.writeService.updatePublished(objectType, matching.id, params.published)
+        return true
+      }
+    } catch (error) {
+      console.warn(`[NostrService] Error checking unpublished in ${objectType}:`, error)
+    }
+  }
+  return false
+}
+
+async function tryUpdateFromAllObjects(params: {
+  objectCache: typeof import('../objectCache').objectCache
+  writeService: typeof import('../writeService').writeService
+  eventId: string
+  published: false | string[]
+}): Promise<void> {
+  for (const objectType of OBJECT_TYPES) {
+    try {
+      const allObjects = await params.objectCache.getAll(objectType)
+      const match = allObjects.find((obj) => isCacheObjectWithEventId(obj, params.eventId))
+      if (match) {
+        await params.writeService.updatePublished(objectType, match.id, params.published)
+        return
+      }
+    } catch (error) {
+      console.warn(`[NostrService] Error searching for event in ${objectType}:`, error)
+    }
+  }
+}
+
+type CacheObjectWithEventId = {
+  id: string
+  event: { id: string }
+}
+
+function isCacheObjectWithEventId(value: unknown, eventId: string): value is CacheObjectWithEventId {
+  if (typeof value !== 'object' || value === null) {
+    return false
+  }
+  const obj = value as Partial<CacheObjectWithEventId>
+  return typeof obj.id === 'string' && typeof obj.event?.id === 'string' && obj.event.id === eventId
+}
diff --git a/lib/nostr/service.ts b/lib/nostr/service.ts
new file mode 100644
index 0000000..3d19eae
--- /dev/null
+++ b/lib/nostr/service.ts
@@ -0,0 +1,182 @@
+import { finalizeEvent, nip19, SimplePool, type Event, type EventTemplate } from 'nostr-tools'
+import { hexToBytes } from 'nostr-tools/utils'
+import type { Article, NostrProfile } from '@/types/nostr'
+import type { PublishResult } from '../publishResult'
+import { checkZapReceipt as checkZapReceiptHelper } from '../nostrZapVerification'
+import { createArticleSubscription, parseArticleOrPresentationFromEvent } from './articles'
+import { getCachedArticleById } from './cache'
+import { getDecryptedArticleContent, getPrivateContent } from './decryption'
+import { buildImmediatePublishStatuses, buildUnsignedEventTemplate, publishEventNonBlocking } from './publish'
+
+class NostrService {
+  private pool: SimplePool | null = null
+  private privateKey: string | null = null
+  private publicKey: string | null = null
+
+  constructor() {
+    if (typeof window !== 'undefined') {
+      this.initializePool()
+    }
+  }
+
+  private initializePool(): void {
+    this.pool = new SimplePool()
+  }
+
+  setPrivateKey(privateKey: string): void {
+    this.privateKey = privateKey
+    try {
+      const decoded = nip19.decode(privateKey)
+      if (decoded.type === 'nsec' && typeof decoded.data === 'string') {
+        this.privateKey = decoded.data
+      }
+    } catch {
+      // Assume it's already a hex string
+    }
+  }
+
+  getPrivateKey(): string | null {
+    return this.privateKey
+  }
+
+  getPublicKey(): string | null {
+    return this.publicKey
+  }
+
+  setPublicKey(publicKey: string): void {
+    this.publicKey = publicKey
+    try {
+      const decoded = nip19.decode(publicKey)
+      if (decoded.type === 'npub' && typeof decoded.data === 'string') {
+        this.publicKey = decoded.data
+      }
+    } catch {
+      // Assume it's already a hex string
+    }
+  }
+
+  async publishEvent(eventTemplate: EventTemplate): Promise<Event | null>
+  async publishEvent(eventTemplate: EventTemplate, returnStatus: false): Promise<Event | null>
+  async publishEvent(eventTemplate: EventTemplate, returnStatus: true): Promise<PublishResult>
+  async publishEvent(eventTemplate: EventTemplate, returnStatus: boolean = false): Promise<Event | null | PublishResult> {
+    if (!this.privateKey || !this.pool) {
+      throw new Error('Private key not set or pool not initialized')
+    }
+
+    const unsignedEvent = buildUnsignedEventTemplate(eventTemplate)
+    const event = finalizeEvent(unsignedEvent, hexToBytes(this.privateKey))
+
+    const { relaySessionManager } = await import('../relaySessionManager')
+    const activeRelays = await relaySessionManager.getActiveRelays()
+
+    void publishEventNonBlocking({ pool: this.pool, event, activeRelays, relaySessionManager })
+
+    if (returnStatus) {
+      const relayStatuses = await buildImmediatePublishStatuses(activeRelays)
+      return { event, relayStatuses }
+    }
+
+    return event
+  }
+
+  subscribeToArticles(callback: (article: Article) => void, limit: number = 100): () => void {
+    if (typeof window === 'undefined') {
+      throw new Error('Cannot subscribe on server side')
+    }
+    if (!this.pool) {
+      this.initializePool()
+    }
+    if (!this.pool) {
+      throw new Error('Pool not initialized')
+    }
+
+    const sub = createArticleSubscription({ pool: this.pool, limit })
+    sub.on('event', (event: Event): void => {
+      void (async (): Promise<void> => {
+        const parsed = await parseArticleOrPresentationFromEvent(event)
+        if (parsed) {
+          callback(parsed)
+        }
+      })()
+    })
+
+    return (): void => sub.unsub()
+  }
+
+  async getArticleById(eventId: string): Promise<Article | null> {
+    return getCachedArticleById(eventId)
+  }
+
+  getPrivateContent(eventId: string, authorPubkey: string): Promise<string | null> {
+    if (!this.privateKey || !this.pool || !this.publicKey) {
+      throw new Error('Private key not set or pool not initialized')
+    }
+    return getPrivateContent({ pool: this.pool, eventId, authorPubkey, privateKey: this.privateKey, publicKey: this.publicKey })
+  }
+
+  async getDecryptedArticleContent(eventId: string, authorPubkey: string): Promise<string | null> {
+    if (!this.privateKey || !this.pool || !this.publicKey) {
+      throw new Error('Private key not set or pool not initialized')
+    }
+    return getDecryptedArticleContent({ pool: this.pool, eventId, authorPubkey, privateKey: this.privateKey, publicKey: this.publicKey })
+  }
+
+  async getProfile(_pubkey: string): Promise<NostrProfile | null> {
+    return null
+  }
+
+  async updateProfile(updates: Partial<NostrProfile>): Promise<void> {
+    if (!this.privateKey || !this.publicKey) {
+      throw new Error('Private key and public key must be set to update profile')
+    }
+    const existingProfile = await this.getProfile(this.publicKey)
+    const currentProfile: NostrProfile = existingProfile ?? { pubkey: this.publicKey }
+    const updatedProfile: NostrProfile = { ...currentProfile, ...updates, pubkey: this.publicKey }
+    const profileEvent: EventTemplate = {
+      kind: 0,
+      created_at: Math.floor(Date.now() / 1000),
+      tags: [],
+      content: JSON.stringify({
+        name: updatedProfile.name,
+        about: updatedProfile.about,
+        picture: updatedProfile.picture,
+        nip05: updatedProfile.nip05,
+        lud16: updatedProfile.lud16,
+        lud06: updatedProfile.lud06,
+      }),
+    }
+    await this.publishEvent(profileEvent)
+  }
+
+  async createZapRequest(targetPubkey: string, targetEventId: string, amount: number, extraTags: string[][] = []): Promise<Event> {
+    if (!this.privateKey) {
+      throw new Error('Private key not set')
+    }
+    const { getPrimaryRelay } = await import('../config')
+    const relayUrl = await getPrimaryRelay()
+    const zapRequest: EventTemplate = {
+      kind: 9734,
+      created_at: Math.floor(Date.now() / 1000),
+      tags: [['p', targetPubkey], ['e', targetEventId], ['amount', amount.toString()], ['relays', relayUrl], ...extraTags],
+      content: '',
+    }
+    const event = await this.publishEvent(zapRequest)
+    if (!event) {
+      throw new Error('Failed to create zap request')
+    }
+    return event
+  }
+
+  checkZapReceipt(targetPubkey: string, targetEventId: string, amount: number, userPubkey?: string): Promise<boolean> {
+    if (!this.publicKey || !this.pool) {
+      return Promise.resolve(false)
+    }
+    return checkZapReceiptHelper({ pool: this.pool, targetPubkey, targetEventId, amount, userPubkey: userPubkey ?? this.publicKey })
+  }
+
+  getPool(): SimplePool | null {
+    return this.pool
+  }
+}
+
+export const nostrService = new NostrService()
diff --git a/lib/nostrEventParsing.ts b/lib/nostrEventParsing.ts
index 58419b5..c8466f4 100644
--- a/lib/nostrEventParsing.ts
+++ b/lib/nostrEventParsing.ts
@@ -1,507 +1 @@
-import type { Event } from 'nostr-tools'
-import type { Article, Page, Purchase, Review, ReviewTip, Series, Sponsoring } from '@/types/nostr'
-import { extractTagsFromEvent } from './nostrTagSystem'
-import { buildObjectId, parseObjectId } from './urlGenerator'
-import { generateHashId } from './hashIdGenerator'
-import { extractPurchaseFromEvent, extractReviewTipFromEvent, extractSponsoringFromEvent } from './metadataExtractor'
-
-/**
- * Parse article metadata from Nostr event
- * Uses new tag system: #publication, #sciencefiction|research, #id_<id>, #paywall, #payment
- */
-export async function parseArticleFromEvent(event: Event): Promise<Article | null> {
-  try {
-    const tags = extractTagsFromEvent(event)
-    // Check if it's a publication type
-    if (tags.type !== 'publication') {
-      return null
-    }
-    const { previewContent } = getPreviewContent(event.content, tags.preview)
-    return buildArticle(event, tags, previewContent)
-  } catch (e) {
-    console.error('Error parsing article:', e)
-    return null
-  }
-}
-
-export async function parseSeriesFromEvent(event: Event): Promise<Series | null> {
-  try {
-    const tags = extractTagsFromEvent(event)
-    const input = readSeriesInput({ tags, eventContent: event.content })
-    if (!input) {
-      return null
-    }
-    const category = mapNostrCategoryToLegacy(tags.category) ?? 'science-fiction'
-
-    const { hash, version, index } = await resolveObjectIdParts({
-      ...(input.idTag ? { idTag: input.idTag } : {}),
-      defaultVersion: input.defaultVersion,
-      defaultIndex: 0,
-      generateHash: async (): Promise<string> => generateHashId({
-        type: 'series',
-        pubkey: event.pubkey,
-        title: input.title,
-        description: input.description,
-        category: input.categoryTag,
-        coverUrl: input.coverUrl,
-      }),
-    })
-
-    return buildSeriesFromParsed({
-      event,
-      input,
-      hash,
-      version,
-      index,
-      category,
-    })
-  } catch (e) {
-    console.error('Error parsing series:', e)
-    return null
-  }
-}
-
-export async function parseReviewFromEvent(event: Event): Promise<Review | null> {
-  try {
-    const tags = extractTagsFromEvent(event)
-    const input = readReviewInput(tags)
-    if (!input) {
-      return null
-    }
-
-    const { hash, version, index } = await resolveObjectIdParts({
-      ...(input.idTag ? { idTag: input.idTag } : {}),
-      defaultVersion: input.defaultVersion,
-      defaultIndex: 0,
-      generateHash: async (): Promise<string> => generateHashId({
-        type: 'quote',
-        pubkey: event.pubkey,
-        articleId: input.articleId,
-        reviewerPubkey: input.reviewerPubkey,
-        content: event.content,
-        title: input.title ?? '',
-      }),
-    })
-
-    const rewardInfo = readRewardInfo(event.tags)
-    const text = readTextTag(event.tags)
-    return buildReviewFromParsed({ event, input, hash, version, index, rewardInfo, text })
-  } catch (e) {
-    console.error('Error parsing review:', e)
-    return null
-  }
-}
-
-function buildSeriesFromParsed(params: {
-  event: Event
-  input: { title: string; description: string; preview: string; coverUrl: string }
-  hash: string
-  version: number
-  index: number
-  category: Series['category']
-}): Series {
-  const id = buildObjectId(params.hash, params.index, params.version)
-  const series: Series = {
-    id,
-    hash: params.hash,
-    version: params.version,
-    index: params.index,
-    pubkey: params.event.pubkey,
-    title: params.input.title,
-    description: params.input.description,
-    preview: params.input.preview,
-    thumbnailUrl: params.input.coverUrl,
-    category: params.category,
-    ...(params.input.coverUrl ? { coverUrl: params.input.coverUrl } : {}),
-  }
-  series.kindType = 'series'
-  return series
-}
-
-function buildReviewFromParsed(params: {
-  event: Event
-  input: { articleId: string; reviewerPubkey: string; title: string | undefined; description: string }
-  hash: string
-  version: number
-  index: number
-  rewardInfo: { rewarded: boolean; rewardAmount: number | undefined }
-  text: string | undefined
-}): Review {
-  const id = buildObjectId(params.hash, params.index, params.version)
-  const review: Review = {
-    id,
-    hash: params.hash,
-    version: params.version,
-    index: params.index,
-    articleId: params.input.articleId,
-    authorPubkey: params.event.pubkey,
-    reviewerPubkey: params.input.reviewerPubkey,
-    content: params.event.content,
-    description: params.input.description,
-    createdAt: params.event.created_at,
-    ...(params.input.title ? { title: params.input.title } : {}),
-    ...(params.text ? { text: params.text } : {}),
-    ...(params.rewardInfo.rewarded ? { rewarded: true } : {}),
-    ...(params.rewardInfo.rewardAmount !== undefined ? { rewardAmount: params.rewardInfo.rewardAmount } : {}),
-  }
-  review.kindType = 'review'
-  return review
-}
-
-function readSeriesInput(params: { tags: ReturnType<typeof extractTagsFromEvent>; eventContent: string }): {
-  idTag: string | undefined
-  defaultVersion: number
-  title: string
-  description: string
-  preview: string
-  coverUrl: string
-  categoryTag: string
-} | null {
-  if (params.tags.type !== 'series' || !params.tags.title || !params.tags.description) {
-    return null
-  }
-
-  return {
-    idTag: params.tags.id,
-    defaultVersion: params.tags.version ?? 0,
-    title: params.tags.title,
-    description: params.tags.description,
-    preview: params.tags.preview ?? params.eventContent.substring(0, 200),
-    coverUrl: params.tags.coverUrl ?? '',
-    categoryTag: params.tags.category ?? 'sciencefiction',
-  }
-}
-
-function readReviewInput(tags: ReturnType<typeof extractTagsFromEvent>): {
-  idTag: string | undefined
-  defaultVersion: number
-  articleId: string
-  reviewerPubkey: string
-  title: string | undefined
-  description: string
-} | null {
-  if (tags.type !== 'quote' || !tags.articleId || !tags.reviewerPubkey) {
-    return null
-  }
-  return {
-    idTag: tags.id,
-    defaultVersion: tags.version ?? 0,
-    articleId: tags.articleId,
-    reviewerPubkey: tags.reviewerPubkey,
-    title: tags.title,
-    description: tags.description ?? '',
-  }
-}
-
-function readRewardInfo(eventTags: string[][]): { rewarded: boolean; rewardAmount: number | undefined } {
-  const rewarded = eventTags.some((tag) => tag[0] === 'rewarded' && tag[1] === 'true')
-  const rewardAmountTag = eventTags.find((tag) => tag[0] === 'reward_amount')?.[1]
-  const rewardAmountRaw = rewardAmountTag ? parseInt(rewardAmountTag, 10) : NaN
-  const rewardAmount = Number.isNaN(rewardAmountRaw) ? undefined : rewardAmountRaw
-  return { rewarded, rewardAmount }
-}
-
-function readTextTag(eventTags: string[][]): string | undefined {
-  return eventTags.find((tag) => tag[0] === 'text')?.[1]
-}
-
-
-function getPreviewContent(content: string, previewTag?: string): { previewContent: string } {
-  const lines = content.split('\n')
-  const previewContent = previewTag ?? lines[0] ?? content.substring(0, 200)
-  return { previewContent }
-}
-
-function mapNostrCategoryToLegacy(
-  category: string | undefined
-): 'science-fiction' | 'scientific-research' | undefined {
-  if (category === 'sciencefiction') {
-    return 'science-fiction'
-  }
-  if (category === 'research') {
-    return 'scientific-research'
-  }
-  return undefined
-}
-
-interface ObjectIdParts {
-  hash: string
-  version: number
-  index: number
-}
-
-function parseObjectIdPartsFromTag(params: { idTag: string; defaultVersion: number; defaultIndex: number }): ObjectIdParts {
-  const parsed = parseObjectId(params.idTag)
-  const hash = parsed.hash ?? params.idTag
-  const version = parsed.version ?? params.defaultVersion
-  const index = parsed.index ?? params.defaultIndex
-  return { hash, version, index }
-}
-
-async function resolveObjectIdParts(params: {
-  idTag?: string
-  defaultVersion: number
-  defaultIndex: number
-  generateHash: () => Promise<string>
-}): Promise<ObjectIdParts> {
-  if (params.idTag) {
-    return parseObjectIdPartsFromTag({
-      idTag: params.idTag,
-      defaultVersion: params.defaultVersion,
-      defaultIndex: params.defaultIndex,
-    })
-  }
-
-  const hash = await params.generateHash()
-  return { hash, version: params.defaultVersion, index: params.defaultIndex }
-}
-
-function resolveThumbnailUrl(tags: ReturnType<typeof extractTagsFromEvent>): string {
-  if (typeof tags.bannerUrl === 'string') {
-    return tags.bannerUrl
-  }
-  if (typeof tags.pictureUrl === 'string') {
-    return tags.pictureUrl
-  }
-  return ''
-}
-
-function parsePagesFromEventJsonTag(event: Event): Page[] | undefined {
-  const jsonTag = event.tags.find((tag) => tag[0] === 'json')?.[1]
-  if (!jsonTag) {
-    return undefined
-  }
-
-  try {
-    const parsed: unknown = JSON.parse(jsonTag)
-    if (typeof parsed !== 'object' || parsed === null) {
-      return undefined
-    }
-    const metadata = parsed as { pages?: unknown }
-    if (!Array.isArray(metadata.pages)) {
-      return undefined
-    }
-    return metadata.pages as Page[]
-  } catch {
-    return undefined
-  }
-}
-
-function buildArticlePaymentFields(tags: ReturnType<typeof extractTagsFromEvent>): Partial<Article> {
-  const result: Partial<Article> = {}
-  if (tags.invoice) {
-    result.invoice = tags.invoice
-  }
-  if (tags.paymentHash) {
-    result.paymentHash = tags.paymentHash
-  }
-  return result
-}
-
-function buildArticleClassificationFields(params: {
-  tags: ReturnType<typeof extractTagsFromEvent>
-  category: 'science-fiction' | 'scientific-research' | undefined
-  isPresentation: boolean
-}): Partial<Article> {
-  const result: Partial<Article> = {}
-  if (params.category) {
-    result.category = params.category
-  }
-  if (params.isPresentation) {
-    result.isPresentation = true
-  }
-  if (params.tags.type === 'publication' || params.tags.type === 'author') {
-    result.kindType = 'article'
-  }
-  return result
-}
-
-function buildArticleOptionalMetaFields(params: {
-  tags: ReturnType<typeof extractTagsFromEvent>
-  pages: Page[] | undefined
-}): Partial<Article> {
-  const result: Partial<Article> = {}
-  if (params.tags.mainnetAddress) {
-    result.mainnetAddress = params.tags.mainnetAddress
-  }
-  if (params.tags.totalSponsoring) {
-    result.totalSponsoring = params.tags.totalSponsoring
-  }
-  if (params.tags.seriesId) {
-    result.seriesId = params.tags.seriesId
-  }
-  if (params.tags.bannerUrl) {
-    result.bannerUrl = params.tags.bannerUrl
-  }
-  if (params.pages && params.pages.length > 0) {
-    result.pages = params.pages
-  }
-  return result
-}
-
-async function buildArticle(event: Event, tags: ReturnType<typeof extractTagsFromEvent>, preview: string): Promise<Article> {
-  const category = mapNostrCategoryToLegacy(tags.category)
-  const isPresentation = tags.type === 'author'
-
-  const { hash, version, index } = await resolveObjectIdParts({
-    ...(tags.id ? { idTag: tags.id } : {}),
-    defaultVersion: tags.version ?? 0,
-    defaultIndex: 0,
-    generateHash: async (): Promise<string> => generateHashId({
-      type: isPresentation ? 'author' : 'publication',
-      pubkey: event.pubkey,
-      title: tags.title ?? 'Untitled',
-      preview,
-      category: tags.category ?? 'sciencefiction',
-      seriesId: tags.seriesId ?? '',
-      bannerUrl: tags.bannerUrl ?? '',
-      zapAmount: tags.zapAmount ?? 800,
-    }),
-  })
-
-  const id = buildObjectId(hash, index, version)
-
-  const pages = parsePagesFromEventJsonTag(event)
-
-  return {
-    id,
-    hash,
-    version,
-    index,
-    pubkey: event.pubkey,
-    title: tags.title ?? 'Untitled',
-    preview,
-    content: '',
-    description: tags.description ?? '', // Required field with default
-    contentDescription: tags.description ?? '', // Required field with default (can be improved later)
-    createdAt: event.created_at,
-    zapAmount: tags.zapAmount ?? 800,
-    paid: false,
-    thumbnailUrl: resolveThumbnailUrl(tags), // Required field with default
-    ...buildArticlePaymentFields(tags),
-    ...buildArticleClassificationFields({ tags, category, isPresentation }),
-    ...buildArticleOptionalMetaFields({ tags, pages }),
-  }
-}
-
-/**
- * Parse purchase from zap receipt event (kind 9735)
- */
-export async function parsePurchaseFromEvent(event: Event): Promise<Purchase | null> {
-  try {
-    const extracted = await extractPurchaseFromEvent(event)
-    if (!extracted) {
-      return null
-    }
-
-    // Extract hash, version, index from id
-    const parsed = parseObjectId(extracted.id)
-    const { hash: parsedHash, version: parsedVersion, index: parsedIndex } = parsed
-    const hash = parsedHash ?? extracted.id
-    const version = parsedVersion ?? 0
-    const index = parsedIndex ?? 0
-    const id = buildObjectId(hash, index, version)
-
-    return {
-      id,
-      hash,
-      version,
-      index,
-      payerPubkey: extracted.payerPubkey,
-      articleId: extracted.articleId,
-      authorPubkey: extracted.authorPubkey,
-      amount: extracted.amount,
-      paymentHash: extracted.paymentHash,
-      createdAt: event.created_at,
-      kindType: 'purchase',
-    }
-  } catch (e) {
-    console.error('Error parsing purchase:', e)
-    return null
-  }
-}
-
-/**
- * Parse sponsoring from zap receipt event (kind 9735)
- */
-export async function parseSponsoringFromEvent(event: Event): Promise<Sponsoring | null> {
-  try {
-    const extracted = await extractSponsoringFromEvent(event)
-    if (!extracted) {
-      return null
-    }
-
-    // Extract hash, version, index from id
-    const parsed = parseObjectId(extracted.id)
-    const { hash: parsedHash, version: parsedVersion, index: parsedIndex } = parsed
-    const hash = parsedHash ?? extracted.id
-    const version = parsedVersion ?? 0
-    const index = parsedIndex ?? 0
-    const id = buildObjectId(hash, index, version)
-
-    // Extract text from tags if present
-    const textTag = event.tags.find((tag) => tag[0] === 'text')?.[1]
-
-    return {
-      id,
-      hash,
-      version,
-      index,
-      payerPubkey: extracted.payerPubkey,
-      authorPubkey: extracted.authorPubkey,
-      amount: extracted.amount,
-      paymentHash: extracted.paymentHash,
-      createdAt: event.created_at,
-      ...(extracted.seriesId ? { seriesId: extracted.seriesId } : {}),
-      ...(extracted.articleId ? { articleId: extracted.articleId } : {}),
-      ...(textTag ? { text: textTag } : {}),
-      kindType: 'sponsoring',
-    }
-  } catch (e) {
-    console.error('Error parsing sponsoring:', e)
-    return null
-  }
-}
-
-/**
- * Parse review tip from zap receipt event (kind 9735)
- */
-export async function parseReviewTipFromEvent(event: Event): Promise<ReviewTip | null> {
-  try {
-    const extracted = await extractReviewTipFromEvent(event)
-    if (!extracted) {
-      return null
-    }
-
-    // Extract hash, version, index from id
-    const parsed = parseObjectId(extracted.id)
-    const { hash: parsedHash, version: parsedVersion, index: parsedIndex } = parsed
-    const hash = parsedHash ?? extracted.id
-    const version = parsedVersion ?? 0
-    const index = parsedIndex ?? 0
-    const id = buildObjectId(hash, index, version)
-
-    // Extract text from tags if present
-    const textTag = event.tags.find((tag) => tag[0] === 'text')?.[1]
-
-    return {
-      id,
-      hash,
-      version,
-      index,
-      payerPubkey: extracted.payerPubkey,
-      articleId: extracted.articleId,
-      reviewId: extracted.reviewId,
-      reviewerPubkey: extracted.reviewerPubkey,
-      authorPubkey: extracted.authorPubkey,
-      amount: extracted.amount,
-      paymentHash: extracted.paymentHash,
-      createdAt: event.created_at,
-      ...(textTag ? { text: textTag } : {}),
-      kindType: 'review_tip',
-    }
-  } catch (e) {
-    console.error('Error parsing review tip:', e)
-    return null
-  }
-}
+export * from './nostrEventParsing/index'
diff --git a/lib/nostrEventParsing/article.ts b/lib/nostrEventParsing/article.ts
new file mode 100644
index 0000000..a0ded77
--- /dev/null
+++ b/lib/nostrEventParsing/article.ts
@@ -0,0 +1,147 @@
+import type { Event } from 'nostr-tools'
+import type { Article, Page } from '@/types/nostr'
+import { extractTagsFromEvent } from '../nostrTagSystem'
+import { buildObjectId } from '../urlGenerator'
+import { generateHashId } from '../hashIdGenerator'
+import { getPreviewContent, mapNostrCategoryToLegacy, resolveObjectIdParts, resolveThumbnailUrl, type ExtractedTags } from './shared'
+
+/**
+ * Parse article metadata from Nostr event
+ * Uses new tag system: #publication, #sciencefiction|research, #id_<id>, #paywall, #payment
+ */
+export async function parseArticleFromEvent(event: Event): Promise<Article | null> {
+  try {
+    const tags = extractTagsFromEvent(event)
+    if (tags.type !== 'publication') {
+      return null
+    }
+    const { previewContent } = getPreviewContent(event.content, tags.preview)
+    return buildArticle(event, tags, previewContent)
+  } catch (e) {
+    console.error('Error parsing article:', e)
+    return null
+  }
+}
+
+function parsePagesFromEventJsonTag(event: Event): Page[] | undefined {
+  const jsonTag = event.tags.find((tag) => tag[0] === 'json')?.[1]
+  if (!jsonTag) {
+    return undefined
+  }
+  try {
+    const parsed: unknown = JSON.parse(jsonTag)
+    if (typeof parsed !== 'object' || parsed === null) {
+      return undefined
+    }
+    const metadata = parsed as { pages?: unknown }
+    if (!Array.isArray(metadata.pages)) {
+      return undefined
+    }
+    return metadata.pages as Page[]
+  } catch {
+    return undefined
+  }
+}
+
+function buildArticlePaymentFields(tags: ExtractedTags): Partial<Article> {
+  const result: Partial<Article> = {}
+  if (tags.invoice) {
+    result.invoice = tags.invoice
+  }
+  if (tags.paymentHash) {
+    result.paymentHash = tags.paymentHash
+  }
+  return result
+}
+
+function buildArticleClassificationFields(params: {
+  tags: ExtractedTags
+  category: 'science-fiction' | 'scientific-research' | undefined
+  isPresentation: boolean
+}): Partial<Article> {
+  const result: Partial<Article> = {}
+  if (params.category) {
+    result.category = params.category
+  }
+  if (params.isPresentation) {
+    result.isPresentation = true
+  }
+  if (params.tags.type === 'publication' || params.tags.type === 'author') {
+    result.kindType = 'article'
+  }
+  return result
+}
+
+function buildArticleOptionalMetaFields(params: { tags: ExtractedTags; pages: Page[] | undefined }): Partial<Article> {
+  const result: Partial<Article> = {}
+  if (params.tags.mainnetAddress) {
+    result.mainnetAddress = params.tags.mainnetAddress
+  }
+  if (params.tags.totalSponsoring) {
+    result.totalSponsoring = params.tags.totalSponsoring
+  }
+  if (params.tags.seriesId) {
+    result.seriesId = params.tags.seriesId
+  }
+  if (params.tags.bannerUrl) {
+    result.bannerUrl = params.tags.bannerUrl
+  }
+  if (params.pages && params.pages.length > 0) {
+    result.pages = params.pages
+  }
+  return result
+}
+
+async function buildArticle(event: Event, tags: ExtractedTags, preview: string): Promise<Article> {
+  const category = mapNostrCategoryToLegacy(tags.category)
+  const isPresentation = tags.type === 'author'
+
+  const { hash, version, index } = await resolveObjectIdParts(buildObjectIdResolutionParams({ event, tags, preview, isPresentation }))
+
+  const id = buildObjectId(hash, index, version)
+  const pages = parsePagesFromEventJsonTag(event)
+
+  return {
+    id,
+    hash,
+    version,
+    index,
+    pubkey: event.pubkey,
+    title: tags.title ?? 'Untitled',
+    preview,
+    content: '',
+    description: tags.description ?? '',
+    contentDescription: tags.description ?? '',
+    createdAt: event.created_at,
+    zapAmount: tags.zapAmount ?? 800,
+    paid: false,
+    thumbnailUrl: resolveThumbnailUrl(tags),
+    ...buildArticlePaymentFields(tags),
+    ...buildArticleClassificationFields({ tags, category, isPresentation }),
+    ...buildArticleOptionalMetaFields({ tags, pages }),
+  }
+}
+
+function buildObjectIdResolutionParams(params: {
+  event: Event
+  tags: ExtractedTags
+  preview: string
+  isPresentation: boolean
+}): Parameters<typeof resolveObjectIdParts>[0] {
+  return {
+    ...(params.tags.id ? { idTag: params.tags.id } : {}),
+    defaultVersion: params.tags.version ?? 0,
+    defaultIndex: 0,
+    generateHash: async (): Promise<string> =>
+      generateHashId({
+        type: params.isPresentation ? 'author' : 'publication',
+        pubkey: params.event.pubkey,
+        title: params.tags.title ?? 'Untitled',
+        preview: params.preview,
+        category: params.tags.category ?? 'sciencefiction',
+        seriesId: params.tags.seriesId ?? '',
+        bannerUrl: params.tags.bannerUrl ?? '',
+        zapAmount: params.tags.zapAmount ?? 800,
+      }),
+  }
+}
diff --git a/lib/nostrEventParsing/index.ts b/lib/nostrEventParsing/index.ts
new file mode 100644
index 0000000..17e3108
--- /dev/null
+++ b/lib/nostrEventParsing/index.ts
@@ -0,0 +1,4 @@
+export { parseArticleFromEvent } from './article'
+export { parseSeriesFromEvent } from './series'
+export { parseReviewFromEvent } from './review'
+export { parsePurchaseFromEvent, parseReviewTipFromEvent, parseSponsoringFromEvent } from './zapReceipts'
diff --git a/lib/nostrEventParsing/review.ts b/lib/nostrEventParsing/review.ts
new file mode 100644
index 0000000..b3a15cf
--- /dev/null
+++ b/lib/nostrEventParsing/review.ts
@@ -0,0 +1,66 @@
+import type { Event } from 'nostr-tools'
+import type { Review } from '@/types/nostr'
+import { extractTagsFromEvent } from '../nostrTagSystem'
+import { buildObjectId } from '../urlGenerator'
+import { generateHashId } from '../hashIdGenerator'
+import { readRewardInfo, readReviewInput, readTextTag, resolveObjectIdParts } from './shared'
+
+export async function parseReviewFromEvent(event: Event): Promise<Review | null> {
+  try {
+    const tags = extractTagsFromEvent(event)
+    const input = readReviewInput(tags)
+    if (!input) {
+      return null
+    }
+    const { hash, version, index } = await resolveObjectIdParts({
+      ...(input.idTag ? { idTag: input.idTag } : {}),
+      defaultVersion: input.defaultVersion,
+      defaultIndex: 0,
+      generateHash: async (): Promise<string> =>
+        generateHashId({
+          type: 'quote',
+          pubkey: event.pubkey,
+          articleId: input.articleId,
+          reviewerPubkey: input.reviewerPubkey,
+          content: event.content,
+          title: input.title ?? '',
+        }),
+    })
+    const rewardInfo = readRewardInfo(event.tags)
+    const text = readTextTag(event.tags)
+    return buildReviewFromParsed({ event, input, hash, version, index, rewardInfo, text })
+  } catch (e) {
+    console.error('Error parsing review:', e)
+    return null
+  }
+}
+
+function buildReviewFromParsed(params: {
+  event: Event
+  input: { articleId: string; reviewerPubkey: string; title: string | undefined; description: string }
+  hash: string
+  version: number
+  index: number
+  rewardInfo: { rewarded: boolean; rewardAmount: number | undefined }
+  text: string | undefined
+}): Review {
+  const id = buildObjectId(params.hash, params.index, params.version)
+  const review: Review = {
+    id,
+    hash: params.hash,
+    version: params.version,
+    index: params.index,
+    articleId: params.input.articleId,
+    authorPubkey: params.event.pubkey,
+    reviewerPubkey: params.input.reviewerPubkey,
+    content: params.event.content,
+    description: params.input.description,
+    createdAt: params.event.created_at,
+    ...(params.input.title ? { title: params.input.title } : {}),
+    ...(params.text ? { text: params.text } : {}),
+    ...(params.rewardInfo.rewarded ? { rewarded: true } : {}),
+    ...(params.rewardInfo.rewardAmount !== undefined ? { rewardAmount: params.rewardInfo.rewardAmount } : {}),
+  }
+  review.kindType = 'review'
+  return review
+}
diff --git a/lib/nostrEventParsing/series.ts b/lib/nostrEventParsing/series.ts
new file mode 100644
index 0000000..5016d97
--- /dev/null
+++ b/lib/nostrEventParsing/series.ts
@@ -0,0 +1,62 @@
+import type { Event } from 'nostr-tools'
+import type { Series } from '@/types/nostr'
+import { extractTagsFromEvent } from '../nostrTagSystem'
+import { buildObjectId } from '../urlGenerator'
+import { generateHashId } from '../hashIdGenerator'
+import { mapNostrCategoryToLegacy, readSeriesInput, resolveObjectIdParts, type ExtractedTags } from './shared'
+
+export async function parseSeriesFromEvent(event: Event): Promise<Series | null> {
+  try {
+    const tags = extractTagsFromEvent(event)
+    const input = readSeriesInput({ tags, eventContent: event.content })
+    if (!input) {
+      return null
+    }
+    const category = mapNostrCategoryToLegacy(tags.category) ?? 'science-fiction'
+    const { hash, version, index } = await resolveObjectIdParts({
+      ...(input.idTag ? { idTag: input.idTag } : {}),
+      defaultVersion: input.defaultVersion,
+      defaultIndex: 0,
+      generateHash: async (): Promise<string> =>
+        generateHashId({
+          type: 'series',
+          pubkey: event.pubkey,
+          title: input.title,
+          description: input.description,
+          category: input.categoryTag,
+          coverUrl: input.coverUrl,
+        }),
+    })
+    return buildSeriesFromParsed({ event, input, hash, version, index, category, tags })
+  } catch (e) {
+    console.error('Error parsing series:', e)
+    return null
+  }
+}
+
+function buildSeriesFromParsed(params: {
+  event: Event
+  input: { title: string; description: string; preview: string; coverUrl: string }
+  hash: string
+  version: number
+  index: number
+  category: Series['category']
+  tags: ExtractedTags
+}): Series {
+  const id = buildObjectId(params.hash, params.index, params.version)
+  const series: Series = {
+    id,
+    hash: params.hash,
+    version: params.version,
+    index: params.index,
+    pubkey: params.event.pubkey,
+    title: params.input.title,
+    description: params.input.description,
+    preview: params.input.preview,
+    thumbnailUrl: params.input.coverUrl,
+    category: params.category,
+    ...(params.input.coverUrl ? { coverUrl: params.input.coverUrl } : {}),
+  }
+  series.kindType = 'series'
+  return series
+}
diff --git a/lib/nostrEventParsing/shared.ts b/lib/nostrEventParsing/shared.ts
new file mode 100644
index 0000000..0f875f7
--- /dev/null
+++ b/lib/nostrEventParsing/shared.ts
@@ -0,0 +1,101 @@
+import { extractTagsFromEvent } from '../nostrTagSystem'
+import { parseObjectId } from '../urlGenerator'
+
+export type ExtractedTags = ReturnType<typeof extractTagsFromEvent>
+
+export function mapNostrCategoryToLegacy(category: string | undefined): 'science-fiction' | 'scientific-research' | undefined {
+  if (category === 'sciencefiction') {
+    return 'science-fiction'
+  }
+  if (category === 'research') {
+    return 'scientific-research'
+  }
+  return undefined
+}
+
+export function getPreviewContent(content: string, previewTag?: string): { previewContent: string } {
+  const lines = content.split('\n')
+  const previewContent = previewTag ?? lines[0] ?? content.substring(0, 200)
+  return { previewContent }
+}
+
+export function readRewardInfo(eventTags: string[][]): { rewarded: boolean; rewardAmount: number | undefined } {
+  const rewarded = eventTags.some((tag) => tag[0] === 'rewarded' && tag[1] === 'true')
+  const rewardAmountTag = eventTags.find((tag) => tag[0] === 'reward_amount')?.[1]
+  const rewardAmountRaw = rewardAmountTag ? Number.parseInt(rewardAmountTag, 10) : Number.NaN
+  const rewardAmount = Number.isNaN(rewardAmountRaw) ? undefined : rewardAmountRaw
+  return { rewarded, rewardAmount }
+}
+
+export function readTextTag(eventTags: string[][]): string | undefined {
+  return eventTags.find((tag) => tag[0] === 'text')?.[1]
+}
+
+export function readSeriesInput(params: {
+  tags: ExtractedTags
+  eventContent: string
+}): { idTag: string | undefined; defaultVersion: number; title: string; description: string; preview: string; coverUrl: string; categoryTag: string } | null {
+  if (params.tags.type !== 'series' || !params.tags.title || !params.tags.description) {
+    return null
+  }
+  return {
+    idTag: params.tags.id,
+    defaultVersion: params.tags.version ?? 0,
+    title: params.tags.title,
+    description: params.tags.description,
+    preview: params.tags.preview ?? params.eventContent.substring(0, 200),
+    coverUrl: params.tags.coverUrl ?? '',
+    categoryTag: params.tags.category ?? 'sciencefiction',
+  }
+}
+
+export function readReviewInput(tags: ExtractedTags): { idTag: string | undefined; defaultVersion: number; articleId: string; reviewerPubkey: string; title: string | undefined; description: string } | null {
+  if (tags.type !== 'quote' || !tags.articleId || !tags.reviewerPubkey) {
+    return null
+  }
+  return {
+    idTag: tags.id,
+    defaultVersion: tags.version ?? 0,
+    articleId: tags.articleId,
+    reviewerPubkey: tags.reviewerPubkey,
+    title: tags.title,
+    description: tags.description ?? '',
+  }
+}
+
+export interface ObjectIdParts {
+  hash: string
+  version: number
+  index: number
+}
+
+export function parseObjectIdPartsFromTag(params: { idTag: string; defaultVersion: number; defaultIndex: number }): ObjectIdParts {
+  const parsed = parseObjectId(params.idTag)
+  const hash = parsed.hash ?? params.idTag
+  const version = parsed.version ?? params.defaultVersion
+  const index = parsed.index ?? params.defaultIndex
+  return { hash, version, index }
+}
+
+export async function resolveObjectIdParts(params: {
+  idTag?: string
+  defaultVersion: number
+  defaultIndex: number
+  generateHash: () => Promise<string>
+}): Promise<ObjectIdParts> {
+  if (params.idTag) {
+    return parseObjectIdPartsFromTag({ idTag: params.idTag, defaultVersion: params.defaultVersion, defaultIndex: params.defaultIndex })
+  }
+  const hash = await params.generateHash()
+  return { hash, version: params.defaultVersion, index: params.defaultIndex }
+}
+
+export function resolveThumbnailUrl(tags: ExtractedTags): string {
+  if (typeof tags.bannerUrl === 'string') {
+    return tags.bannerUrl
+  }
+  if (typeof tags.pictureUrl === 'string') {
+    return tags.pictureUrl
+  }
+  return ''
+}
diff --git a/lib/nostrEventParsing/zapReceipts.ts b/lib/nostrEventParsing/zapReceipts.ts
new file mode 100644
index 0000000..d00fcea
--- /dev/null
+++ b/lib/nostrEventParsing/zapReceipts.ts
@@ -0,0 +1,108 @@
+import type { Event } from 'nostr-tools'
+import type { Purchase, ReviewTip, Sponsoring } from '@/types/nostr'
+import { buildObjectId, parseObjectId } from '../urlGenerator'
+import { extractPurchaseFromEvent, extractReviewTipFromEvent, extractSponsoringFromEvent } from '../metadataExtractor'
+import { readTextTag } from './shared'
+
+/**
+ * Parse purchase from zap receipt event (kind 9735)
+ */
+export async function parsePurchaseFromEvent(event: Event): Promise<Purchase | null> {
+  try {
+    const extracted = await extractPurchaseFromEvent(event)
+    if (!extracted) {
+      return null
+    }
+    const { id, hash, version, index } = parseObjectIdentity(extracted.id)
+    return {
+      id,
+      hash,
+      version,
+      index,
+      payerPubkey: extracted.payerPubkey,
+      articleId: extracted.articleId,
+      authorPubkey: extracted.authorPubkey,
+      amount: extracted.amount,
+      paymentHash: extracted.paymentHash,
+      createdAt: event.created_at,
+      kindType: 'purchase',
+    }
+  } catch (e) {
+    console.error('Error parsing purchase:', e)
+    return null
+  }
+}
+
+/**
+ * Parse sponsoring from zap receipt event (kind 9735)
+ */
+export async function parseSponsoringFromEvent(event: Event): Promise<Sponsoring | null> {
+  try {
+    const extracted = await extractSponsoringFromEvent(event)
+    if (!extracted) {
+      return null
+    }
+    const { id, hash, version, index } = parseObjectIdentity(extracted.id)
+    const textTag = readTextTag(event.tags)
+    return {
+      id,
+      hash,
+      version,
+      index,
+      payerPubkey: extracted.payerPubkey,
+      authorPubkey: extracted.authorPubkey,
+      amount: extracted.amount,
+      paymentHash: extracted.paymentHash,
+      createdAt: event.created_at,
+      ...(extracted.seriesId ? { seriesId: extracted.seriesId } : {}),
+      ...(extracted.articleId ? { articleId: extracted.articleId } : {}),
+      ...(textTag ? { text: textTag } : {}),
+      kindType: 'sponsoring',
+    }
+  } catch (e) {
+    console.error('Error parsing sponsoring:', e)
+    return null
+  }
+}
+
+/**
+ * Parse review tip from zap receipt event (kind 9735)
+ */
+export async function parseReviewTipFromEvent(event: Event): Promise<ReviewTip | null> {
+  try {
+    const extracted = await extractReviewTipFromEvent(event)
+    if (!extracted) {
+      return null
+    }
+    const { id, hash, version, index } = parseObjectIdentity(extracted.id)
+    const textTag = readTextTag(event.tags)
+    return {
+      id,
+      hash,
+      version,
+      index,
+      payerPubkey: extracted.payerPubkey,
+      articleId: extracted.articleId,
+      reviewId: extracted.reviewId,
+      reviewerPubkey: extracted.reviewerPubkey,
+      authorPubkey: extracted.authorPubkey,
+      amount: extracted.amount,
+      paymentHash: extracted.paymentHash,
+      createdAt: event.created_at,
+      ...(textTag ? { text: textTag } : {}),
+      kindType: 'review_tip',
+    }
+  } catch (e) {
+    console.error('Error parsing review tip:', e)
+    return null
+  }
+}
+
+function parseObjectIdentity(idValue: string): { id: string; hash: string; version: number; index: number } {
+  const parsed = parseObjectId(idValue)
+  const hash = parsed.hash ?? idValue
+  const version = parsed.version ?? 0
+  const index = parsed.index ?? 0
+  const id = buildObjectId(hash, index, version)
+  return { id, hash, version, index }
+}
diff --git a/lib/objectCache.ts b/lib/objectCache.ts
index c4885a9..ed9402b 100644
--- a/lib/objectCache.ts
+++ b/lib/objectCache.ts
@@ -1,448 +1 @@
-/**
- * IndexedDB cache for Nostr objects (authors, series, publications, reviews)
- * Objects are indexed by their hash ID for fast retrieval
- * One database per object type
- */
-
-import type { Event as NostrEvent } from 'nostr-tools'
-import type { AuthorPresentationArticle } from '@/types/nostr'
-import { buildObjectId } from './urlGenerator'
-import { createIndexedDBHelper, type IndexedDBHelper } from './helpers/indexedDBHelper'
-
-export type ObjectType = 'author' | 'series' | 'publication' | 'review' | 'purchase' | 'sponsoring' | 'review_tip' | 'payment_note'
-
-export interface CachedObject {
-  id: string // Format: <hash>_<index>_<version>
-  hash: string // SHA-256 hash of the object
-  hashId: string // Legacy field for backward compatibility
-  index: number // Index for duplicates
-  event: NostrEvent
-  parsed: unknown // Parsed object (AuthorPresentationArticle, Series, etc.)
-  version: number
-  hidden: boolean
-  createdAt: number
-  cachedAt: number
-  published: false | string[] // false if not published, array of relay URLs that successfully published
-}
-
-const DB_PREFIX = 'nostr_objects_'
-const DB_VERSION = 3 // Incremented to add published field
-const STORE_NAME = 'objects'
-
-class ObjectCacheService {
-  private readonly dbHelpers: Map<ObjectType, IndexedDBHelper> = new Map()
-
-  private getDBHelper(objectType: ObjectType): IndexedDBHelper {
-    if (!this.dbHelpers.has(objectType)) {
-      const helper = createDbHelperForObjectType(objectType)
-      this.dbHelpers.set(objectType, helper)
-    }
-    return getRequiredDbHelper(this.dbHelpers, objectType)
-  }
-
-  /**
-   * Initialize database and return IDBDatabase instance
-   * Used for direct database access when needed
-   */
-  private async initDB(objectType: ObjectType): Promise<IDBDatabase> {
-    const helper = this.getDBHelper(objectType)
-    return helper.init()
-  }
-
-  /**
-   * Count objects with the same hash to determine the index
-   */
-  private async countObjectsWithHash(objectType: ObjectType, hash: string): Promise<number> {
-    try {
-      const helper = this.getDBHelper(objectType)
-      return helper.countByIndex('hash', IDBKeyRange.only(hash))
-    } catch (countError) {
-      console.error(`Error counting objects with hash ${hash}:`, countError)
-      return 0
-    }
-  }
-
-  /**
-   * Store an object in cache
-   * Verifies and sets the index before insertion
-   * @param published - false if not published, or array of relay URLs that successfully published
-   */
-  async set(params: {
-    objectType: ObjectType
-    hash: string
-    event: NostrEvent
-    parsed: unknown
-    version: number
-    hidden: boolean
-    index?: number
-    published?: false | string[]
-  }): Promise<void> {
-    try {
-      const helper = this.getDBHelper(params.objectType)
-      const index = await this.resolveIndex(params.objectType, params.hash, params.index)
-      const id = buildObjectId(params.hash, index, params.version)
-      const published = await this.resolvePublishedForUpsert(helper, id, params.published)
-      await helper.put(this.buildCachedObject(params, id, index, published))
-    } catch (cacheError) {
-      console.error(`Error caching ${params.objectType} object:`, cacheError)
-    }
-  }
-
-  private async resolveIndex(
-    objectType: ObjectType,
-    hash: string,
-    index: number | undefined
-  ): Promise<number> {
-    if (index !== undefined) {
-      return index
-    }
-    return this.countObjectsWithHash(objectType, hash)
-  }
-
-  private async resolvePublishedForUpsert(
-    helper: IndexedDBHelper,
-    id: string,
-    published: false | string[] | undefined
-  ): Promise<false | string[]> {
-    const nextPublished = published ?? false
-    if (nextPublished !== false) {
-      return nextPublished
-    }
-    const existing = await helper.get<CachedObject>(id).catch(() => null)
-    return existing ? existing.published : false
-  }
-
-  private buildCachedObject(
-    params: {
-      objectType: ObjectType
-      hash: string
-      event: NostrEvent
-      parsed: unknown
-      version: number
-      hidden: boolean
-    },
-    id: string,
-    index: number,
-    published: false | string[]
-  ): CachedObject {
-    return {
-      id,
-      hash: params.hash,
-      hashId: params.hash, // Legacy field for backward compatibility
-      index,
-      event: params.event,
-      parsed: params.parsed,
-      version: params.version,
-      hidden: params.hidden,
-      createdAt: params.event.created_at,
-      cachedAt: Date.now(),
-      published,
-    }
-  }
-
-  /**
-   * Update published status for an object
-   */
-  async updatePublished(
-    objectType: ObjectType,
-    id: string,
-    published: false | string[]
-  ): Promise<void> {
-    try {
-      const helper = this.getDBHelper(objectType)
-      const existing = await helper.get<CachedObject>(id)
-
-      if (!existing) {
-        console.warn(`Object ${id} not found in cache, cannot update published status`)
-        return
-      }
-
-      const oldPublished = existing.published
-      const updated: CachedObject = {
-        ...existing,
-        published,
-      }
-
-      await helper.put(updated)
-
-      // Notify about published status change (false -> array of relays)
-      if (oldPublished === false && Array.isArray(published) && published.length > 0) {
-        const eventId = id.split(':')[1] ?? id
-        void import('./notificationDetector')
-          .then(({ notificationDetector }) => {
-            void notificationDetector.checkObjectChange({
-              objectType,
-              objectId: id,
-              eventId,
-              oldPublished,
-              newPublished: published,
-            })
-          })
-          .catch((error) => {
-            console.error('Failed to notify published status change:', error)
-          })
-      }
-    } catch (updateError) {
-      console.error(`Error updating published status for ${objectType} object:`, updateError)
-    }
-  }
-
-  /**
-   * Get all objects that are not published (published === false)
-   */
-  async getUnpublished(objectType: ObjectType): Promise<Array<{ id: string; event: NostrEvent }>> {
-    try {
-      const db = await this.initDB(objectType)
-      const transaction = db.transaction(['objects'], 'readonly')
-      const store = transaction.objectStore('objects')
-
-      return new Promise((resolve, reject) => {
-        const request = store.openCursor()
-        const unpublished: Array<{ id: string; event: NostrEvent }> = []
-
-        request.onsuccess = (event: globalThis.Event): void => {
-          const cursor = (event.target as IDBRequest<IDBCursorWithValue>).result
-          if (cursor) {
-            const obj = cursor.value as CachedObject
-            // Check if published is false (not an array)
-            if (obj.published === false && !obj.hidden) {
-              unpublished.push({ id: obj.id, event: obj.event })
-            }
-            cursor.continue()
-          } else {
-            resolve(unpublished)
-          }
-        }
-
-        request.onerror = (): void => {
-          reject(request.error)
-        }
-      })
-    } catch (getUnpublishedError) {
-      console.error(`Error retrieving unpublished ${objectType} objects:`, getUnpublishedError)
-      return []
-    }
-  }
-
-  /**
-   * Get an object from cache by hash
-   * Returns the latest non-hidden version
-   */
-  async get(objectType: ObjectType, hash: string): Promise<unknown> {
-    try {
-      const db = await this.initDB(objectType)
-      const transaction = db.transaction(['objects'], 'readonly')
-      const store = transaction.objectStore('objects')
-      const hashIndex = store.index('hash')
-
-      return new Promise<unknown>((resolve, reject) => {
-        const request = hashIndex.openCursor(IDBKeyRange.only(hash))
-        const objects: CachedObject[] = []
-
-        request.onsuccess = (event: globalThis.Event): void => {
-          const cursor = (event.target as IDBRequest<IDBCursorWithValue>).result
-          if (cursor) {
-            const obj = cursor.value as CachedObject
-            if (obj?.hash === hash && !obj.hidden) {
-              objects.push(obj)
-            }
-            cursor.continue()
-          } else {
-            // Sort by version descending and return the latest
-            if (objects.length === 0) {
-              resolve(null)
-              return
-            }
-            objects.sort((a, b) => b.version - a.version)
-            resolve(objects[0]?.parsed ?? null)
-          }
-        }
-
-        request.onerror = (): void => {
-          reject(request.error)
-        }
-      })
-    } catch (retrieveError) {
-      console.error(`Error retrieving ${objectType} object from cache:`, retrieveError)
-      return null
-    }
-  }
-
-  /**
-   * Get an object from cache by ID
-   */
-  async getById(objectType: ObjectType, id: string): Promise<unknown> {
-    try {
-      const helper = this.getDBHelper(objectType)
-      const obj = await helper.get<CachedObject>(id)
-      if (obj && !obj.hidden) {
-        return obj.parsed
-      }
-      return null
-    } catch (retrieveByIdError) {
-      console.error(`Error retrieving ${objectType} object by ID from cache:`, retrieveByIdError)
-      return null
-    }
-  }
-
-  /**
-   * Get the raw event from cache by ID
-   */
-  async getEventById(objectType: ObjectType, id: string): Promise<NostrEvent | null> {
-    try {
-      const helper = this.getDBHelper(objectType)
-      const obj = await helper.get<CachedObject>(id)
-      if (obj && !obj.hidden) {
-        return obj.event
-      }
-      return null
-    } catch (retrieveByIdError) {
-      console.error(`Error retrieving ${objectType} event by ID from cache:`, retrieveByIdError)
-      return null
-    }
-  }
-
-  /**
-   * Get an author presentation by pubkey (searches all cached authors)
-   */
-  async getAuthorByPubkey(pubkey: string): Promise<AuthorPresentationArticle | null> {
-    try {
-      const db = await this.initDB('author')
-      const transaction = db.transaction(['objects'], 'readonly')
-      const store = transaction.objectStore('objects')
-
-      return new Promise((resolve, reject) => {
-        const request = store.openCursor()
-        const objects: CachedObject[] = []
-
-        request.onsuccess = (event: globalThis.Event): void => {
-          const cursor = (event.target as IDBRequest<IDBCursorWithValue>).result
-          if (cursor) {
-            const obj = cursor.value as CachedObject
-            if (obj?.event.pubkey === pubkey && !obj.hidden) {
-              objects.push(obj)
-            }
-            cursor.continue()
-          } else {
-            // Sort by version descending and return the latest
-            if (objects.length === 0) {
-              resolve(null)
-              return
-            }
-            objects.sort((a, b) => b.version - a.version)
-            resolve((objects[0]?.parsed ?? null) as AuthorPresentationArticle | null)
-          }
-        }
-
-        request.onerror = (): void => {
-          reject(request.error)
-        }
-      })
-    } catch (authorRetrieveError) {
-      console.error('Error retrieving author from cache by pubkey:', authorRetrieveError)
-      return null
-    }
-  }
-
-  /**
-   * Get all objects of a type from cache (non-hidden only)
-   */
-  async getAll(objectType: ObjectType): Promise<unknown[]> {
-    try {
-      const db = await this.initDB(objectType)
-      const transaction = db.transaction(['objects'], 'readonly')
-      const store = transaction.objectStore('objects')
-
-      return new Promise((resolve, reject) => {
-        const request = store.openCursor()
-        const objects: unknown[] = []
-
-        request.onsuccess = (event: globalThis.Event): void => {
-          const cursor = (event.target as IDBRequest<IDBCursorWithValue>).result
-          if (cursor) {
-            const obj = cursor.value as CachedObject
-            if (!obj.hidden) {
-              objects.push(obj.parsed)
-            }
-            cursor.continue()
-          } else {
-            resolve(objects)
-          }
-        }
-
-        request.onerror = (): void => {
-          reject(request.error)
-        }
-      })
-    } catch (getAllError) {
-      console.error(`Error retrieving all ${objectType} objects from cache:`, getAllError)
-      return []
-    }
-  }
-
-  /**
-   * Clear cache for an object type
-   */
-  async clear(objectType: ObjectType): Promise<void> {
-    try {
-      const helper = this.getDBHelper(objectType)
-      await helper.clear()
-    } catch (clearError) {
-      console.error(`Error clearing ${objectType} cache:`, clearError)
-    }
-  }
-}
-
-export const objectCache = new ObjectCacheService()
-
-function createDbHelperForObjectType(objectType: ObjectType): IndexedDBHelper {
-  return createIndexedDBHelper({
-    dbName: `${DB_PREFIX}${objectType}`,
-    version: DB_VERSION,
-    storeName: STORE_NAME,
-    keyPath: 'id',
-    indexes: getObjectCacheIndexes(),
-    onUpgrade: (_db: IDBDatabase, event: IDBVersionChangeEvent): void => {
-      handleObjectCacheUpgrade(event)
-    },
-  })
-}
-
-function getObjectCacheIndexes(): Array<{ name: string; keyPath: string; unique: boolean }> {
-  return [
-    { name: 'hash', keyPath: 'hash', unique: false },
-    { name: 'hashId', keyPath: 'hashId', unique: false },
-    { name: 'version', keyPath: 'version', unique: false },
-    { name: 'index', keyPath: 'index', unique: false },
-    { name: 'hidden', keyPath: 'hidden', unique: false },
-    { name: 'cachedAt', keyPath: 'cachedAt', unique: false },
-    { name: 'published', keyPath: 'published', unique: false },
-  ]
-}
-
-function handleObjectCacheUpgrade(event: IDBVersionChangeEvent): void {
-  // Migration: add new indexes if they don't exist
-  const target = event.target as IDBOpenDBRequest
-  const { transaction } = target
-  if (!transaction) {
-    return
-  }
-  const store = transaction.objectStore(STORE_NAME)
-  ensureIndex(store, 'hash', 'hash')
-  ensureIndex(store, 'index', 'index')
-  ensureIndex(store, 'published', 'published')
-}
-
-function ensureIndex(store: IDBObjectStore, name: string, keyPath: string): void {
-  if (!store.indexNames.contains(name)) {
-    store.createIndex(name, keyPath, { unique: false })
-  }
-}
-
-function getRequiredDbHelper(map: Map<ObjectType, IndexedDBHelper>, objectType: ObjectType): IndexedDBHelper {
-  const helper = map.get(objectType)
-  if (!helper) {
-    throw new Error(`Database helper not found for ${objectType}`)
-  }
-  return helper
-}
+export * from './objectCache/index'
diff --git a/lib/objectCache/ObjectCacheService.ts b/lib/objectCache/ObjectCacheService.ts
new file mode 100644
index 0000000..987de4b
--- /dev/null
+++ b/lib/objectCache/ObjectCacheService.ts
@@ -0,0 +1,268 @@
+import type { Event as NostrEvent } from 'nostr-tools'
+import type { AuthorPresentationArticle } from '@/types/nostr'
+import { buildObjectId } from '../urlGenerator'
+import type { IndexedDBHelper } from '../helpers/indexedDBHelper'
+import type { CachedObject, ObjectType } from './types'
+import { createDbHelperForObjectType, getRequiredDbHelper } from './db'
+
+export class ObjectCacheService {
+  private readonly dbHelpers: Map<ObjectType, IndexedDBHelper> = new Map()
+
+  private getDBHelper(objectType: ObjectType): IndexedDBHelper {
+    if (!this.dbHelpers.has(objectType)) {
+      const helper = createDbHelperForObjectType(objectType)
+      this.dbHelpers.set(objectType, helper)
+    }
+    return getRequiredDbHelper(this.dbHelpers, objectType)
+  }
+
+  private async initDB(objectType: ObjectType): Promise<IDBDatabase> {
+    const helper = this.getDBHelper(objectType)
+    return helper.init()
+  }
+
+  private async countObjectsWithHash(objectType: ObjectType, hash: string): Promise<number> {
+    try {
+      const helper = this.getDBHelper(objectType)
+      return helper.countByIndex('hash', IDBKeyRange.only(hash))
+    } catch (countError) {
+      console.error(`Error counting objects with hash ${hash}:`, countError)
+      return 0
+    }
+  }
+
+  async set(params: {
+    objectType: ObjectType
+    hash: string
+    event: NostrEvent
+    parsed: unknown
+    version: number
+    hidden: boolean
+    index?: number
+    published?: false | string[]
+  }): Promise<void> {
+    try {
+      const helper = this.getDBHelper(params.objectType)
+      const index = await this.resolveIndex(params.objectType, params.hash, params.index)
+      const id = buildObjectId(params.hash, index, params.version)
+      const published = await this.resolvePublishedForUpsert(helper, id, params.published)
+      await helper.put(this.buildCachedObject(params, id, index, published))
+    } catch (cacheError) {
+      console.error(`Error caching ${params.objectType} object:`, cacheError)
+    }
+  }
+
+  private async resolveIndex(objectType: ObjectType, hash: string, index: number | undefined): Promise<number> {
+    if (index !== undefined) {
+      return index
+    }
+    return this.countObjectsWithHash(objectType, hash)
+  }
+
+  private async resolvePublishedForUpsert(helper: IndexedDBHelper, id: string, published: false | string[] | undefined): Promise<false | string[]> {
+    const nextPublished = published ?? false
+    if (nextPublished !== false) {
+      return nextPublished
+    }
+    const existing = await helper.get<CachedObject>(id).catch(() => null)
+    return existing ? existing.published : false
+  }
+
+  private buildCachedObject(
+    params: { objectType: ObjectType; hash: string; event: NostrEvent; parsed: unknown; version: number; hidden: boolean },
+    id: string,
+    index: number,
+    published: false | string[]
+  ): CachedObject {
+    return {
+      id,
+      hash: params.hash,
+      hashId: params.hash,
+      index,
+      event: params.event,
+      parsed: params.parsed,
+      version: params.version,
+      hidden: params.hidden,
+      createdAt: params.event.created_at,
+      cachedAt: Date.now(),
+      published,
+    }
+  }
+
+  async updatePublished(objectType: ObjectType, id: string, published: false | string[]): Promise<void> {
+    try {
+      const helper = this.getDBHelper(objectType)
+      const existing = await helper.get<CachedObject>(id)
+      if (!existing) {
+        console.warn(`Object ${id} not found in cache, cannot update published status`)
+        return
+      }
+
+      const oldPublished = existing.published
+      await helper.put({ ...existing, published })
+
+      if (oldPublished === false && Array.isArray(published) && published.length > 0) {
+        const eventId = id.split(':')[1] ?? id
+        void import('../notificationDetector')
+          .then(({ notificationDetector }) => {
+            void notificationDetector.checkObjectChange({ objectType, objectId: id, eventId, oldPublished, newPublished: published })
+          })
+          .catch((error) => {
+            console.error('Failed to notify published status change:', error)
+          })
+      }
+    } catch (updateError) {
+      console.error(`Error updating published status for ${objectType} object:`, updateError)
+    }
+  }
+
+  async getUnpublished(objectType: ObjectType): Promise<Array<{ id: string; event: NostrEvent }>> {
+    try {
+      const db = await this.initDB(objectType)
+      const store = db.transaction(['objects'], 'readonly').objectStore('objects')
+      return new Promise((resolve, reject) => {
+        const request = store.openCursor()
+        const unpublished: Array<{ id: string; event: NostrEvent }> = []
+        request.onsuccess = (event: globalThis.Event): void => {
+          const cursor = (event.target as IDBRequest<IDBCursorWithValue>).result
+          if (cursor) {
+            const obj = cursor.value as CachedObject
+            if (obj.published === false && !obj.hidden) {
+              unpublished.push({ id: obj.id, event: obj.event })
+            }
+            cursor.continue()
+          } else {
+            resolve(unpublished)
+          }
+        }
+        request.onerror = (): void => reject(request.error)
+      })
+    } catch (getUnpublishedError) {
+      console.error(`Error retrieving unpublished ${objectType} objects:`, getUnpublishedError)
+      return []
+    }
+  }
+
+  async get(objectType: ObjectType, hash: string): Promise<unknown> {
+    try {
+      const db = await this.initDB(objectType)
+      const store = db.transaction(['objects'], 'readonly').objectStore('objects')
+      const hashIndex = store.index('hash')
+      return new Promise<unknown>((resolve, reject) => {
+        const request = hashIndex.openCursor(IDBKeyRange.only(hash))
+        const objects: CachedObject[] = []
+        request.onsuccess = (event: globalThis.Event): void => {
+          const cursor = (event.target as IDBRequest<IDBCursorWithValue>).result
+          if (cursor) {
+            const obj = cursor.value as CachedObject
+            if (obj?.hash === hash && !obj.hidden) {
+              objects.push(obj)
+            }
+            cursor.continue()
+          } else {
+            if (objects.length === 0) {
+              resolve(null)
+              return
+            }
+            objects.sort((a, b) => b.version - a.version)
+            resolve(objects[0]?.parsed ?? null)
+          }
+        }
+        request.onerror = (): void => reject(request.error)
+      })
+    } catch (retrieveError) {
+      console.error(`Error retrieving ${objectType} object from cache:`, retrieveError)
+      return null
+    }
+  }
+
+  async getById(objectType: ObjectType, id: string): Promise<unknown> {
+    try {
+      const helper = this.getDBHelper(objectType)
+      const obj = await helper.get<CachedObject>(id)
+      return obj && !obj.hidden ? obj.parsed : null
+    } catch (retrieveByIdError) {
+      console.error(`Error retrieving ${objectType} object by ID from cache:`, retrieveByIdError)
+      return null
+    }
+  }
+
+  async getEventById(objectType: ObjectType, id: string): Promise<NostrEvent | null> {
+    try {
+      const helper = this.getDBHelper(objectType)
+      const obj = await helper.get<CachedObject>(id)
+      return obj && !obj.hidden ? obj.event : null
+    } catch (retrieveByIdError) {
+      console.error(`Error retrieving ${objectType} event by ID from cache:`, retrieveByIdError)
+      return null
+    }
+  }
+
+  async getAuthorByPubkey(pubkey: string): Promise<AuthorPresentationArticle | null> {
+    try {
+      const db = await this.initDB('author')
+      const store = db.transaction(['objects'], 'readonly').objectStore('objects')
+      return new Promise((resolve, reject) => {
+        const request = store.openCursor()
+        const objects: CachedObject[] = []
+        request.onsuccess = (event: globalThis.Event): void => {
+          const cursor = (event.target as IDBRequest<IDBCursorWithValue>).result
+          if (cursor) {
+            const obj = cursor.value as CachedObject
+            if (obj?.event.pubkey === pubkey && !obj.hidden) {
+              objects.push(obj)
+            }
+            cursor.continue()
+          } else {
+            if (objects.length === 0) {
+              resolve(null)
+              return
+            }
+            objects.sort((a, b) => b.version - a.version)
+            resolve((objects[0]?.parsed ?? null) as AuthorPresentationArticle | null)
+          }
+        }
+        request.onerror = (): void => reject(request.error)
+      })
+    } catch (authorRetrieveError) {
+      console.error('Error retrieving author from cache by pubkey:', authorRetrieveError)
+      return null
+    }
+  }
+
+  async getAll(objectType: ObjectType): Promise<unknown[]> {
+    try {
+      const db = await this.initDB(objectType)
+      const store = db.transaction(['objects'], 'readonly').objectStore('objects')
+      return new Promise((resolve, reject) => {
+        const request = store.openCursor()
+        const objects: unknown[] = []
+        request.onsuccess = (event: globalThis.Event): void => {
+          const cursor = (event.target as IDBRequest<IDBCursorWithValue>).result
+          if (cursor) {
+            const obj = cursor.value as CachedObject
+            if (!obj.hidden) {
+              objects.push(obj.parsed)
+            }
+            cursor.continue()
+          } else {
+            resolve(objects)
+          }
+        }
+        request.onerror = (): void => reject(request.error)
+      })
+    } catch (getAllError) {
+      console.error(`Error retrieving all ${objectType} objects from cache:`, getAllError)
+      return []
+    }
+  }
+
+  async clear(objectType: ObjectType): Promise<void> {
+    try {
+      const helper = this.getDBHelper(objectType)
+      await helper.clear()
+    } catch (clearError) {
+      console.error(`Error clearing ${objectType} cache:`, clearError)
+    }
+  }
+}
diff --git a/lib/objectCache/db.ts b/lib/objectCache/db.ts
new file mode 100644
index 0000000..c2130ad
--- /dev/null
+++ b/lib/objectCache/db.ts
@@ -0,0 +1,57 @@
+import { createIndexedDBHelper, type IndexedDBHelper } from '../helpers/indexedDBHelper'
+import type { ObjectType } from './types'
+
+const DB_PREFIX = 'nostr_objects_'
+const DB_VERSION = 3 // Incremented to add published field
+const STORE_NAME = 'objects'
+
+export function createDbHelperForObjectType(objectType: ObjectType): IndexedDBHelper {
+  return createIndexedDBHelper({
+    dbName: `${DB_PREFIX}${objectType}`,
+    version: DB_VERSION,
+    storeName: STORE_NAME,
+    keyPath: 'id',
+    indexes: getObjectCacheIndexes(),
+    onUpgrade: (_db: IDBDatabase, event: IDBVersionChangeEvent): void => {
+      handleObjectCacheUpgrade(event)
+    },
+  })
+}
+
+export function getRequiredDbHelper(map: Map<ObjectType, IndexedDBHelper>, objectType: ObjectType): IndexedDBHelper {
+  const helper = map.get(objectType)
+  if (!helper) {
+    throw new Error(`Database helper not found for ${objectType}`)
+  }
+  return helper
+}
+
+function getObjectCacheIndexes(): Array<{ name: string; keyPath: string; unique: boolean }> {
+  return [
+    { name: 'hash', keyPath: 'hash', unique: false },
+    { name: 'hashId', keyPath: 'hashId', unique: false },
+    { name: 'version', keyPath: 'version', unique: false },
+    { name: 'index', keyPath: 'index', unique: false },
+    { name: 'hidden', keyPath: 'hidden', unique: false },
+    { name: 'cachedAt', keyPath: 'cachedAt', unique: false },
+    { name: 'published', keyPath: 'published', unique: false },
+  ]
+}
+
+function handleObjectCacheUpgrade(event: IDBVersionChangeEvent): void {
+  const target = event.target as IDBOpenDBRequest
+  const { transaction } = target
+  if (!transaction) {
+    return
+  }
+  const store = transaction.objectStore(STORE_NAME)
+  ensureIndex(store, 'hash', 'hash')
+  ensureIndex(store, 'index', 'index')
+  ensureIndex(store, 'published', 'published')
+}
+
+function ensureIndex(store: IDBObjectStore, name: string, keyPath: string): void {
+  if (!store.indexNames.contains(name)) {
+    store.createIndex(name, keyPath, { unique: false })
+  }
+}
diff --git a/lib/objectCache/index.ts b/lib/objectCache/index.ts
new file mode 100644
index 0000000..119b22a
--- /dev/null
+++ b/lib/objectCache/index.ts
@@ -0,0 +1,2 @@
+export type { ObjectType, CachedObject } from './types'
+export { objectCache } from './objectCache'
diff --git a/lib/objectCache/objectCache.ts b/lib/objectCache/objectCache.ts
new file mode 100644
index 0000000..994718f
--- /dev/null
+++ b/lib/objectCache/objectCache.ts
@@ -0,0 +1,3 @@
+import { ObjectCacheService } from './ObjectCacheService'
+
+export const objectCache = new ObjectCacheService()
diff --git a/lib/objectCache/types.ts b/lib/objectCache/types.ts
new file mode 100644
index 0000000..dde2a66
--- /dev/null
+++ b/lib/objectCache/types.ts
@@ -0,0 +1,25 @@
+import type { Event as NostrEvent } from 'nostr-tools'
+
+export type ObjectType =
+  | 'author'
+  | 'series'
+  | 'publication'
+  | 'review'
+  | 'purchase'
+  | 'sponsoring'
+  | 'review_tip'
+  | 'payment_note'
+
+export interface CachedObject {
+  id: string // Format: <hash>_<index>_<version>
+  hash: string // SHA-256 hash of the object
+  hashId: string // Legacy field for backward compatibility
+  index: number // Index for duplicates
+  event: NostrEvent
+  parsed: unknown
+  version: number
+  hidden: boolean
+  createdAt: number
+  cachedAt: number
+  published: false | string[]
+}
diff --git a/lib/paymentNotes.ts b/lib/paymentNotes.ts
index e2e43b2..3ed2818 100644
--- a/lib/paymentNotes.ts
+++ b/lib/paymentNotes.ts
@@ -1,483 +1 @@
-import { nostrService } from './nostr'
-import { buildTags } from './nostrTagSystem'
-import { PLATFORM_SERVICE } from './platformConfig'
-import { generatePurchaseHashId, generateReviewTipHashId, generateSponsoringHashId } from './hashIdGenerator'
-import { buildObjectId } from './urlGenerator'
-import type { Event, EventTemplate } from 'nostr-tools'
-import { finalizeEvent } from 'nostr-tools'
-import { hexToBytes } from 'nostr-tools/utils'
-import type { Purchase, ReviewTip, Sponsoring } from '@/types/nostr'
-import { writeOrchestrator } from './writeOrchestrator'
-import { getPublishRelays } from './relaySelection'
-
-/**
- * Publish an explicit payment note (kind 1) for a purchase
- * This note is published in addition to the zap receipt (kind 9735)
- */
-export async function publishPurchaseNote(params: {
-  articleId: string
-  authorPubkey: string
-  payerPubkey: string
-  amount: number
-  paymentHash: string
-  zapReceiptId?: string
-  category?: 'science-fiction' | 'scientific-research'
-  seriesId?: string
-  payerPrivateKey: string
-}): Promise<Event | null> {
-  const category = mapPaymentCategory(params.category)
-  const payload = await buildPurchaseNotePayload({ ...params, category })
-  return publishPaymentNoteToRelays({
-    payerPrivateKey: params.payerPrivateKey,
-    objectType: 'purchase',
-    hash: payload.hashId,
-    eventTemplate: payload.eventTemplate,
-    parsed: payload.parsedPurchase,
-    version: 0,
-    hidden: false,
-    index: 0,
-  })
-}
-
-/**
- * Publish an explicit payment note (kind 1) for a review tip
- * This note is published in addition to the zap receipt (kind 9735)
- */
-export async function publishReviewTipNote(params: {
-  articleId: string
-  reviewId: string
-  authorPubkey: string
-  reviewerPubkey: string
-  payerPubkey: string
-  amount: number
-  paymentHash: string
-  zapReceiptId?: string
-  category?: 'science-fiction' | 'scientific-research'
-  seriesId?: string
-  text?: string
-  payerPrivateKey: string
-}): Promise<Event | null> {
-  const category = mapPaymentCategory(params.category)
-  const payload = await buildReviewTipNotePayload({ ...params, category })
-  return publishPaymentNoteToRelays({
-    payerPrivateKey: params.payerPrivateKey,
-    objectType: 'review_tip',
-    hash: payload.hashId,
-    eventTemplate: payload.eventTemplate,
-    parsed: payload.parsedReviewTip,
-    version: 0,
-    hidden: false,
-    index: 0,
-  })
-}
-
-/**
- * Publish an explicit payment note (kind 1) for a sponsoring
- * This note is published in addition to the zap receipt (kind 9735) if applicable
- */
-export async function publishSponsoringNote(params: {
-  authorPubkey: string
-  payerPubkey: string
-  amount: number
-  paymentHash: string
-  category?: 'science-fiction' | 'scientific-research'
-  seriesId?: string
-  articleId?: string
-  text?: string
-  transactionId?: string // Bitcoin transaction ID for mainnet payments
-  payerPrivateKey: string
-}): Promise<Event | null> {
-  const category = mapPaymentCategory(params.category)
-  const payload = await buildSponsoringNotePayload({ ...params, category })
-
-  return publishPaymentNoteToRelays({
-    payerPrivateKey: params.payerPrivateKey,
-    objectType: 'sponsoring',
-    hash: payload.hashId,
-    eventTemplate: payload.eventTemplate,
-    parsed: payload.parsedSponsoring,
-    version: 0,
-    hidden: false,
-    index: 0,
-  })
-}
-
-function mapPaymentCategory(
-  category: 'science-fiction' | 'scientific-research' | undefined
-): 'sciencefiction' | 'research' {
-  if (category === 'scientific-research') {
-    return 'research'
-  }
-  return 'sciencefiction'
-}
-
-async function buildPurchaseNotePayload(params: {
-  articleId: string
-  authorPubkey: string
-  payerPubkey: string
-  amount: number
-  paymentHash: string
-  zapReceiptId?: string
-  category: 'sciencefiction' | 'research'
-  seriesId?: string
-}): Promise<{ hashId: string; eventTemplate: EventTemplate; parsedPurchase: Purchase }> {
-  const purchaseData = {
-    payerPubkey: params.payerPubkey,
-    articleId: params.articleId,
-    authorPubkey: params.authorPubkey,
-    amount: params.amount,
-    paymentHash: params.paymentHash,
-    ...(params.seriesId ? { seriesId: params.seriesId } : {}),
-  }
-  const hashId = await generatePurchaseHashId(purchaseData)
-  const id = buildObjectId(hashId, 0, 0)
-  const tags = buildPurchaseNoteTags({ ...params, hashId })
-  tags.push(['json', JSON.stringify({ type: 'purchase', id, hash: hashId, version: 0, index: 0, ...purchaseData })])
-  const parsedPurchase = buildParsedPurchase({ ...params, id, hashId })
-  return { hashId, eventTemplate: buildPaymentNoteTemplate(tags, `Purchase confirmed: ${params.amount} sats for article ${params.articleId}`), parsedPurchase }
-}
-
-function buildPurchaseNoteTags(params: {
-  articleId: string
-  authorPubkey: string
-  payerPubkey: string
-  amount: number
-  paymentHash: string
-  zapReceiptId?: string
-  category: 'sciencefiction' | 'research'
-  seriesId?: string
-  hashId: string
-}): string[][] {
-  return buildTags({
-    type: 'payment',
-    category: params.category,
-    id: params.hashId,
-    service: PLATFORM_SERVICE,
-    version: 0,
-    hidden: false,
-    payment: true,
-    paymentType: 'purchase',
-    amount: params.amount,
-    payerPubkey: params.payerPubkey,
-    recipientPubkey: params.authorPubkey,
-    paymentHash: params.paymentHash,
-    articleId: params.articleId,
-    ...(params.zapReceiptId ? { zapReceiptId: params.zapReceiptId } : {}),
-    ...(params.seriesId ? { seriesId: params.seriesId } : {}),
-  })
-}
-
-function buildParsedPurchase(params: {
-  articleId: string
-  authorPubkey: string
-  payerPubkey: string
-  amount: number
-  paymentHash: string
-  id: string
-  hashId: string
-  seriesId?: string
-}): Purchase {
-  return {
-    id: params.id,
-    hash: params.hashId,
-    version: 0,
-    index: 0,
-    payerPubkey: params.payerPubkey,
-    articleId: params.articleId,
-    authorPubkey: params.authorPubkey,
-    amount: params.amount,
-    paymentHash: params.paymentHash,
-    createdAt: Math.floor(Date.now() / 1000),
-    ...(params.seriesId ? { seriesId: params.seriesId } : {}),
-    kindType: 'purchase',
-  }
-}
-
-async function buildReviewTipNotePayload(params: {
-  articleId: string
-  reviewId: string
-  authorPubkey: string
-  reviewerPubkey: string
-  payerPubkey: string
-  amount: number
-  paymentHash: string
-  zapReceiptId?: string
-  category: 'sciencefiction' | 'research'
-  seriesId?: string
-  text?: string
-}): Promise<{ hashId: string; eventTemplate: EventTemplate; parsedReviewTip: ReviewTip }> {
-  const tipData = {
-    payerPubkey: params.payerPubkey,
-    articleId: params.articleId,
-    reviewId: params.reviewId,
-    reviewerPubkey: params.reviewerPubkey,
-    authorPubkey: params.authorPubkey,
-    amount: params.amount,
-    paymentHash: params.paymentHash,
-    ...(params.seriesId ? { seriesId: params.seriesId } : {}),
-    ...(params.text ? { text: params.text } : {}),
-  }
-  const hashId = await generateReviewTipHashId(tipData)
-  const id = buildObjectId(hashId, 0, 0)
-  const tags = buildReviewTipNoteTags({ ...params, hashId })
-  tags.push(['json', JSON.stringify({ type: 'review_tip', id, hash: hashId, version: 0, index: 0, ...tipData })])
-  const parsedReviewTip = buildParsedReviewTip({ ...params, id, hashId })
-  return { hashId, eventTemplate: buildPaymentNoteTemplate(tags, buildReviewTipNoteContent(params)), parsedReviewTip }
-}
-
-function buildReviewTipNoteTags(params: {
-  articleId: string
-  reviewId: string
-  authorPubkey: string
-  reviewerPubkey: string
-  payerPubkey: string
-  amount: number
-  paymentHash: string
-  zapReceiptId?: string
-  category: 'sciencefiction' | 'research'
-  seriesId?: string
-  text?: string
-  hashId: string
-}): string[][] {
-  return buildTags({
-    type: 'payment',
-    category: params.category,
-    id: params.hashId,
-    service: PLATFORM_SERVICE,
-    version: 0,
-    hidden: false,
-    payment: true,
-    paymentType: 'review_tip',
-    amount: params.amount,
-    payerPubkey: params.payerPubkey,
-    recipientPubkey: params.reviewerPubkey,
-    paymentHash: params.paymentHash,
-    articleId: params.articleId,
-    reviewId: params.reviewId,
-    ...(params.zapReceiptId ? { zapReceiptId: params.zapReceiptId } : {}),
-    ...(params.seriesId ? { seriesId: params.seriesId } : {}),
-    ...(params.text ? { text: params.text } : {}),
-  })
-}
-
-function buildReviewTipNoteContent(params: { amount: number; reviewId: string; text?: string }): string {
-  const prefix = `Review tip confirmed: ${params.amount} sats for review ${params.reviewId}`
-  return params.text ? `${prefix}\n\n${params.text}` : prefix
-}
-
-function buildParsedReviewTip(params: {
-  articleId: string
-  reviewId: string
-  authorPubkey: string
-  reviewerPubkey: string
-  payerPubkey: string
-  amount: number
-  paymentHash: string
-  seriesId?: string
-  text?: string
-  id: string
-  hashId: string
-}): ReviewTip {
-  return {
-    id: params.id,
-    hash: params.hashId,
-    version: 0,
-    index: 0,
-    payerPubkey: params.payerPubkey,
-    articleId: params.articleId,
-    reviewId: params.reviewId,
-    reviewerPubkey: params.reviewerPubkey,
-    authorPubkey: params.authorPubkey,
-    amount: params.amount,
-    paymentHash: params.paymentHash,
-    createdAt: Math.floor(Date.now() / 1000),
-    ...(params.seriesId ? { seriesId: params.seriesId } : {}),
-    ...(params.text ? { text: params.text } : {}),
-    kindType: 'review_tip',
-  }
-}
-
-function buildPaymentNoteTemplate(tags: string[][], content: string): EventTemplate {
-  return {
-    kind: 1,
-    created_at: Math.floor(Date.now() / 1000),
-    tags,
-    content,
-  }
-}
-
-async function buildSponsoringNotePayload(params: {
-  authorPubkey: string
-  payerPubkey: string
-  amount: number
-  paymentHash: string
-  category: 'sciencefiction' | 'research'
-  seriesId?: string
-  articleId?: string
-  text?: string
-  transactionId?: string
-}): Promise<{
-  hashId: string
-  eventTemplate: EventTemplate
-  parsedSponsoring: Sponsoring
-}> {
-  const sponsoringData = buildSponsoringHashInput(params)
-  const hashId = await generateSponsoringHashId(sponsoringData)
-  const id = buildObjectId(hashId, 0, 0)
-  const tags = buildSponsoringNoteTags({ ...params, hashId })
-  tags.push(['json', buildSponsoringPaymentJson({ ...params, sponsoringData, id, hashId })])
-  const parsedSponsoring = buildParsedSponsoring({ ...params, id, hashId })
-  const eventTemplate = buildSponsoringEventTemplate({ tags, content: buildSponsoringNoteContent(params) })
-  return { hashId, eventTemplate, parsedSponsoring }
-}
-
-function buildSponsoringHashInput(params: {
-  payerPubkey: string
-  authorPubkey: string
-  amount: number
-  paymentHash: string
-  seriesId?: string
-  articleId?: string
-}): Parameters<typeof generateSponsoringHashId>[0] {
-  return {
-    payerPubkey: params.payerPubkey,
-    authorPubkey: params.authorPubkey,
-    amount: params.amount,
-    paymentHash: params.paymentHash,
-    ...(params.seriesId ? { seriesId: params.seriesId } : {}),
-    ...(params.articleId ? { articleId: params.articleId } : {}),
-  }
-}
-
-function buildParsedSponsoring(params: {
-  authorPubkey: string
-  payerPubkey: string
-  amount: number
-  paymentHash: string
-  seriesId?: string
-  articleId?: string
-  text?: string
-  id: string
-  hashId: string
-}): Sponsoring {
-  return {
-    id: params.id,
-    hash: params.hashId,
-    version: 0,
-    index: 0,
-    payerPubkey: params.payerPubkey,
-    authorPubkey: params.authorPubkey,
-    amount: params.amount,
-    paymentHash: params.paymentHash,
-    createdAt: Math.floor(Date.now() / 1000),
-    ...(params.seriesId ? { seriesId: params.seriesId } : {}),
-    ...(params.articleId ? { articleId: params.articleId } : {}),
-    ...(params.text ? { text: params.text } : {}),
-    kindType: 'sponsoring',
-  }
-}
-
-function buildSponsoringEventTemplate(params: { tags: string[][]; content: string }): EventTemplate {
-  return { kind: 1, created_at: Math.floor(Date.now() / 1000), tags: params.tags, content: params.content }
-}
-
-function buildSponsoringNoteContent(params: {
-  authorPubkey: string
-  amount: number
-  text?: string
-}): string {
-  const prefix = `Sponsoring confirmed: ${params.amount} sats for author ${params.authorPubkey.substring(0, 16)}...`
-  return params.text ? `${prefix}\n\n${params.text}` : prefix
-}
-
-function buildSponsoringNoteTags(params: {
-  authorPubkey: string
-  payerPubkey: string
-  amount: number
-  paymentHash: string
-  category: 'sciencefiction' | 'research'
-  seriesId?: string
-  articleId?: string
-  text?: string
-  transactionId?: string
-  hashId: string
-}): string[][] {
-  const tags = buildTags({
-    type: 'payment',
-    category: params.category,
-    id: params.hashId,
-    service: PLATFORM_SERVICE,
-    version: 0,
-    hidden: false,
-    payment: true,
-    paymentType: 'sponsoring',
-    amount: params.amount,
-    payerPubkey: params.payerPubkey,
-    recipientPubkey: params.authorPubkey,
-    paymentHash: params.paymentHash,
-    ...(params.seriesId ? { seriesId: params.seriesId } : {}),
-    ...(params.articleId ? { articleId: params.articleId } : {}),
-    ...(params.text ? { text: params.text } : {}),
-  })
-
-  if (params.transactionId) {
-    tags.push(['transaction_id', params.transactionId])
-  }
-
-  return tags
-}
-
-function buildSponsoringPaymentJson(params: {
-  id: string
-  hashId: string
-  sponsoringData: Record<string, unknown>
-  text?: string
-  transactionId?: string
-}): string {
-  return JSON.stringify({
-    type: 'sponsoring',
-    id: params.id,
-    hash: params.hashId,
-    version: 0,
-    index: 0,
-    ...params.sponsoringData,
-    ...(params.text ? { text: params.text } : {}),
-    ...(params.transactionId ? { transactionId: params.transactionId } : {}),
-  })
-}
-
-async function publishPaymentNoteToRelays(params: {
-  payerPrivateKey: string
-  objectType: 'purchase' | 'review_tip' | 'sponsoring'
-  hash: string
-  eventTemplate: EventTemplate
-  parsed: Purchase | ReviewTip | Sponsoring
-  version: number
-  hidden: boolean
-  index: number
-}): Promise<Event | null> {
-  nostrService.setPrivateKey(params.payerPrivateKey)
-  writeOrchestrator.setPrivateKey(params.payerPrivateKey)
-
-  const secretKey = hexToBytes(params.payerPrivateKey)
-  const event = finalizeEvent(params.eventTemplate, secretKey)
-  const relays = await getPublishRelays()
-
-  const result = await writeOrchestrator.writeAndPublish(
-    {
-      objectType: params.objectType,
-      hash: params.hash,
-      event,
-      parsed: params.parsed,
-      version: params.version,
-      hidden: params.hidden,
-      index: params.index,
-    },
-    relays
-  )
-
-  if (!result.success) {
-    return null
-  }
-  return event
-}
+export * from './paymentNotes/index'
diff --git a/lib/paymentNotes/index.ts b/lib/paymentNotes/index.ts
new file mode 100644
index 0000000..d23b796
--- /dev/null
+++ b/lib/paymentNotes/index.ts
@@ -0,0 +1,3 @@
+export { publishPurchaseNote } from './purchase'
+export { publishReviewTipNote } from './reviewTip'
+export { publishSponsoringNote } from './sponsoring'
diff --git a/lib/paymentNotes/purchase.ts b/lib/paymentNotes/purchase.ts
new file mode 100644
index 0000000..7267dda
--- /dev/null
+++ b/lib/paymentNotes/purchase.ts
@@ -0,0 +1,114 @@
+import type { Event } from 'nostr-tools'
+import type { Purchase } from '@/types/nostr'
+import { buildTags } from '../nostrTagSystem'
+import { PLATFORM_SERVICE } from '../platformConfig'
+import { generatePurchaseHashId } from '../hashIdGenerator'
+import { buildObjectId } from '../urlGenerator'
+import { buildPaymentNoteTemplate, mapPaymentCategory, type PaymentCategoryTag, publishPaymentNoteToRelays } from './shared'
+
+export async function publishPurchaseNote(params: {
+  articleId: string
+  authorPubkey: string
+  payerPubkey: string
+  amount: number
+  paymentHash: string
+  zapReceiptId?: string
+  category?: 'science-fiction' | 'scientific-research'
+  seriesId?: string
+  payerPrivateKey: string
+}): Promise<Event | null> {
+  const category = mapPaymentCategory(params.category)
+  const payload = await buildPurchaseNotePayload({ ...params, category })
+  return publishPaymentNoteToRelays({
+    payerPrivateKey: params.payerPrivateKey,
+    objectType: 'purchase',
+    hash: payload.hashId,
+    eventTemplate: payload.eventTemplate,
+    parsed: payload.parsedPurchase,
+    version: 0,
+    hidden: false,
+    index: 0,
+  })
+}
+
+async function buildPurchaseNotePayload(params: {
+  articleId: string
+  authorPubkey: string
+  payerPubkey: string
+  amount: number
+  paymentHash: string
+  zapReceiptId?: string
+  category: PaymentCategoryTag
+  seriesId?: string
+}): Promise<{ hashId: string; eventTemplate: import('nostr-tools').EventTemplate; parsedPurchase: Purchase }> {
+  const purchaseData = {
+    payerPubkey: params.payerPubkey,
+    articleId: params.articleId,
+    authorPubkey: params.authorPubkey,
+    amount: params.amount,
+    paymentHash: params.paymentHash,
+    ...(params.seriesId ? { seriesId: params.seriesId } : {}),
+  }
+  const hashId = await generatePurchaseHashId(purchaseData)
+  const id = buildObjectId(hashId, 0, 0)
+  const tags = buildPurchaseNoteTags({ ...params, hashId })
+  tags.push(['json', JSON.stringify({ type: 'purchase', id, hash: hashId, version: 0, index: 0, ...purchaseData })])
+  const parsedPurchase = buildParsedPurchase({ ...params, id, hashId })
+  return { hashId, eventTemplate: buildPaymentNoteTemplate(tags, `Purchase confirmed: ${params.amount} sats for article ${params.articleId}`), parsedPurchase }
+}
+
+function buildPurchaseNoteTags(params: {
+  articleId: string
+  authorPubkey: string
+  payerPubkey: string
+  amount: number
+  paymentHash: string
+  zapReceiptId?: string
+  category: PaymentCategoryTag
+  seriesId?: string
+  hashId: string
+}): string[][] {
+  return buildTags({
+    type: 'payment',
+    category: params.category,
+    id: params.hashId,
+    service: PLATFORM_SERVICE,
+    version: 0,
+    hidden: false,
+    payment: true,
+    paymentType: 'purchase',
+    amount: params.amount,
+    payerPubkey: params.payerPubkey,
+    recipientPubkey: params.authorPubkey,
+    paymentHash: params.paymentHash,
+    articleId: params.articleId,
+    ...(params.zapReceiptId ? { zapReceiptId: params.zapReceiptId } : {}),
+    ...(params.seriesId ? { seriesId: params.seriesId } : {}),
+  })
+}
+
+function buildParsedPurchase(params: {
+  articleId: string
+  authorPubkey: string
+  payerPubkey: string
+  amount: number
+  paymentHash: string
+  id: string
+  hashId: string
+  seriesId?: string
+}): Purchase {
+  return {
+    id: params.id,
+    hash: params.hashId,
+    version: 0,
+    index: 0,
+    payerPubkey: params.payerPubkey,
+    articleId: params.articleId,
+    authorPubkey: params.authorPubkey,
+    amount: params.amount,
+    paymentHash: params.paymentHash,
+    createdAt: Math.floor(Date.now() / 1000),
+    ...(params.seriesId ? { seriesId: params.seriesId } : {}),
+    kindType: 'purchase',
+  }
+}
diff --git a/lib/paymentNotes/reviewTip.ts b/lib/paymentNotes/reviewTip.ts
new file mode 100644
index 0000000..3e10134
--- /dev/null
+++ b/lib/paymentNotes/reviewTip.ts
@@ -0,0 +1,139 @@
+import type { Event } from 'nostr-tools'
+import type { ReviewTip } from '@/types/nostr'
+import { buildTags } from '../nostrTagSystem'
+import { PLATFORM_SERVICE } from '../platformConfig'
+import { generateReviewTipHashId } from '../hashIdGenerator'
+import { buildObjectId } from '../urlGenerator'
+import { buildPaymentNoteTemplate, mapPaymentCategory, type PaymentCategoryTag, publishPaymentNoteToRelays } from './shared'
+
+export async function publishReviewTipNote(params: {
+  articleId: string
+  reviewId: string
+  authorPubkey: string
+  reviewerPubkey: string
+  payerPubkey: string
+  amount: number
+  paymentHash: string
+  zapReceiptId?: string
+  category?: 'science-fiction' | 'scientific-research'
+  seriesId?: string
+  text?: string
+  payerPrivateKey: string
+}): Promise<Event | null> {
+  const category = mapPaymentCategory(params.category)
+  const payload = await buildReviewTipNotePayload({ ...params, category })
+  return publishPaymentNoteToRelays({
+    payerPrivateKey: params.payerPrivateKey,
+    objectType: 'review_tip',
+    hash: payload.hashId,
+    eventTemplate: payload.eventTemplate,
+    parsed: payload.parsedReviewTip,
+    version: 0,
+    hidden: false,
+    index: 0,
+  })
+}
+
+async function buildReviewTipNotePayload(params: {
+  articleId: string
+  reviewId: string
+  authorPubkey: string
+  reviewerPubkey: string
+  payerPubkey: string
+  amount: number
+  paymentHash: string
+  zapReceiptId?: string
+  category: PaymentCategoryTag
+  seriesId?: string
+  text?: string
+}): Promise<{ hashId: string; eventTemplate: import('nostr-tools').EventTemplate; parsedReviewTip: ReviewTip }> {
+  const tipData = {
+    payerPubkey: params.payerPubkey,
+    articleId: params.articleId,
+    reviewId: params.reviewId,
+    reviewerPubkey: params.reviewerPubkey,
+    authorPubkey: params.authorPubkey,
+    amount: params.amount,
+    paymentHash: params.paymentHash,
+    ...(params.seriesId ? { seriesId: params.seriesId } : {}),
+    ...(params.text ? { text: params.text } : {}),
+  }
+  const hashId = await generateReviewTipHashId(tipData)
+  const id = buildObjectId(hashId, 0, 0)
+  const tags = buildReviewTipNoteTags({ ...params, hashId })
+  tags.push(['json', JSON.stringify({ type: 'review_tip', id, hash: hashId, version: 0, index: 0, ...tipData })])
+  const parsedReviewTip = buildParsedReviewTip({ ...params, id, hashId })
+  return { hashId, eventTemplate: buildPaymentNoteTemplate(tags, buildReviewTipNoteContent(params)), parsedReviewTip }
+}
+
+function buildReviewTipNoteTags(params: {
+  articleId: string
+  reviewId: string
+  authorPubkey: string
+  reviewerPubkey: string
+  payerPubkey: string
+  amount: number
+  paymentHash: string
+  zapReceiptId?: string
+  category: PaymentCategoryTag
+  seriesId?: string
+  text?: string
+  hashId: string
+}): string[][] {
+  return buildTags({
+    type: 'payment',
+    category: params.category,
+    id: params.hashId,
+    service: PLATFORM_SERVICE,
+    version: 0,
+    hidden: false,
+    payment: true,
+    paymentType: 'review_tip',
+    amount: params.amount,
+    payerPubkey: params.payerPubkey,
+    recipientPubkey: params.reviewerPubkey,
+    paymentHash: params.paymentHash,
+    articleId: params.articleId,
+    reviewId: params.reviewId,
+    ...(params.zapReceiptId ? { zapReceiptId: params.zapReceiptId } : {}),
+    ...(params.seriesId ? { seriesId: params.seriesId } : {}),
+    ...(params.text ? { text: params.text } : {}),
+  })
+}
+
+function buildReviewTipNoteContent(params: { amount: number; reviewId: string; text?: string }): string {
+  const prefix = `Review tip confirmed: ${params.amount} sats for review ${params.reviewId}`
+  return params.text ? `${prefix}\n\n${params.text}` : prefix
+}
+
+function buildParsedReviewTip(params: {
+  articleId: string
+  reviewId: string
+  authorPubkey: string
+  reviewerPubkey: string
+  payerPubkey: string
+  amount: number
+  paymentHash: string
+  seriesId?: string
+  text?: string
+  id: string
+  hashId: string
+}): ReviewTip {
+  return {
+    id: params.id,
+    hash: params.hashId,
+    version: 0,
+    index: 0,
+    payerPubkey: params.payerPubkey,
+    articleId: params.articleId,
+    reviewId: params.reviewId,
+    reviewerPubkey: params.reviewerPubkey,
+    authorPubkey: params.authorPubkey,
+    amount: params.amount,
+    paymentHash: params.paymentHash,
+    createdAt: Math.floor(Date.now() / 1000),
+    ...(params.seriesId ? { seriesId: params.seriesId } : {}),
+    ...(params.text ? { text: params.text } : {}),
+    kindType: 'review_tip',
+  }
+}
diff --git a/lib/paymentNotes/shared.ts b/lib/paymentNotes/shared.ts
new file mode 100644
index 0000000..4f95c08
--- /dev/null
+++ b/lib/paymentNotes/shared.ts
@@ -0,0 +1,38 @@
+import { nostrService } from '../nostr'
+import type { Event, EventTemplate } from 'nostr-tools'
+import { finalizeEvent } from 'nostr-tools'
+import { hexToBytes } from 'nostr-tools/utils'
+import { writeOrchestrator } from '../writeOrchestrator'
+import { getPublishRelays } from '../relaySelection'
+import type { Purchase, ReviewTip, Sponsoring } from '@/types/nostr'
+
+export type PaymentCategoryTag = 'sciencefiction' | 'research'
+
+export function mapPaymentCategory(category: 'science-fiction' | 'scientific-research' | undefined): PaymentCategoryTag {
+  return category === 'scientific-research' ? 'research' : 'sciencefiction'
+}
+
+export function buildPaymentNoteTemplate(tags: string[][], content: string): EventTemplate {
+  return { kind: 1, created_at: Math.floor(Date.now() / 1000), tags, content }
+}
+
+export async function publishPaymentNoteToRelays(params: {
+  payerPrivateKey: string
+  objectType: 'purchase' | 'review_tip' | 'sponsoring'
+  hash: string
+  eventTemplate: EventTemplate
+  parsed: Purchase | ReviewTip | Sponsoring
+  version: number
+  hidden: boolean
+  index: number
+}): Promise<Event | null> {
+  nostrService.setPrivateKey(params.payerPrivateKey)
+  writeOrchestrator.setPrivateKey(params.payerPrivateKey)
+  const event = finalizeEvent(params.eventTemplate, hexToBytes(params.payerPrivateKey))
+  const relays = await getPublishRelays()
+  const result = await writeOrchestrator.writeAndPublish(
+    { objectType: params.objectType, hash: params.hash, event, parsed: params.parsed, version: params.version, hidden: params.hidden, index: params.index },
+    relays
+  )
+  return result.success ? event : null
+}
diff --git a/lib/paymentNotes/sponsoring.ts b/lib/paymentNotes/sponsoring.ts
new file mode 100644
index 0000000..1c401f6
--- /dev/null
+++ b/lib/paymentNotes/sponsoring.ts
@@ -0,0 +1,162 @@
+import type { Event, EventTemplate } from 'nostr-tools'
+import type { Sponsoring } from '@/types/nostr'
+import { buildTags } from '../nostrTagSystem'
+import { PLATFORM_SERVICE } from '../platformConfig'
+import { generateSponsoringHashId } from '../hashIdGenerator'
+import { buildObjectId } from '../urlGenerator'
+import { buildPaymentNoteTemplate, mapPaymentCategory, type PaymentCategoryTag, publishPaymentNoteToRelays } from './shared'
+
+export async function publishSponsoringNote(params: {
+  authorPubkey: string
+  payerPubkey: string
+  amount: number
+  paymentHash: string
+  category?: 'science-fiction' | 'scientific-research'
+  seriesId?: string
+  articleId?: string
+  text?: string
+  transactionId?: string
+  payerPrivateKey: string
+}): Promise<Event | null> {
+  const category = mapPaymentCategory(params.category)
+  const payload = await buildSponsoringNotePayload({ ...params, category })
+  return publishPaymentNoteToRelays({
+    payerPrivateKey: params.payerPrivateKey,
+    objectType: 'sponsoring',
+    hash: payload.hashId,
+    eventTemplate: payload.eventTemplate,
+    parsed: payload.parsedSponsoring,
+    version: 0,
+    hidden: false,
+    index: 0,
+  })
+}
+
+async function buildSponsoringNotePayload(params: {
+  authorPubkey: string
+  payerPubkey: string
+  amount: number
+  paymentHash: string
+  category: PaymentCategoryTag
+  seriesId?: string
+  articleId?: string
+  text?: string
+  transactionId?: string
+}): Promise<{ hashId: string; eventTemplate: EventTemplate; parsedSponsoring: Sponsoring }> {
+  const sponsoringData = buildSponsoringHashInput(params)
+  const hashId = await generateSponsoringHashId(sponsoringData)
+  const id = buildObjectId(hashId, 0, 0)
+  const tags = buildSponsoringNoteTags({ ...params, hashId })
+  tags.push(['json', buildSponsoringPaymentJson({ id, hashId, sponsoringData, text: params.text, transactionId: params.transactionId })])
+  const parsedSponsoring = buildParsedSponsoring({ ...params, id, hashId })
+  return { hashId, eventTemplate: buildSponsoringEventTemplate({ tags, content: buildSponsoringNoteContent(params) }), parsedSponsoring }
+}
+
+function buildSponsoringHashInput(params: {
+  payerPubkey: string
+  authorPubkey: string
+  amount: number
+  paymentHash: string
+  seriesId?: string
+  articleId?: string
+}): Parameters<typeof generateSponsoringHashId>[0] {
+  return {
+    payerPubkey: params.payerPubkey,
+    authorPubkey: params.authorPubkey,
+    amount: params.amount,
+    paymentHash: params.paymentHash,
+    ...(params.seriesId ? { seriesId: params.seriesId } : {}),
+    ...(params.articleId ? { articleId: params.articleId } : {}),
+  }
+}
+
+function buildParsedSponsoring(params: {
+  authorPubkey: string
+  payerPubkey: string
+  amount: number
+  paymentHash: string
+  seriesId?: string
+  articleId?: string
+  text?: string
+  id: string
+  hashId: string
+}): Sponsoring {
+  return {
+    id: params.id,
+    hash: params.hashId,
+    version: 0,
+    index: 0,
+    payerPubkey: params.payerPubkey,
+    authorPubkey: params.authorPubkey,
+    amount: params.amount,
+    paymentHash: params.paymentHash,
+    createdAt: Math.floor(Date.now() / 1000),
+    ...(params.seriesId ? { seriesId: params.seriesId } : {}),
+    ...(params.articleId ? { articleId: params.articleId } : {}),
+    ...(params.text ? { text: params.text } : {}),
+    kindType: 'sponsoring',
+  }
+}
+
+function buildSponsoringEventTemplate(params: { tags: string[][]; content: string }): EventTemplate {
+  return buildPaymentNoteTemplate(params.tags, params.content)
+}
+
+function buildSponsoringNoteContent(params: { authorPubkey: string; amount: number; text?: string }): string {
+  const prefix = `Sponsoring confirmed: ${params.amount} sats for author ${params.authorPubkey.substring(0, 16)}...`
+  return params.text ? `${prefix}\n\n${params.text}` : prefix
+}
+
+function buildSponsoringNoteTags(params: {
+  authorPubkey: string
+  payerPubkey: string
+  amount: number
+  paymentHash: string
+  category: PaymentCategoryTag
+  seriesId?: string
+  articleId?: string
+  text?: string
+  transactionId?: string
+  hashId: string
+}): string[][] {
+  const tags = buildTags({
+    type: 'payment',
+    category: params.category,
+    id: params.hashId,
+    service: PLATFORM_SERVICE,
+    version: 0,
+    hidden: false,
+    payment: true,
+    paymentType: 'sponsoring',
+    amount: params.amount,
+    payerPubkey: params.payerPubkey,
+    recipientPubkey: params.authorPubkey,
+    paymentHash: params.paymentHash,
+    ...(params.seriesId ? { seriesId: params.seriesId } : {}),
+    ...(params.articleId ? { articleId: params.articleId } : {}),
+    ...(params.text ? { text: params.text } : {}),
+  })
+  if (params.transactionId) {
+    tags.push(['transaction_id', params.transactionId])
+  }
+  return tags
+}
+
+function buildSponsoringPaymentJson(params: {
+  id: string
+  hashId: string
+  sponsoringData: Record<string, unknown>
+  text?: string
+  transactionId?: string
+}): string {
+  return JSON.stringify({
+    type: 'sponsoring',
+    id: params.id,
+    hash: params.hashId,
+    version: 0,
+    index: 0,
+    ...params.sponsoringData,
+    ...(params.text ? { text: params.text } : {}),
+    ...(params.transactionId ? { transactionId: params.transactionId } : {}),
+  })
+}
diff --git a/lib/platformSync.ts b/lib/platformSync.ts
index 074ed9a..f4e4eaf 100644
--- a/lib/platformSync.ts
+++ b/lib/platformSync.ts
@@ -1,624 +1 @@
-/**
- * Background sync service that scans all notes with service='zapwall.fr' tag
- * and caches them in IndexedDB
- * Runs in background (non-blocking) and updates cache when new notes are published
- */
-
-import type { Event } from 'nostr-tools'
-import type { SimplePoolWithSub } from '@/types/nostr-tools-extended'
-import { createSubscription } from '@/types/nostr-tools-extended'
-import { nostrService } from './nostr'
-import { PLATFORM_SERVICE, MIN_EVENT_DATE } from './platformConfig'
-import { extractTagsFromEvent } from './nostrTagSystem'
-import { parsePresentationEvent } from './articlePublisherHelpersPresentation'
-import { parseArticleFromEvent, parseSeriesFromEvent, parseReviewFromEvent, parsePurchaseFromEvent, parseReviewTipFromEvent, parseSponsoringFromEvent } from './nostrEventParsing'
-
-const TARGET_EVENT_ID = '527d83e0af20bf23c3e104974090ccc21536ece72c24eb784b3642890f63b763'
-
-class PlatformSyncService {
-  private syncInProgress = false
-  private syncSubscription: { unsub: () => void } | null = null
-  private lastSyncTime: number = 0
-  private readonly SYNC_INTERVAL_MS = 60000 // Sync every minute
-  private readonly SYNC_TIMEOUT_MS = 60000 // 60 seconds timeout per relay (increased from 30s)
-
-  /**
-   * Start background sync
-   * Scans all notes with service='zapwall.fr' and caches them
-   * Does not require pubkey - syncs all public notes with service='zapwall.fr'
-   */
-  async startSync(): Promise<void> {
-    if (this.syncInProgress) {
-      return
-    }
-
-    const pool = nostrService.getPool()
-    if (!pool) {
-      console.warn('Pool not initialized, cannot start platform sync')
-      return
-    }
-
-    this.syncInProgress = true
-
-    // Update progress manager to show sync indicator
-    const { syncProgressManager } = await import('./syncProgressManager')
-    const { relaySessionManager } = await import('./relaySessionManager')
-    const activeRelays = await relaySessionManager.getActiveRelays()
-    const initialRelay = activeRelays[0] ?? 'Connecting...'
-    const totalRelays = activeRelays.length ?? 1
-    syncProgressManager.setProgress({ currentStep: 0, totalSteps: totalRelays, completed: false, currentRelay: initialRelay })
-
-    try {
-      await this.performSync(pool as unknown as SimplePoolWithSub)
-
-      // Mark as completed after all relays are processed
-      const finalRelay = activeRelays[activeRelays.length - 1] ?? initialRelay
-      syncProgressManager.setProgress({ currentStep: totalRelays, totalSteps: totalRelays, completed: true, currentRelay: finalRelay })
-    } catch (error) {
-      console.error('Error in platform sync:', error)
-      syncProgressManager.setProgress(null)
-    } finally {
-      this.syncInProgress = false
-      // Clear progress after a short delay
-      setTimeout(() => {
-        syncProgressManager.setProgress(null)
-      }, 500)
-    }
-  }
-
-  /**
-   * Perform a sync operation
-   * Scans all notes with service='zapwall.fr' tag from ALL active relays
-   * Starts from January 5, 2026 00:00:00 UTC
-   */
-  private async performSync(pool: SimplePoolWithSub): Promise<void> {
-    // Don't filter by #service on relay side - some relays don't support it well
-    // Instead, fetch all kind 1 events since MIN_EVENT_DATE and filter client-side
-    const filters = [
-      {
-        kinds: [1],
-        since: MIN_EVENT_DATE, // January 5, 2026 00:00:00 UTC
-        limit: 1000, // Get up to 1000 events per sync
-      },
-    ]
-
-    console.warn(`[PlatformSync] Starting sync with filter (no #service filter on relay side):`, JSON.stringify(filters, null, 2))
-    console.warn(`[PlatformSync] MIN_EVENT_DATE: ${MIN_EVENT_DATE} (${new Date(MIN_EVENT_DATE * 1000).toISOString()})`)
-    console.warn(`[PlatformSync] Will filter by service='${PLATFORM_SERVICE}' client-side after receiving events`)
-
-    const { relaySessionManager } = await import('./relaySessionManager')
-    const { syncProgressManager } = await import('./syncProgressManager')
-    const activeRelays = await relaySessionManager.getActiveRelays()
-
-    if (activeRelays.length === 0) {
-      throw new Error('No active relays available')
-    }
-
-    const allEvents: Event[] = []
-    const processedEventIds = new Set<string>()
-
-    // Synchronize from all active relays
-    for (let i = 0; i < activeRelays.length; i++) {
-      const relayUrl = activeRelays[i]
-      if (relayUrl) {
-        // Update progress with current relay
-        syncProgressManager.setProgress({
-        currentStep: 0,
-        totalSteps: activeRelays.length,
-        completed: false,
-        currentRelay: relayUrl,
-      })
-
-      try {
-        console.warn(`[PlatformSync] Synchronizing from relay ${i + 1}/${activeRelays.length}: ${relayUrl}`)
-
-        const sub = createSubscription(pool, [relayUrl], filters)
-
-        const relayEvents: Event[] = []
-        let resolved = false
-        let eventCount = 0
-
-        const finalize = async (): Promise<void> => {
-          if (resolved) {
-            return
-          }
-          resolved = true
-          sub.unsub()
-
-          // Deduplicate events by ID before adding to allEvents
-          for (const event of relayEvents) {
-            if (!processedEventIds.has(event.id)) {
-              processedEventIds.add(event.id)
-              allEvents.push(event)
-            }
-          }
-
-          console.warn(`[PlatformSync] Relay ${relayUrl} completed: received ${eventCount} total events from relay, ${relayEvents.length} filtered with service='${PLATFORM_SERVICE}'`)
-
-          // Update lastSyncDate for this relay on successful sync
-          if (relayEvents.length > 0 || eventCount > 0) {
-            const { configStorage } = await import('./configStorage')
-            const config = await configStorage.getConfig()
-            const relayConfig = config.relays.find((r) => r.url === relayUrl)
-            if (relayConfig) {
-              await configStorage.updateRelay(relayConfig.id, { lastSyncDate: Date.now() })
-            }
-          }
-        }
-        await new Promise<void>((resolve) => {
-          sub.on('event', (event: Event): void => {
-            eventCount = this.handleRelaySyncEvent({
-              event,
-              relayUrl,
-              relayEvents,
-              eventCount,
-            })
-          })
-
-          sub.on('eose', (): void => {
-            console.warn(`[PlatformSync] Relay ${relayUrl} sent EOSE signal`)
-            void finalize()
-            resolve()
-          })
-
-          // Timeout after SYNC_TIMEOUT_MS
-          const timeoutId = setTimeout((): void => {
-            console.warn(`[PlatformSync] Relay ${relayUrl} timeout after ${this.SYNC_TIMEOUT_MS}ms`)
-            void finalize()
-            resolve()
-          }, this.SYNC_TIMEOUT_MS)
-          timeoutId.unref?.()
-
-          this.syncSubscription = sub
-        })
-
-        // Update progress after each relay
-        syncProgressManager.setProgress({
-          currentStep: i + 1,
-          totalSteps: activeRelays.length,
-          completed: false,
-          currentRelay: relayUrl,
-        })
-      } catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error)
-        console.warn(`[PlatformSync] Relay ${relayUrl} failed: ${errorMessage}`)
-        // Mark relay as failed but continue with next relay
-        relaySessionManager.markRelayFailed(relayUrl)
-        // Update progress even on failure
-        syncProgressManager.setProgress({
-          currentStep: i + 1,
-          totalSteps: activeRelays.length,
-          completed: false,
-          currentRelay: relayUrl,
-        })
-      }
-      }
-    }
-
-    // Process all collected events
-    await this.processAndCacheEvents(allEvents)
-    console.warn(`[PlatformSync] Total events collected from all relays: ${allEvents.length}`)
-
-    this.lastSyncTime = Date.now()
-  }
-
-  /**
-   * Process events and cache them by type
-   */
-  private async processAndCacheEvents(events: Event[]): Promise<void> {
-    for (const event of events) {
-      try {
-        await this.processEvent(event)
-      } catch (error) {
-        console.error('Error processing event:', error, event.id)
-        // Continue processing other events even if one fails
-      }
-    }
-  }
-
-  private handleRelaySyncEvent(params: {
-    event: Event
-    relayUrl: string
-    relayEvents: Event[]
-    eventCount: number
-  }): number {
-    const nextCount = params.eventCount + 1
-    this.logRelaySyncProgress({ relayUrl: params.relayUrl, eventCount: nextCount })
-    this.logTargetEventReceived({ relayUrl: params.relayUrl, event: params.event, eventCount: nextCount })
-
-    const tags = extractTagsFromEvent(params.event)
-    this.logTargetEventTags({ event: params.event, tags })
-
-    if (tags.service === PLATFORM_SERVICE) {
-      params.relayEvents.push(params.event)
-      this.logTargetEventAccepted(params.event)
-    } else {
-      this.logTargetEventRejected({ event: params.event, tags })
-    }
-
-    return nextCount
-  }
-
-  private logRelaySyncProgress(params: { relayUrl: string; eventCount: number }): void {
-    if (params.eventCount % 100 === 0) {
-      console.warn(`[PlatformSync] Received ${params.eventCount} events from relay ${params.relayUrl} (client-side filtering in progress)`)
-    }
-  }
-
-  private logTargetEventReceived(params: { relayUrl: string; event: Event; eventCount: number }): void {
-    if (params.event.id !== TARGET_EVENT_ID) {
-      return
-    }
-    console.warn(`[PlatformSync] ✅ Received target event from relay ${params.relayUrl} (event #${params.eventCount}):`, {
-      id: params.event.id,
-      created_at: params.event.created_at,
-      created_at_date: new Date(params.event.created_at * 1000).toISOString(),
-      pubkey: params.event.pubkey,
-      allTags: params.event.tags,
-      serviceTags: params.event.tags.filter((tag) => tag[0] === 'service'),
-    })
-  }
-
-  private logTargetEventTags(params: { event: Event; tags: ReturnType<typeof extractTagsFromEvent> }): void {
-    if (params.event.id !== TARGET_EVENT_ID) {
-      return
-    }
-    console.warn(`[PlatformSync] Extracted tags for target event:`, {
-      extractedTags: params.tags,
-      hasServiceTag: params.tags.service === PLATFORM_SERVICE,
-      serviceValue: params.tags.service,
-      expectedService: PLATFORM_SERVICE,
-    })
-  }
-
-  private logTargetEventAccepted(event: Event): void {
-    if (event.id === TARGET_EVENT_ID) {
-      console.warn(`[PlatformSync] Target event accepted and added to relayEvents`)
-    }
-  }
-
-  private logTargetEventRejected(params: { event: Event; tags: ReturnType<typeof extractTagsFromEvent> }): void {
-    if (params.event.id !== TARGET_EVENT_ID) {
-      return
-    }
-    console.warn(`[PlatformSync] Event ${params.event.id} rejected: service tag is "${params.tags.service}", expected "${PLATFORM_SERVICE}"`)
-  }
-
-  /**
-   * Process a single event and cache it
-   */
-  private async processEvent(event: Event): Promise<void> {
-    const tags = extractTagsFromEvent(event)
-    const { writeObjectToCache } = await import('./helpers/writeObjectHelper')
-
-    logTargetEventDebug({ event, tags })
-    if (tags.hidden) {
-      logTargetEventSkipped({ event, tags })
-      return
-    }
-
-    if (await this.tryCacheAuthorEvent({ event, tags, writeObjectToCache })) {
-      return
-    }
-    if (await this.tryCacheSeriesEvent({ event, tags, writeObjectToCache })) {
-      return
-    }
-    if (await this.tryCachePublicationEvent({ event, tags, writeObjectToCache })) {
-      return
-    }
-    if (await this.tryCacheReviewEvent({ event, tags, writeObjectToCache })) {
-      return
-    }
-    await this.tryCacheZapReceiptEvent({ event, writeObjectToCache })
-  }
-
-  private async tryCacheAuthorEvent(params: {
-    event: Event
-    tags: ReturnType<typeof extractTagsFromEvent>
-    writeObjectToCache: typeof import('./helpers/writeObjectHelper').writeObjectToCache
-  }): Promise<boolean> {
-    if (params.tags.type !== 'author') {
-      return false
-    }
-
-    logTargetEventAttempt({ event: params.event, message: 'Attempting to parse target event as author presentation' })
-    const parsed = await parsePresentationEvent(params.event)
-    logTargetEventParsed({ event: params.event, parsed })
-
-    if (!parsed?.hash) {
-      logTargetEventNotCached({ event: params.event, parsed })
-      return true
-    }
-
-    await params.writeObjectToCache({
-      objectType: 'author',
-      hash: parsed.hash,
-      event: params.event,
-      parsed,
-      version: params.tags.version,
-      hidden: params.tags.hidden,
-      index: parsed.index,
-    })
-    logTargetEventCached({ event: params.event, hash: parsed.hash })
-    return true
-  }
-
-  private async tryCacheSeriesEvent(params: {
-    event: Event
-    tags: ReturnType<typeof extractTagsFromEvent>
-    writeObjectToCache: typeof import('./helpers/writeObjectHelper').writeObjectToCache
-  }): Promise<boolean> {
-    if (params.tags.type !== 'series') {
-      return false
-    }
-    const parsed = await parseSeriesFromEvent(params.event)
-    if (!parsed?.hash) {
-      return true
-    }
-    await params.writeObjectToCache({
-      objectType: 'series',
-      hash: parsed.hash,
-      event: params.event,
-      parsed,
-      version: params.tags.version,
-      hidden: params.tags.hidden,
-      index: parsed.index,
-    })
-    return true
-  }
-
-  private async tryCachePublicationEvent(params: {
-    event: Event
-    tags: ReturnType<typeof extractTagsFromEvent>
-    writeObjectToCache: typeof import('./helpers/writeObjectHelper').writeObjectToCache
-  }): Promise<boolean> {
-    if (params.tags.type !== 'publication') {
-      return false
-    }
-    const parsed = await parseArticleFromEvent(params.event)
-    if (!parsed?.hash) {
-      return true
-    }
-    await params.writeObjectToCache({
-      objectType: 'publication',
-      hash: parsed.hash,
-      event: params.event,
-      parsed,
-      version: params.tags.version,
-      hidden: params.tags.hidden,
-      index: parsed.index,
-    })
-    return true
-  }
-
-  private async tryCacheReviewEvent(params: {
-    event: Event
-    tags: ReturnType<typeof extractTagsFromEvent>
-    writeObjectToCache: typeof import('./helpers/writeObjectHelper').writeObjectToCache
-  }): Promise<boolean> {
-    if (params.tags.type !== 'quote') {
-      return false
-    }
-    const parsed = await parseReviewFromEvent(params.event)
-    if (!parsed?.hash) {
-      return true
-    }
-    await params.writeObjectToCache({
-      objectType: 'review',
-      hash: parsed.hash,
-      event: params.event,
-      parsed,
-      version: params.tags.version,
-      hidden: params.tags.hidden,
-      index: parsed.index,
-    })
-    return true
-  }
-
-  private async tryCacheZapReceiptEvent(params: {
-    event: Event
-    writeObjectToCache: typeof import('./helpers/writeObjectHelper').writeObjectToCache
-  }): Promise<boolean> {
-    if (params.event.kind !== 9735) {
-      return false
-    }
-
-    if (await this.tryCacheSponsoringZapReceipt(params)) {
-      return true
-    }
-    if (await this.tryCachePurchaseZapReceipt(params)) {
-      return true
-    }
-    if (await this.tryCacheReviewTipZapReceipt(params)) {
-      return true
-    }
-    return true
-  }
-
-  private async tryCacheSponsoringZapReceipt(params: {
-    event: Event
-    writeObjectToCache: typeof import('./helpers/writeObjectHelper').writeObjectToCache
-  }): Promise<boolean> {
-    const sponsoring = await parseSponsoringFromEvent(params.event)
-    if (!sponsoring?.hash) {
-      return false
-    }
-    await params.writeObjectToCache({
-      objectType: 'sponsoring',
-      hash: sponsoring.hash,
-      event: params.event,
-      parsed: sponsoring,
-      index: sponsoring.index,
-    })
-    return true
-  }
-
-  private async tryCachePurchaseZapReceipt(params: {
-    event: Event
-    writeObjectToCache: typeof import('./helpers/writeObjectHelper').writeObjectToCache
-  }): Promise<boolean> {
-    const purchase = await parsePurchaseFromEvent(params.event)
-    if (!purchase?.hash) {
-      return false
-    }
-    await params.writeObjectToCache({
-      objectType: 'purchase',
-      hash: purchase.hash,
-      event: params.event,
-      parsed: purchase,
-      index: purchase.index,
-    })
-    return true
-  }
-
-  private async tryCacheReviewTipZapReceipt(params: {
-    event: Event
-    writeObjectToCache: typeof import('./helpers/writeObjectHelper').writeObjectToCache
-  }): Promise<boolean> {
-    const reviewTip = await parseReviewTipFromEvent(params.event)
-    if (!reviewTip?.hash) {
-      return false
-    }
-    await params.writeObjectToCache({
-      objectType: 'review_tip',
-      hash: reviewTip.hash,
-      event: params.event,
-      parsed: reviewTip,
-      index: reviewTip.index,
-    })
-    return true
-  }
-
-  /**
-   * Start continuous sync (runs periodically)
-   * Can use Service Worker if available, otherwise falls back to setInterval
-   */
-  async startContinuousSync(): Promise<void> {
-    // Try to use Service Worker for background sync
-    if (typeof window !== 'undefined') {
-      try {
-        const { swClient } = await import('./swClient')
-        const isReady = await swClient.isReady()
-        if (isReady) {
-          console.warn('[PlatformSync] Using Service Worker for background sync')
-          await swClient.startPlatformSync()
-          // Still start initial sync in main thread
-          void this.startSync()
-          return
-        }
-      } catch (error) {
-        console.warn('[PlatformSync] Service Worker not available, using setInterval:', error)
-      }
-    }
-
-    // Fallback to setInterval if Service Worker not available
-    // Start initial sync
-    void this.startSync()
-
-    // Schedule periodic syncs
-    setInterval(() => {
-      if (!this.syncInProgress) {
-        void this.startSync()
-      }
-    }, this.SYNC_INTERVAL_MS)
-  }
-
-  /**
-   * Stop sync
-   */
-  async stopSync(): Promise<void> {
-    // Stop Service Worker sync if active
-    if (typeof window !== 'undefined') {
-      try {
-        const { swClient } = await import('./swClient')
-        const isReady = await swClient.isReady()
-        if (isReady) {
-          await swClient.stopPlatformSync()
-        }
-      } catch {
-        // Ignore errors
-      }
-    }
-
-    // Stop local sync
-    if (this.syncSubscription) {
-      this.syncSubscription.unsub()
-      this.syncSubscription = null
-    }
-    this.syncInProgress = false
-  }
-
-  /**
-   * Check if sync is in progress
-   */
-  isSyncing(): boolean {
-    return this.syncInProgress
-  }
-
-  /**
-   * Get last sync time
-   */
-  getLastSyncTime(): number {
-    return this.lastSyncTime
-  }
-}
-
-export const platformSyncService = new PlatformSyncService()
-
-function isTargetDebugEvent(eventId: string): boolean {
-  return eventId === '527d83e0af20bf23c3e104974090ccc21536ece72c24eb784b3642890f63b763'
-}
-
-function logTargetEventDebug(params: { event: Event; tags: ReturnType<typeof extractTagsFromEvent> }): void {
-  if (!isTargetDebugEvent(params.event.id)) {
-    return
-  }
-  console.warn(`[PlatformSync] Processing target event:`, {
-    id: params.event.id,
-    type: params.tags.type,
-    hidden: params.tags.hidden,
-    service: params.tags.service,
-    version: params.tags.version,
-  })
-}
-
-function logTargetEventSkipped(params: { event: Event; tags: ReturnType<typeof extractTagsFromEvent> }): void {
-  if (!isTargetDebugEvent(params.event.id) || !params.tags.hidden) {
-    return
-  }
-  console.warn(`[PlatformSync] Target event skipped: hidden=${params.tags.hidden}`)
-}
-
-function logTargetEventAttempt(params: { event: Event; message: string }): void {
-  if (!isTargetDebugEvent(params.event.id)) {
-    return
-  }
-  console.warn(`[PlatformSync] ${params.message}`)
-}
-
-function logTargetEventParsed(params: { event: Event; parsed: unknown }): void {
-  if (!isTargetDebugEvent(params.event.id)) {
-    return
-  }
-  const parsedObj = params.parsed as { hash?: string } | null
-  console.warn(`[PlatformSync] parsePresentationEvent result for target event:`, {
-    parsed: parsedObj !== null,
-    hasHash: parsedObj?.hash !== undefined,
-    hash: parsedObj?.hash,
-  })
-}
-
-function logTargetEventCached(params: { event: Event; hash: string }): void {
-  if (!isTargetDebugEvent(params.event.id)) {
-    return
-  }
-  console.warn(`[PlatformSync] Target event cached successfully as author with hash:`, params.hash)
-}
-
-function logTargetEventNotCached(params: { event: Event; parsed: unknown }): void {
-  if (!isTargetDebugEvent(params.event.id)) {
-    return
-  }
-  const parsedObj = params.parsed as { hash?: string } | null
-  console.warn(`[PlatformSync] Target event NOT cached: parsed=${parsedObj !== null}, hasHash=${parsedObj?.hash !== undefined}`)
-}
+export * from './platformSync/index'
diff --git a/lib/platformSync/PlatformSyncService.ts b/lib/platformSync/PlatformSyncService.ts
new file mode 100644
index 0000000..9d8ce80
--- /dev/null
+++ b/lib/platformSync/PlatformSyncService.ts
@@ -0,0 +1,198 @@
+import type { Event, Filter } from 'nostr-tools'
+import type { SimplePoolWithSub } from '@/types/nostr-tools-extended'
+import { nostrService } from '../nostr'
+import { MIN_EVENT_DATE, PLATFORM_SERVICE } from '../platformConfig'
+import { cachePlatformEvent } from './cacheEvent'
+import { SYNC_INTERVAL_MS, SYNC_TIMEOUT_MS } from './constants'
+import { collectEventsFromRelays, type RelaySessionManager, type SyncProgressManager } from './relayCollection'
+
+export class PlatformSyncService {
+  private syncInProgress = false
+  private syncSubscription: { unsub: () => void } | null = null
+  private lastSyncTime = 0
+
+  /**
+   * Start background sync
+   * Scans all notes with service='zapwall.fr' and caches them
+   * Does not require pubkey - syncs all public notes with service='zapwall.fr'
+   */
+  public async startSync(): Promise<void> {
+    if (this.syncInProgress) {
+      return
+    }
+
+    const pool = nostrService.getPool()
+    if (!pool) {
+      console.warn('Pool not initialized, cannot start platform sync')
+      return
+    }
+
+    this.syncInProgress = true
+
+    const { relaySessionManager, syncProgressManager, activeRelays } = await this.loadSyncManagers()
+    const initialRelay = activeRelays[0] ?? 'Connecting...'
+    const totalRelays = activeRelays.length ?? 1
+    syncProgressManager.setProgress({ currentStep: 0, totalSteps: totalRelays, completed: false, currentRelay: initialRelay })
+
+    try {
+      await this.performSync({ pool: pool as unknown as SimplePoolWithSub, relaySessionManager, syncProgressManager, activeRelays })
+      const finalRelay = activeRelays[activeRelays.length - 1] ?? initialRelay
+      syncProgressManager.setProgress({ currentStep: totalRelays, totalSteps: totalRelays, completed: true, currentRelay: finalRelay })
+    } catch (error) {
+      console.error('Error in platform sync:', error)
+      syncProgressManager.setProgress(null)
+    } finally {
+      this.syncInProgress = false
+      setTimeout(() => {
+        syncProgressManager.setProgress(null)
+      }, 500)
+    }
+  }
+
+  /**
+   * Start continuous sync (runs periodically)
+   * Can use Service Worker if available, otherwise falls back to setInterval
+   */
+  public async startContinuousSync(): Promise<void> {
+    if (typeof window !== 'undefined') {
+      const usedSw = await this.tryStartServiceWorkerSync()
+      if (usedSw) {
+        void this.startSync()
+        return
+      }
+    }
+
+    void this.startSync()
+    setInterval(() => {
+      if (!this.syncInProgress) {
+        void this.startSync()
+      }
+    }, SYNC_INTERVAL_MS)
+  }
+
+  /**
+   * Stop sync
+   */
+  public async stopSync(): Promise<void> {
+    if (typeof window !== 'undefined') {
+      await this.tryStopServiceWorkerSync()
+    }
+
+    if (this.syncSubscription) {
+      this.syncSubscription.unsub()
+      this.syncSubscription = null
+    }
+    this.syncInProgress = false
+  }
+
+  /**
+   * Check if sync is in progress
+   */
+  public isSyncing(): boolean {
+    return this.syncInProgress
+  }
+
+  /**
+   * Get last sync time
+   */
+  public getLastSyncTime(): number {
+    return this.lastSyncTime
+  }
+
+  /**
+   * Perform a sync operation
+   * Scans all notes with service='zapwall.fr' tag from ALL active relays
+   * Starts from January 5, 2026 00:00:00 UTC
+   */
+  private async performSync(params: {
+    pool: SimplePoolWithSub
+    relaySessionManager: RelaySessionManager
+    syncProgressManager: SyncProgressManager
+    activeRelays: string[]
+  }): Promise<void> {
+    const filters = buildSyncFilters()
+    logSyncStart(filters)
+
+    if (params.activeRelays.length === 0) {
+      throw new Error('No active relays available')
+    }
+
+    const allEvents = await collectEventsFromRelays({
+      pool: params.pool,
+      activeRelays: params.activeRelays,
+      filters,
+      relaySessionManager: params.relaySessionManager,
+      syncProgressManager: params.syncProgressManager,
+      syncTimeoutMs: SYNC_TIMEOUT_MS,
+      setSyncSubscription: (sub): void => {
+        this.syncSubscription = sub
+      },
+    })
+
+    await processAndCacheEvents(allEvents)
+    console.warn(`[PlatformSync] Total events collected from all relays: ${allEvents.length}`)
+    this.lastSyncTime = Date.now()
+  }
+
+  private async loadSyncManagers(): Promise<{
+    relaySessionManager: RelaySessionManager & { getActiveRelays: () => Promise<string[]> }
+    syncProgressManager: SyncProgressManager
+    activeRelays: string[]
+  }> {
+    const { syncProgressManager } = await import('../syncProgressManager')
+    const { relaySessionManager } = await import('../relaySessionManager')
+    const activeRelays = await relaySessionManager.getActiveRelays()
+    return { relaySessionManager, syncProgressManager, activeRelays }
+  }
+
+  private async tryStartServiceWorkerSync(): Promise<boolean> {
+    try {
+      const { swClient } = await import('../swClient')
+      const isReady = await swClient.isReady()
+      if (!isReady) {
+        return false
+      }
+      console.warn('[PlatformSync] Using Service Worker for background sync')
+      await swClient.startPlatformSync()
+      return true
+    } catch (error) {
+      console.warn('[PlatformSync] Service Worker not available, using setInterval:', error)
+      return false
+    }
+  }
+
+  private async tryStopServiceWorkerSync(): Promise<void> {
+    try {
+      const { swClient } = await import('../swClient')
+      const isReady = await swClient.isReady()
+      if (isReady) {
+        await swClient.stopPlatformSync()
+      }
+    } catch {
+      // Ignore errors
+    }
+  }
+}
+
+function buildSyncFilters(): Filter[] {
+  return [{ kinds: [1], since: MIN_EVENT_DATE, limit: 1000 }]
+}
+
+function logSyncStart(filters: Filter[]): void {
+  console.warn(
+    `[PlatformSync] Starting sync with filter (no #service filter on relay side):`,
+    JSON.stringify(filters, null, 2)
+  )
+  console.warn(`[PlatformSync] MIN_EVENT_DATE: ${MIN_EVENT_DATE} (${new Date(MIN_EVENT_DATE * 1000).toISOString()})`)
+  console.warn(`[PlatformSync] Will filter by service='${PLATFORM_SERVICE}' client-side after receiving events`)
+}
+
+async function processAndCacheEvents(events: Event[]): Promise<void> {
+  for (const event of events) {
+    try {
+      await cachePlatformEvent(event)
+    } catch (error) {
+      console.error('Error processing event:', error, event.id)
+    }
+  }
+}
diff --git a/lib/platformSync/cacheEvent.ts b/lib/platformSync/cacheEvent.ts
new file mode 100644
index 0000000..c46f9ea
--- /dev/null
+++ b/lib/platformSync/cacheEvent.ts
@@ -0,0 +1,216 @@
+import type { Event } from 'nostr-tools'
+import { extractTagsFromEvent } from '../nostrTagSystem'
+import { parsePresentationEvent } from '../articlePublisherHelpersPresentation'
+import {
+  parseArticleFromEvent,
+  parsePurchaseFromEvent,
+  parseReviewFromEvent,
+  parseReviewTipFromEvent,
+  parseSeriesFromEvent,
+  parseSponsoringFromEvent,
+} from '../nostrEventParsing'
+import {
+  logTargetEventAttempt,
+  logTargetEventCached,
+  logTargetEventDebug,
+  logTargetEventNotCached,
+  logTargetEventParsed,
+  logTargetEventSkipped,
+} from './debug'
+
+type ExtractedTags = ReturnType<typeof extractTagsFromEvent>
+
+type WriteObjectToCache = typeof import('../helpers/writeObjectHelper').writeObjectToCache
+
+export async function cachePlatformEvent(event: Event): Promise<void> {
+  const tags = extractTagsFromEvent(event)
+  const { writeObjectToCache } = await import('../helpers/writeObjectHelper')
+
+  logTargetEventDebug({ event, tags })
+  if (tags.hidden) {
+    logTargetEventSkipped({ event, tags })
+    return
+  }
+
+  if (await tryCacheAuthorEvent({ event, tags, writeObjectToCache })) {
+    return
+  }
+  if (await tryCacheSeriesEvent({ event, tags, writeObjectToCache })) {
+    return
+  }
+  if (await tryCachePublicationEvent({ event, tags, writeObjectToCache })) {
+    return
+  }
+  if (await tryCacheReviewEvent({ event, tags, writeObjectToCache })) {
+    return
+  }
+  await tryCacheZapReceiptEvent({ event, writeObjectToCache })
+}
+
+async function tryCacheAuthorEvent(params: {
+  event: Event
+  tags: ExtractedTags
+  writeObjectToCache: WriteObjectToCache
+}): Promise<boolean> {
+  if (params.tags.type !== 'author') {
+    return false
+  }
+
+  logTargetEventAttempt({ event: params.event, message: 'Attempting to parse target event as author presentation' })
+  const parsed = await parsePresentationEvent(params.event)
+  logTargetEventParsed({ event: params.event, parsed })
+
+  if (!parsed?.hash) {
+    logTargetEventNotCached({ event: params.event, parsed })
+    return true
+  }
+
+  await params.writeObjectToCache({
+    objectType: 'author',
+    hash: parsed.hash,
+    event: params.event,
+    parsed,
+    version: params.tags.version,
+    hidden: params.tags.hidden,
+    index: parsed.index,
+  })
+  logTargetEventCached({ event: params.event, hash: parsed.hash })
+  return true
+}
+
+async function tryCacheSeriesEvent(params: {
+  event: Event
+  tags: ExtractedTags
+  writeObjectToCache: WriteObjectToCache
+}): Promise<boolean> {
+  if (params.tags.type !== 'series') {
+    return false
+  }
+  const parsed = await parseSeriesFromEvent(params.event)
+  if (!parsed?.hash) {
+    return true
+  }
+  await params.writeObjectToCache({
+    objectType: 'series',
+    hash: parsed.hash,
+    event: params.event,
+    parsed,
+    version: params.tags.version,
+    hidden: params.tags.hidden,
+    index: parsed.index,
+  })
+  return true
+}
+
+async function tryCachePublicationEvent(params: {
+  event: Event
+  tags: ExtractedTags
+  writeObjectToCache: WriteObjectToCache
+}): Promise<boolean> {
+  if (params.tags.type !== 'publication') {
+    return false
+  }
+  const parsed = await parseArticleFromEvent(params.event)
+  if (!parsed?.hash) {
+    return true
+  }
+  await params.writeObjectToCache({
+    objectType: 'publication',
+    hash: parsed.hash,
+    event: params.event,
+    parsed,
+    version: params.tags.version,
+    hidden: params.tags.hidden,
+    index: parsed.index,
+  })
+  return true
+}
+
+async function tryCacheReviewEvent(params: {
+  event: Event
+  tags: ExtractedTags
+  writeObjectToCache: WriteObjectToCache
+}): Promise<boolean> {
+  if (params.tags.type !== 'quote') {
+    return false
+  }
+  const parsed = await parseReviewFromEvent(params.event)
+  if (!parsed?.hash) {
+    return true
+  }
+  await params.writeObjectToCache({
+    objectType: 'review',
+    hash: parsed.hash,
+    event: params.event,
+    parsed,
+    version: params.tags.version,
+    hidden: params.tags.hidden,
+    index: parsed.index,
+  })
+  return true
+}
+
+async function tryCacheZapReceiptEvent(params: { event: Event; writeObjectToCache: WriteObjectToCache }): Promise<boolean> {
+  if (params.event.kind !== 9735) {
+    return false
+  }
+
+  if (await tryCacheSponsoringZapReceipt(params)) {
+    return true
+  }
+  if (await tryCachePurchaseZapReceipt(params)) {
+    return true
+  }
+  if (await tryCacheReviewTipZapReceipt(params)) {
+    return true
+  }
+  return true
+}
+
+async function tryCacheSponsoringZapReceipt(params: {
+  event: Event
+  writeObjectToCache: WriteObjectToCache
+}): Promise<boolean> {
+  const sponsoring = await parseSponsoringFromEvent(params.event)
+  if (!sponsoring?.hash) {
+    return false
+  }
+  await params.writeObjectToCache({
+    objectType: 'sponsoring',
+    hash: sponsoring.hash,
+    event: params.event,
+    parsed: sponsoring,
+    index: sponsoring.index,
+  })
+  return true
+}
+
+async function tryCachePurchaseZapReceipt(params: { event: Event; writeObjectToCache: WriteObjectToCache }): Promise<boolean> {
+  const purchase = await parsePurchaseFromEvent(params.event)
+  if (!purchase?.hash) {
+    return false
+  }
+  await params.writeObjectToCache({
+    objectType: 'purchase',
+    hash: purchase.hash,
+    event: params.event,
+    parsed: purchase,
+    index: purchase.index,
+  })
+  return true
+}
+
+async function tryCacheReviewTipZapReceipt(params: { event: Event; writeObjectToCache: WriteObjectToCache }): Promise<boolean> {
+  const reviewTip = await parseReviewTipFromEvent(params.event)
+  if (!reviewTip?.hash) {
+    return false
+  }
+  await params.writeObjectToCache({
+    objectType: 'review_tip',
+    hash: reviewTip.hash,
+    event: params.event,
+    parsed: reviewTip,
+    index: reviewTip.index,
+  })
+  return true
+}
diff --git a/lib/platformSync/constants.ts b/lib/platformSync/constants.ts
new file mode 100644
index 0000000..3fa37d4
--- /dev/null
+++ b/lib/platformSync/constants.ts
@@ -0,0 +1,4 @@
+export const TARGET_EVENT_ID = '527d83e0af20bf23c3e104974090ccc21536ece72c24eb784b3642890f63b763'
+
+export const SYNC_INTERVAL_MS = 60_000
+export const SYNC_TIMEOUT_MS = 60_000
diff --git a/lib/platformSync/debug.ts b/lib/platformSync/debug.ts
new file mode 100644
index 0000000..9ea3995
--- /dev/null
+++ b/lib/platformSync/debug.ts
@@ -0,0 +1,117 @@
+import type { Event } from 'nostr-tools'
+import { PLATFORM_SERVICE } from '../platformConfig'
+import { TARGET_EVENT_ID } from './constants'
+
+type ExtractedTags = ReturnType<typeof import('../nostrTagSystem').extractTagsFromEvent>
+
+export function isTargetDebugEvent(eventId: string): boolean {
+  return eventId === TARGET_EVENT_ID
+}
+
+export function logRelaySyncProgress(params: { relayUrl: string; eventCount: number }): void {
+  if (params.eventCount % 100 !== 0) {
+    return
+  }
+  console.warn(
+    `[PlatformSync] Received ${params.eventCount} events from relay ${params.relayUrl} (client-side filtering in progress)`
+  )
+}
+
+export function logTargetEventReceived(params: { relayUrl: string; event: Event; eventCount: number }): void {
+  if (!isTargetDebugEvent(params.event.id)) {
+    return
+  }
+  console.warn(`[PlatformSync] ✅ Received target event from relay ${params.relayUrl} (event #${params.eventCount}):`, {
+    id: params.event.id,
+    created_at: params.event.created_at,
+    created_at_date: new Date(params.event.created_at * 1000).toISOString(),
+    pubkey: params.event.pubkey,
+    allTags: params.event.tags,
+    serviceTags: params.event.tags.filter((tag) => tag[0] === 'service'),
+  })
+}
+
+export function logTargetEventTags(params: {
+  event: Event
+  tags: ExtractedTags
+}): void {
+  if (!isTargetDebugEvent(params.event.id)) {
+    return
+  }
+  console.warn(`[PlatformSync] Extracted tags for target event:`, {
+    extractedTags: params.tags,
+    hasServiceTag: params.tags.service === PLATFORM_SERVICE,
+    serviceValue: params.tags.service,
+    expectedService: PLATFORM_SERVICE,
+  })
+}
+
+export function logTargetEventAccepted(event: Event): void {
+  if (!isTargetDebugEvent(event.id)) {
+    return
+  }
+  console.warn(`[PlatformSync] Target event accepted and added to relayEvents`)
+}
+
+export function logTargetEventRejected(params: { event: Event; tags: ExtractedTags }): void {
+  if (!isTargetDebugEvent(params.event.id)) {
+    return
+  }
+  console.warn(
+    `[PlatformSync] Event ${params.event.id} rejected: service tag is "${params.tags.service}", expected "${PLATFORM_SERVICE}"`
+  )
+}
+
+export function logTargetEventDebug(params: { event: Event; tags: ExtractedTags }): void {
+  if (!isTargetDebugEvent(params.event.id)) {
+    return
+  }
+  console.warn(`[PlatformSync] Processing target event:`, {
+    id: params.event.id,
+    type: params.tags.type,
+    hidden: params.tags.hidden,
+    service: params.tags.service,
+    version: params.tags.version,
+  })
+}
+
+export function logTargetEventSkipped(params: { event: Event; tags: ExtractedTags }): void {
+  if (!isTargetDebugEvent(params.event.id) || !params.tags.hidden) {
+    return
+  }
+  console.warn(`[PlatformSync] Target event skipped: hidden=${params.tags.hidden}`)
+}
+
+export function logTargetEventAttempt(params: { event: Event; message: string }): void {
+  if (!isTargetDebugEvent(params.event.id)) {
+    return
+  }
+  console.warn(`[PlatformSync] ${params.message}`)
+}
+
+export function logTargetEventParsed(params: { event: Event; parsed: unknown }): void {
+  if (!isTargetDebugEvent(params.event.id)) {
+    return
+  }
+  const parsedObj = params.parsed as { hash?: string } | null
+  console.warn(`[PlatformSync] parsePresentationEvent result for target event:`, {
+    parsed: parsedObj !== null,
+    hasHash: parsedObj?.hash !== undefined,
+    hash: parsedObj?.hash,
+  })
+}
+
+export function logTargetEventCached(params: { event: Event; hash: string }): void {
+  if (!isTargetDebugEvent(params.event.id)) {
+    return
+  }
+  console.warn(`[PlatformSync] Target event cached successfully as author with hash:`, params.hash)
+}
+
+export function logTargetEventNotCached(params: { event: Event; parsed: unknown }): void {
+  if (!isTargetDebugEvent(params.event.id)) {
+    return
+  }
+  const parsedObj = params.parsed as { hash?: string } | null
+  console.warn(`[PlatformSync] Target event NOT cached: parsed=${parsedObj !== null}, hasHash=${parsedObj?.hash !== undefined}`)
+}
diff --git a/lib/platformSync/index.ts b/lib/platformSync/index.ts
new file mode 100644
index 0000000..1354260
--- /dev/null
+++ b/lib/platformSync/index.ts
@@ -0,0 +1,5 @@
+export * from './PlatformSyncService'
+
+import { PlatformSyncService } from './PlatformSyncService'
+
+export const platformSyncService: PlatformSyncService = new PlatformSyncService()
diff --git a/lib/platformSync/relayCollection.ts b/lib/platformSync/relayCollection.ts
new file mode 100644
index 0000000..3bc7796
--- /dev/null
+++ b/lib/platformSync/relayCollection.ts
@@ -0,0 +1,188 @@
+import type { Event, Filter } from 'nostr-tools'
+import type { SimplePoolWithSub } from '@/types/nostr-tools-extended'
+import { createSubscription } from '@/types/nostr-tools-extended'
+import { PLATFORM_SERVICE } from '../platformConfig'
+import { extractTagsFromEvent } from '../nostrTagSystem'
+import {
+  logRelaySyncProgress,
+  logTargetEventAccepted,
+  logTargetEventReceived,
+  logTargetEventRejected,
+  logTargetEventTags,
+} from './debug'
+
+export type SyncProgress = { currentStep: number; totalSteps: number; completed: boolean; currentRelay?: string }
+
+export type SyncProgressManager = { setProgress: (progress: SyncProgress | null) => void }
+
+export type RelaySessionManager = {
+  markRelayFailed: (relayUrl: string) => void
+}
+
+export type SetSyncSubscription = (sub: { unsub: () => void } | null) => void
+
+export async function collectEventsFromRelays(params: {
+  pool: SimplePoolWithSub
+  activeRelays: string[]
+  filters: Filter[]
+  relaySessionManager: RelaySessionManager
+  syncProgressManager: SyncProgressManager
+  syncTimeoutMs: number
+  setSyncSubscription: SetSyncSubscription
+}): Promise<Event[]> {
+  const allEvents: Event[] = []
+  const processedEventIds = new Set<string>()
+
+  for (let i = 0; i < params.activeRelays.length; i++) {
+    const relayUrl = params.activeRelays[i]
+    if (relayUrl) {
+      await collectEventsFromRelay({
+        ...params,
+        relayUrl,
+        relayIndex: i,
+        processedEventIds,
+        allEvents,
+      })
+    }
+  }
+
+  return allEvents
+}
+
+async function collectEventsFromRelay(params: {
+  pool: SimplePoolWithSub
+  relayUrl: string
+  relayIndex: number
+  activeRelays: string[]
+  filters: Filter[]
+  relaySessionManager: RelaySessionManager
+  syncProgressManager: SyncProgressManager
+  processedEventIds: Set<string>
+  allEvents: Event[]
+  syncTimeoutMs: number
+  setSyncSubscription: SetSyncSubscription
+}): Promise<void> {
+  setRelayProgress(params.syncProgressManager, 0, params.activeRelays.length, params.relayUrl)
+
+  try {
+    const relayEvents = await readEventsFromRelay({
+      pool: params.pool,
+      relayUrl: params.relayUrl,
+      filters: params.filters,
+      syncTimeoutMs: params.syncTimeoutMs,
+      setSyncSubscription: params.setSyncSubscription,
+    })
+
+    addUniqueEvents({ relayEvents, processedEventIds: params.processedEventIds, allEvents: params.allEvents })
+    await updateRelayLastSyncDateIfNeeded({ relayUrl: params.relayUrl, eventCount: relayEvents.length })
+    setRelayProgress(params.syncProgressManager, params.relayIndex + 1, params.activeRelays.length, params.relayUrl)
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error)
+    console.warn(`[PlatformSync] Relay ${params.relayUrl} failed: ${errorMessage}`)
+    params.relaySessionManager.markRelayFailed(params.relayUrl)
+    setRelayProgress(params.syncProgressManager, params.relayIndex + 1, params.activeRelays.length, params.relayUrl)
+  }
+}
+
+function setRelayProgress(
+  syncProgressManager: SyncProgressManager,
+  currentStep: number,
+  totalSteps: number,
+  relayUrl: string
+): void {
+  syncProgressManager.setProgress({ currentStep, totalSteps, completed: false, currentRelay: relayUrl })
+}
+
+async function readEventsFromRelay(params: {
+  pool: SimplePoolWithSub
+  relayUrl: string
+  filters: Filter[]
+  syncTimeoutMs: number
+  setSyncSubscription: SetSyncSubscription
+}): Promise<Event[]> {
+  console.warn(`[PlatformSync] Synchronizing from relay: ${params.relayUrl}`)
+
+  const sub = createSubscription(params.pool, [params.relayUrl], params.filters)
+  params.setSyncSubscription(sub)
+
+  const relayEvents: Event[] = []
+  let eventCount = 0
+
+  const finalize = (): void => {
+    sub.unsub()
+    params.setSyncSubscription(null)
+  }
+
+  await new Promise<void>((resolve) => {
+    sub.on('event', (event: Event): void => {
+      eventCount = handleRelaySyncEvent({ event, relayUrl: params.relayUrl, relayEvents, eventCount })
+    })
+
+    sub.on('eose', (): void => {
+      console.warn(`[PlatformSync] Relay ${params.relayUrl} sent EOSE signal`)
+      finalize()
+      resolve()
+    })
+
+    const timeoutId = setTimeout((): void => {
+      console.warn(`[PlatformSync] Relay ${params.relayUrl} timeout after ${params.syncTimeoutMs}ms`)
+      finalize()
+      resolve()
+    }, params.syncTimeoutMs)
+
+    timeoutId.unref?.()
+  })
+
+  console.warn(
+    `[PlatformSync] Relay ${params.relayUrl} completed: received ${eventCount} total events from relay, ${relayEvents.length} filtered with service='${PLATFORM_SERVICE}'`
+  )
+
+  return relayEvents
+}
+
+function handleRelaySyncEvent(params: {
+  event: Event
+  relayUrl: string
+  relayEvents: Event[]
+  eventCount: number
+}): number {
+  const nextCount = params.eventCount + 1
+
+  logRelaySyncProgress({ relayUrl: params.relayUrl, eventCount: nextCount })
+  logTargetEventReceived({ relayUrl: params.relayUrl, event: params.event, eventCount: nextCount })
+
+  const tags = extractTagsFromEvent(params.event)
+  logTargetEventTags({ event: params.event, tags })
+
+  if (tags.service === PLATFORM_SERVICE) {
+    params.relayEvents.push(params.event)
+    logTargetEventAccepted(params.event)
+  } else {
+    logTargetEventRejected({ event: params.event, tags })
+  }
+
+  return nextCount
+}
+
+function addUniqueEvents(params: { relayEvents: Event[]; processedEventIds: Set<string>; allEvents: Event[] }): void {
+  for (const event of params.relayEvents) {
+    if (!params.processedEventIds.has(event.id)) {
+      params.processedEventIds.add(event.id)
+      params.allEvents.push(event)
+    }
+  }
+}
+
+async function updateRelayLastSyncDateIfNeeded(params: { relayUrl: string; eventCount: number }): Promise<void> {
+  if (params.eventCount <= 0) {
+    return
+  }
+
+  const { configStorage } = await import('../configStorage')
+  const config = await configStorage.getConfig()
+  const relayConfig = config.relays.find((r) => r.url === params.relayUrl)
+  if (!relayConfig) {
+    return
+  }
+  await configStorage.updateRelay(relayConfig.id, { lastSyncDate: Date.now() })
+}
diff --git a/lib/writeService.ts b/lib/writeService.ts
index 3ac664f..1574762 100644
--- a/lib/writeService.ts
+++ b/lib/writeService.ts
@@ -1,429 +1,2 @@
-/**
- * Write service - manages all write operations to IndexedDB
- * Routes writes through Web Worker for IndexedDB operations
- * Routes network operations through WebSocket service
- */
+export * from './writeService/index'
 
-import type { NostrEvent } from 'nostr-tools'
-import type { ObjectType } from './objectCache'
-
-interface WriteObjectParams {
-  objectType: ObjectType
-  hash: string
-  event: NostrEvent
-  parsed: unknown
-  version: number
-  hidden: boolean
-  index?: number
-  published?: false | string[]
-}
-
-interface CreateNotificationParams {
-  type: string
-  objectType: string
-  objectId: string
-  eventId: string
-  data?: Record<string, unknown>
-}
-
-interface LogPublicationParams {
-  eventId: string
-  relayUrl: string
-  success: boolean
-  error?: string
-  objectType?: string
-  objectId?: string
-}
-
-interface WorkerMessageEnvelope {
-  type: string
-  data?: unknown
-}
-
-interface WorkerErrorData {
-  originalType: string | undefined
-  taskId: string | undefined
-  error: string | undefined
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null
-}
-
-function isWorkerMessageEnvelope(value: unknown): value is WorkerMessageEnvelope {
-  if (!isRecord(value)) {
-    return false
-  }
-  return typeof value.type === 'string'
-}
-
-function readString(value: unknown): string | undefined {
-  return typeof value === 'string' ? value : undefined
-}
-
-function readWorkerErrorData(value: unknown): WorkerErrorData {
-  if (!isRecord(value)) {
-    return { originalType: undefined, taskId: undefined, error: undefined }
-  }
-  return {
-    originalType: readString(value.originalType),
-    taskId: readString(value.taskId),
-    error: readString(value.error),
-  }
-}
-
-function isWorkerErrorForOperation(errorData: WorkerErrorData, operation: string): boolean {
-  if (errorData.originalType === operation) {
-    return true
-  }
-  return errorData.taskId?.startsWith(operation) === true
-}
-
-class WriteService {
-  private writeWorker: Worker | null = null
-  private initPromise: Promise<void> | null = null
-
-  /**
-   * Initialize the write worker
-   */
-  private async init(): Promise<void> {
-    if (this.writeWorker) {
-      return
-    }
-
-    if (this.initPromise) {
-      return this.initPromise
-    }
-
-    this.initPromise = this.createWorker()
-
-    try {
-      await this.initPromise
-    } catch (error) {
-      this.initPromise = null
-      throw error
-    }
-  }
-
-  private createWorker(): Promise<void> {
-    return new Promise((resolve) => {
-      this.createWorkerOrFallback(resolve)
-    })
-  }
-
-  private createWorkerOrFallback(resolve: () => void): void {
-    if (!isWebWorkerAvailable()) {
-      console.warn('[WriteService] Web Workers not available, using direct writes')
-      resolve()
-      return
-    }
-
-    try {
-      this.writeWorker = new Worker('/writeWorker.js', { type: 'classic' })
-      this.registerWorkerListeners(this.writeWorker, resolve)
-    } catch (error) {
-      console.warn('[WriteService] Failed to create worker, using direct writes:', error)
-      resolve()
-    }
-  }
-
-  private registerWorkerListeners(worker: Worker, resolve: () => void): void {
-    worker.addEventListener('message', (event: MessageEvent<unknown>) => {
-      if (!isWorkerMessageEnvelope(event.data)) {
-        console.error('[WriteService] Received invalid worker message envelope', { data: event.data })
-        return
-      }
-      if (event.data.type === 'ERROR') {
-        console.error('[WriteService] Worker error:', event.data.data)
-      }
-    })
-
-    worker.addEventListener('error', (error) => {
-      console.error('[WriteService] Worker error:', error)
-      console.warn('[WriteService] Falling back to direct writes')
-      this.writeWorker = null
-      resolve()
-    })
-
-    const readyTimeout = setTimeout(() => {
-      console.warn('[WriteService] Worker ready timeout, using direct writes')
-      this.writeWorker?.terminate()
-      this.writeWorker = null
-      resolve()
-    }, 2000)
-
-    const readyHandler = (event: MessageEvent<unknown>): void => {
-      if (isWorkerMessageEnvelope(event.data) && event.data.type === 'WORKER_READY') {
-        clearTimeout(readyTimeout)
-        this.writeWorker?.removeEventListener('message', readyHandler)
-        resolve()
-      }
-    }
-    worker.addEventListener('message', readyHandler)
-  }
-
-  /**
-   * Write object to IndexedDB (via Web Worker)
-   */
-  async writeObject(params: WriteObjectParams): Promise<void> {
-    try {
-      await this.init()
-      if (this.writeWorker) {
-        return this.postWriteObjectToWorker(params)
-      }
-      await this.writeObjectDirect(params)
-    } catch (error) {
-      console.error('[WriteService] Error writing object:', error)
-      throw error
-    }
-  }
-
-  /**
-   * Update published status (via Web Worker)
-   */
-  async updatePublished(
-    objectType: ObjectType,
-    id: string,
-    published: false | string[]
-  ): Promise<void> {
-    try {
-      await this.init()
-
-      if (this.writeWorker) {
-        return this.postUpdatePublishedToWorker({ objectType, id, published })
-      }
-      await this.updatePublishedDirect({ objectType, id, published })
-    } catch (error) {
-      console.error('[WriteService] Error updating published status:', error)
-      throw error
-    }
-  }
-
-  private postWriteObjectToWorker(params: WriteObjectParams): Promise<void> {
-    const published = params.published ?? false
-    return new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => reject(new Error('Write operation timeout')), 10000)
-      const handler = (event: MessageEvent): void => {
-        if (!isWorkerMessageEnvelope(event.data)) {
-          return
-        }
-        if (event.data.type === 'WRITE_OBJECT_SUCCESS' && isRecord(event.data.data) && event.data.data.hash === params.hash) {
-          clearTimeout(timeout)
-          this.writeWorker?.removeEventListener('message', handler)
-          resolve()
-          return
-        }
-        if (event.data.type === 'ERROR') {
-          const errorData = readWorkerErrorData(event.data.data)
-          if (errorData.originalType !== 'WRITE_OBJECT') {
-            return
-          }
-          clearTimeout(timeout)
-          this.writeWorker?.removeEventListener('message', handler)
-          reject(new Error(errorData.error ?? 'Write worker error'))
-        }
-      }
-      if (this.writeWorker) {
-        this.writeWorker.addEventListener('message', handler)
-        this.writeWorker.postMessage({
-          type: 'WRITE_OBJECT',
-          data: {
-            objectType: params.objectType,
-            hash: params.hash,
-            event: params.event,
-            parsed: params.parsed,
-            version: params.version,
-            hidden: params.hidden,
-            index: params.index,
-            published,
-          },
-        })
-      }
-    })
-  }
-
-  private async writeObjectDirect(params: WriteObjectParams): Promise<void> {
-    const { objectCache } = await import('./objectCache')
-    await objectCache.set({
-      objectType: params.objectType,
-      hash: params.hash,
-      event: params.event,
-      parsed: params.parsed,
-      version: params.version,
-      hidden: params.hidden,
-      ...(params.index !== undefined ? { index: params.index } : {}),
-      ...(params.published !== undefined ? { published: params.published } : {}),
-    })
-  }
-
-  private postUpdatePublishedToWorker(params: {
-    objectType: ObjectType
-    id: string
-    published: false | string[]
-  }): Promise<void> {
-    return new Promise((resolve, reject) => {
-      const timeout = setTimeout(() => reject(new Error('Update published operation timeout')), 10000)
-      const handler = (event: MessageEvent): void => {
-        if (!isWorkerMessageEnvelope(event.data)) {
-          return
-        }
-        if (event.data.type === 'UPDATE_PUBLISHED_SUCCESS') {
-          if (!isRecord(event.data.data) || event.data.data.id !== params.id) {
-            return
-          }
-          clearTimeout(timeout)
-          this.writeWorker?.removeEventListener('message', handler)
-          resolve()
-          return
-        }
-        if (event.data.type !== 'ERROR') {
-          return
-        }
-        const errorData = readWorkerErrorData(event.data.data)
-        if (!isWorkerErrorForOperation(errorData, 'UPDATE_PUBLISHED')) {
-          return
-        }
-        clearTimeout(timeout)
-        this.writeWorker?.removeEventListener('message', handler)
-        reject(new Error(errorData.error ?? 'Write worker error'))
-      }
-      if (this.writeWorker) {
-        this.writeWorker.addEventListener('message', handler)
-        this.writeWorker.postMessage({ type: 'UPDATE_PUBLISHED', data: { ...params } })
-      }
-    })
-  }
-
-  private async updatePublishedDirect(params: { objectType: ObjectType; id: string; published: false | string[] }): Promise<void> {
-    const { objectCache } = await import('./objectCache')
-    await objectCache.updatePublished(params.objectType, params.id, params.published)
-  }
-
-  /**
-   * Create notification (via Web Worker)
-   */
-  async createNotification(params: CreateNotificationParams): Promise<void> {
-    try {
-      await this.init()
-
-      if (this.writeWorker) {
-        // Send to worker
-        return new Promise((resolve, reject) => {
-          const timeout = setTimeout(() => {
-            reject(new Error('Create notification operation timeout'))
-          }, 10000)
-
-          const handler = (event: MessageEvent): void => {
-            if (!isWorkerMessageEnvelope(event.data)) {
-              return
-            }
-            const responseType = event.data.type
-            const responseData = event.data.data
-
-            if (responseType === 'CREATE_NOTIFICATION_SUCCESS') {
-              if (!isRecord(responseData) || responseData.eventId !== params.eventId) {
-                return
-              }
-              clearTimeout(timeout)
-              this.writeWorker?.removeEventListener('message', handler)
-              resolve()
-              return
-            }
-
-            if (responseType !== 'ERROR') {
-              return
-            }
-
-            const errorData = readWorkerErrorData(responseData)
-            if (!isWorkerErrorForOperation(errorData, 'CREATE_NOTIFICATION')) {
-              return
-            }
-            clearTimeout(timeout)
-            this.writeWorker?.removeEventListener('message', handler)
-            reject(new Error(errorData.error ?? 'Write worker error'))
-          }
-
-          if (this.writeWorker) {
-            this.writeWorker.addEventListener('message', handler)
-            this.writeWorker.postMessage({
-              type: 'CREATE_NOTIFICATION',
-              data: {
-                type: params.type,
-                objectType: params.objectType,
-                objectId: params.objectId,
-                eventId: params.eventId,
-                notificationData: params.data,
-              },
-            })
-          }
-        })
-      }
-        // Fallback: direct write
-        const { notificationService } = await import('./notificationService')
-        const notificationParams: Parameters<typeof notificationService.createNotification>[0] = {
-          type: params.type as Parameters<typeof notificationService.createNotification>[0]['type'],
-          objectType: params.objectType,
-          objectId: params.objectId,
-          eventId: params.eventId,
-        }
-        if (params.data !== undefined) {
-          notificationParams.data = params.data
-        }
-        await notificationService.createNotification(notificationParams)
-
-
-    } catch (error) {
-      console.error('[WriteService] Error creating notification:', error)
-      throw error
-    }
-  }
-
-  /**
-   * Log publication (via Web Worker)
-   */
-  async logPublication(params: LogPublicationParams): Promise<void> {
-    try {
-      await this.init()
-
-      if (this.writeWorker) {
-        // Send to worker
-        this.writeWorker.postMessage({
-          type: 'LOG_PUBLICATION',
-          data: {
-            eventId: params.eventId,
-            relayUrl: params.relayUrl,
-            success: params.success,
-            error: params.error,
-            objectType: params.objectType,
-            objectId: params.objectId,
-          },
-        })
-        // Don't wait for response for logs (fire and forget)
-      } else {
-        // Fallback: direct write
-        const { publishLog } = await import('./publishLog')
-        await publishLog.logPublicationDirect(params)
-      }
-    } catch (logError) {
-      console.error('[WriteService] Error logging publication:', logError)
-      // Don't throw for logs
-    }
-  }
-
-  /**
-   * Terminate the worker
-   */
-  terminate(): void {
-    if (this.writeWorker) {
-      this.writeWorker.terminate()
-      this.writeWorker = null
-      this.initPromise = null
-    }
-  }
-}
-
-function isWebWorkerAvailable(): boolean {
-  return typeof window !== 'undefined' && Boolean(window.Worker)
-}
-
-export const writeService = new WriteService()
diff --git a/lib/writeService/WriteService.ts b/lib/writeService/WriteService.ts
new file mode 100644
index 0000000..005b875
--- /dev/null
+++ b/lib/writeService/WriteService.ts
@@ -0,0 +1,226 @@
+import type { ObjectType } from '../objectCache'
+import { isWebWorkerAvailable } from './env'
+import type { CreateNotificationParams, LogPublicationParams, WriteObjectParams } from './types'
+import { decideCreateNotificationWorkerMessage } from './notificationDecision'
+import { createNotificationDirect, logPublicationDirect, updatePublishedDirect, writeObjectDirect } from './direct'
+import { isRecord, isWorkerErrorForOperation, isWorkerMessageEnvelope, readWorkerErrorData } from './workerMessage'
+import { buildCreateNotificationWorkerPayload, buildWriteObjectWorkerPayload } from './workerPayloads'
+
+export class WriteService {
+  private writeWorker: Worker | null = null
+  private initPromise: Promise<void> | null = null
+
+  private async init(): Promise<void> {
+    if (this.writeWorker) {
+      return
+    }
+    if (this.initPromise) {
+      return this.initPromise
+    }
+    this.initPromise = this.createWorker()
+    try {
+      await this.initPromise
+    } catch (error) {
+      this.initPromise = null
+      throw error
+    }
+  }
+
+  private createWorker(): Promise<void> {
+    return new Promise((resolve) => this.createWorkerOrFallback(resolve))
+  }
+
+  private createWorkerOrFallback(resolve: () => void): void {
+    if (!isWebWorkerAvailable()) {
+      console.warn('[WriteService] Web Workers not available, using direct writes')
+      resolve()
+      return
+    }
+    try {
+      this.writeWorker = new Worker('/writeWorker.js', { type: 'classic' })
+      this.registerWorkerListeners(this.writeWorker, resolve)
+    } catch (error) {
+      console.warn('[WriteService] Failed to create worker, using direct writes:', error)
+      resolve()
+    }
+  }
+
+  private registerWorkerListeners(worker: Worker, resolve: () => void): void {
+    worker.addEventListener('message', (event: MessageEvent<unknown>) => {
+      if (!isWorkerMessageEnvelope(event.data)) {
+        console.error('[WriteService] Received invalid worker message envelope', { data: event.data })
+        return
+      }
+      if (event.data.type === 'ERROR') {
+        console.error('[WriteService] Worker error:', event.data.data)
+      }
+    })
+
+    worker.addEventListener('error', (error) => {
+      console.error('[WriteService] Worker error:', error)
+      console.warn('[WriteService] Falling back to direct writes')
+      this.writeWorker = null
+      resolve()
+    })
+
+    const readyTimeout = setTimeout(() => {
+      console.warn('[WriteService] Worker ready timeout, using direct writes')
+      this.writeWorker?.terminate()
+      this.writeWorker = null
+      resolve()
+    }, 2000)
+
+    const readyHandler = (event: MessageEvent<unknown>): void => {
+      if (isWorkerMessageEnvelope(event.data) && event.data.type === 'WORKER_READY') {
+        clearTimeout(readyTimeout)
+        this.writeWorker?.removeEventListener('message', readyHandler)
+        resolve()
+      }
+    }
+    worker.addEventListener('message', readyHandler)
+  }
+
+  async writeObject(params: WriteObjectParams): Promise<void> {
+    try {
+      await this.init()
+      if (this.writeWorker) {
+        return this.postWriteObjectToWorker(params)
+      }
+      await writeObjectDirect(params)
+    } catch (error) {
+      console.error('[WriteService] Error writing object:', error)
+      throw error
+    }
+  }
+
+  async updatePublished(objectType: ObjectType, id: string, published: false | string[]): Promise<void> {
+    try {
+      await this.init()
+      if (this.writeWorker) {
+        return this.postUpdatePublishedToWorker({ objectType, id, published })
+      }
+      await updatePublishedDirect({ objectType, id, published })
+    } catch (error) {
+      console.error('[WriteService] Error updating published status:', error)
+      throw error
+    }
+  }
+
+  async createNotification(params: CreateNotificationParams): Promise<void> {
+    try {
+      await this.init()
+      if (this.writeWorker) {
+        return this.postCreateNotificationToWorker(params)
+      }
+      await createNotificationDirect(params)
+    } catch (error) {
+      console.error('[WriteService] Error creating notification:', error)
+      throw error
+    }
+  }
+
+  async logPublication(params: LogPublicationParams): Promise<void> {
+    try {
+      await this.init()
+      if (this.writeWorker) {
+        this.writeWorker.postMessage({ type: 'LOG_PUBLICATION', data: { ...params } })
+        return
+      }
+      await logPublicationDirect(params)
+    } catch (logError) {
+      console.error('[WriteService] Error logging publication:', logError)
+    }
+  }
+
+  terminate(): void {
+    if (this.writeWorker) {
+      this.writeWorker.terminate()
+      this.writeWorker = null
+      this.initPromise = null
+    }
+  }
+
+  private postWriteObjectToWorker(params: WriteObjectParams): Promise<void> {
+    const published = params.published ?? false
+    const payload = buildWriteObjectWorkerPayload({ params, published })
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => reject(new Error('Write operation timeout')), 10000)
+      const handler = (event: MessageEvent): void => {
+        if (!isWorkerMessageEnvelope(event.data)) {
+          return
+        }
+        if (event.data.type === 'WRITE_OBJECT_SUCCESS' && isRecord(event.data.data) && event.data.data.hash === params.hash) {
+          clearTimeout(timeout)
+          this.writeWorker?.removeEventListener('message', handler)
+          resolve()
+          return
+        }
+        if (event.data.type === 'ERROR') {
+          const errorData = readWorkerErrorData(event.data.data)
+          if (errorData.originalType !== 'WRITE_OBJECT') {
+            return
+          }
+          clearTimeout(timeout)
+          this.writeWorker?.removeEventListener('message', handler)
+          reject(new Error(errorData.error ?? 'Write worker error'))
+        }
+      }
+      this.writeWorker?.addEventListener('message', handler)
+      this.writeWorker?.postMessage(payload)
+    })
+  }
+
+  private postUpdatePublishedToWorker(params: { objectType: ObjectType; id: string; published: false | string[] }): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => reject(new Error('Update published operation timeout')), 10000)
+      const handler = (event: MessageEvent): void => {
+        if (!isWorkerMessageEnvelope(event.data)) {
+          return
+        }
+        if (event.data.type === 'UPDATE_PUBLISHED_SUCCESS') {
+          if (!isRecord(event.data.data) || event.data.data.id !== params.id) {
+            return
+          }
+          clearTimeout(timeout)
+          this.writeWorker?.removeEventListener('message', handler)
+          resolve()
+          return
+        }
+        if (event.data.type !== 'ERROR') {
+          return
+        }
+        const errorData = readWorkerErrorData(event.data.data)
+        if (!isWorkerErrorForOperation(errorData, 'UPDATE_PUBLISHED')) {
+          return
+        }
+        clearTimeout(timeout)
+        this.writeWorker?.removeEventListener('message', handler)
+        reject(new Error(errorData.error ?? 'Write worker error'))
+      }
+      this.writeWorker?.addEventListener('message', handler)
+      this.writeWorker?.postMessage({ type: 'UPDATE_PUBLISHED', data: { ...params } })
+    })
+  }
+
+  private postCreateNotificationToWorker(params: CreateNotificationParams): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const timeout = setTimeout(() => reject(new Error('Create notification operation timeout')), 10000)
+      const handler = (event: MessageEvent): void => {
+        const decision = decideCreateNotificationWorkerMessage({ eventData: event.data, expectedEventId: params.eventId })
+        if (decision.status === 'ignore') {
+          return
+        }
+        clearTimeout(timeout)
+        this.writeWorker?.removeEventListener('message', handler)
+        if (decision.status === 'resolve') {
+          resolve()
+        } else {
+          reject(new Error(decision.message))
+        }
+      }
+      this.writeWorker?.addEventListener('message', handler)
+      this.writeWorker?.postMessage(buildCreateNotificationWorkerPayload(params))
+    })
+  }
+}
+
diff --git a/lib/writeService/createNotificationDecision.ts b/lib/writeService/createNotificationDecision.ts
new file mode 100644
index 0000000..d17584d
--- /dev/null
+++ b/lib/writeService/createNotificationDecision.ts
@@ -0,0 +1,32 @@
+import { isWorkerErrorForOperation, isWorkerMessageEnvelope, isRecord, readWorkerErrorData } from './workerMessage'
+
+export function decideCreateNotificationWorkerMessage(params: {
+  eventData: unknown
+  expectedEventId: string
+}):
+  | { status: 'ignore' }
+  | { status: 'resolve' }
+  | { status: 'reject'; message: string } {
+  if (!isWorkerMessageEnvelope(params.eventData)) {
+    return { status: 'ignore' }
+  }
+  const responseType = params.eventData.type
+  const responseData = params.eventData.data
+
+  if (responseType === 'CREATE_NOTIFICATION_SUCCESS') {
+    if (!isRecord(responseData) || responseData.eventId !== params.expectedEventId) {
+      return { status: 'ignore' }
+    }
+    return { status: 'resolve' }
+  }
+
+  if (responseType !== 'ERROR') {
+    return { status: 'ignore' }
+  }
+
+  const errorData = readWorkerErrorData(responseData)
+  if (!isWorkerErrorForOperation(errorData, 'CREATE_NOTIFICATION')) {
+    return { status: 'ignore' }
+  }
+  return { status: 'reject', message: errorData.error ?? 'Write worker error' }
+}
diff --git a/lib/writeService/direct.ts b/lib/writeService/direct.ts
new file mode 100644
index 0000000..66b59f0
--- /dev/null
+++ b/lib/writeService/direct.ts
@@ -0,0 +1,41 @@
+import type { CreateNotificationParams, LogPublicationParams, WriteObjectParams } from './types'
+import type { ObjectType } from '../objectCache'
+
+export async function writeObjectDirect(params: WriteObjectParams): Promise<void> {
+  const { objectCache } = await import('../objectCache')
+  await objectCache.set({
+    objectType: params.objectType,
+    hash: params.hash,
+    event: params.event,
+    parsed: params.parsed,
+    version: params.version,
+    hidden: params.hidden,
+    ...(params.index !== undefined ? { index: params.index } : {}),
+    ...(params.published !== undefined ? { published: params.published } : {}),
+  })
+}
+
+export async function updatePublishedDirect(params: { objectType: ObjectType; id: string; published: false | string[] }): Promise<void> {
+  const { objectCache } = await import('../objectCache')
+  await objectCache.updatePublished(params.objectType, params.id, params.published)
+}
+
+export async function createNotificationDirect(params: CreateNotificationParams): Promise<void> {
+  const { notificationService } = await import('../notificationService')
+  const notificationParams: Parameters<typeof notificationService.createNotification>[0] = {
+    type: params.type as Parameters<typeof notificationService.createNotification>[0]['type'],
+    objectType: params.objectType,
+    objectId: params.objectId,
+    eventId: params.eventId,
+  }
+  if (params.data !== undefined) {
+    notificationParams.data = params.data
+  }
+  await notificationService.createNotification(notificationParams)
+}
+
+export async function logPublicationDirect(params: LogPublicationParams): Promise<void> {
+  const { publishLog } = await import('../publishLog')
+  await publishLog.logPublicationDirect(params)
+}
+
diff --git a/lib/writeService/env.ts b/lib/writeService/env.ts
new file mode 100644
index 0000000..2c261f6
--- /dev/null
+++ b/lib/writeService/env.ts
@@ -0,0 +1,4 @@
+export function isWebWorkerAvailable(): boolean {
+  return typeof window !== 'undefined' && Boolean(window.Worker)
+}
+
diff --git a/lib/writeService/index.ts b/lib/writeService/index.ts
new file mode 100644
index 0000000..252d4a8
--- /dev/null
+++ b/lib/writeService/index.ts
@@ -0,0 +1,5 @@
+export { WriteService } from './WriteService'
+export { isWebWorkerAvailable } from './env'
+export type { CreateNotificationParams, LogPublicationParams, WorkerErrorData, WorkerMessageEnvelope, WriteObjectParams } from './types'
+export { writeService } from './singleton'
+
diff --git a/lib/writeService/notificationDecision.ts b/lib/writeService/notificationDecision.ts
new file mode 100644
index 0000000..ff42a0e
--- /dev/null
+++ b/lib/writeService/notificationDecision.ts
@@ -0,0 +1,33 @@
+import { isRecord, isWorkerErrorForOperation, isWorkerMessageEnvelope, readWorkerErrorData } from './workerMessage'
+
+export function decideCreateNotificationWorkerMessage(params: {
+  eventData: unknown
+  expectedEventId: string
+}):
+  | { status: 'ignore' }
+  | { status: 'resolve' }
+  | { status: 'reject'; message: string } {
+  if (!isWorkerMessageEnvelope(params.eventData)) {
+    return { status: 'ignore' }
+  }
+  const responseType = params.eventData.type
+  const responseData = params.eventData.data
+
+  if (responseType === 'CREATE_NOTIFICATION_SUCCESS') {
+    if (!isRecord(responseData) || responseData.eventId !== params.expectedEventId) {
+      return { status: 'ignore' }
+    }
+    return { status: 'resolve' }
+  }
+
+  if (responseType !== 'ERROR') {
+    return { status: 'ignore' }
+  }
+
+  const errorData = readWorkerErrorData(responseData)
+  if (!isWorkerErrorForOperation(errorData, 'CREATE_NOTIFICATION')) {
+    return { status: 'ignore' }
+  }
+  return { status: 'reject', message: errorData.error ?? 'Write worker error' }
+}
+
diff --git a/lib/writeService/objectWriteOps.ts b/lib/writeService/objectWriteOps.ts
new file mode 100644
index 0000000..2dfa738
--- /dev/null
+++ b/lib/writeService/objectWriteOps.ts
@@ -0,0 +1,111 @@
+import type { ObjectType } from '../objectCache'
+import { buildWriteObjectWorkerPayload } from './payloads'
+import { isWorkerMessageEnvelope, isRecord, readWorkerErrorData } from './workerMessage'
+import type { WriteObjectParams } from './types'
+
+export async function writeObjectDirect(params: WriteObjectParams): Promise<void> {
+  const { objectCache } = await import('../objectCache')
+  await objectCache.set({
+    objectType: params.objectType,
+    hash: params.hash,
+    event: params.event,
+    parsed: params.parsed,
+    version: params.version,
+    hidden: params.hidden,
+    ...(params.index !== undefined ? { index: params.index } : {}),
+    ...(params.published !== undefined ? { published: params.published } : {}),
+  })
+}
+
+export function postWriteObjectToWorker(params: {
+  worker: Worker
+  writeParams: WriteObjectParams
+}): Promise<void> {
+  const published = params.writeParams.published ?? false
+  const payload = buildWriteObjectWorkerPayload({ params: params.writeParams, published })
+
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => reject(new Error('Write operation timeout')), 10000)
+
+    const handler = (event: MessageEvent<unknown>): void => {
+      if (!isWorkerMessageEnvelope(event.data)) {
+        return
+      }
+
+      if (
+        event.data.type === 'WRITE_OBJECT_SUCCESS' &&
+        isRecord(event.data.data) &&
+        event.data.data.hash === params.writeParams.hash
+      ) {
+        clearTimeout(timeout)
+        params.worker.removeEventListener('message', handler)
+        resolve()
+        return
+      }
+
+      if (event.data.type === 'ERROR') {
+        const errorData = readWorkerErrorData(event.data.data)
+        if (errorData.originalType !== 'WRITE_OBJECT') {
+          return
+        }
+        clearTimeout(timeout)
+        params.worker.removeEventListener('message', handler)
+        reject(new Error(errorData.error ?? 'Write worker error'))
+      }
+    }
+
+    params.worker.addEventListener('message', handler)
+    params.worker.postMessage(payload)
+  })
+}
+
+export async function updatePublishedDirect(params: {
+  objectType: ObjectType
+  id: string
+  published: false | string[]
+}): Promise<void> {
+  const { objectCache } = await import('../objectCache')
+  await objectCache.updatePublished(params.objectType, params.id, params.published)
+}
+
+export function postUpdatePublishedToWorker(params: {
+  worker: Worker
+  objectType: ObjectType
+  id: string
+  published: false | string[]
+}): Promise<void> {
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => reject(new Error('Update published operation timeout')), 10000)
+
+    const handler = (event: MessageEvent<unknown>): void => {
+      if (!isWorkerMessageEnvelope(event.data)) {
+        return
+      }
+
+      if (event.data.type === 'UPDATE_PUBLISHED_SUCCESS') {
+        if (!isRecord(event.data.data) || event.data.data.id !== params.id) {
+          return
+        }
+        clearTimeout(timeout)
+        params.worker.removeEventListener('message', handler)
+        resolve()
+        return
+      }
+
+      if (event.data.type !== 'ERROR') {
+        return
+      }
+
+      const errorData = readWorkerErrorData(event.data.data)
+      if (errorData.originalType !== 'UPDATE_PUBLISHED' && errorData.taskId?.startsWith('UPDATE_PUBLISHED') !== true) {
+        return
+      }
+      clearTimeout(timeout)
+      params.worker.removeEventListener('message', handler)
+      reject(new Error(errorData.error ?? 'Write worker error'))
+    }
+
+    params.worker.addEventListener('message', handler)
+    params.worker.postMessage({ type: 'UPDATE_PUBLISHED', data: { objectType: params.objectType, id: params.id, published: params.published } })
+  })
+}
diff --git a/lib/writeService/payloads.ts b/lib/writeService/payloads.ts
new file mode 100644
index 0000000..c92f3ef
--- /dev/null
+++ b/lib/writeService/payloads.ts
@@ -0,0 +1,36 @@
+import type { CreateNotificationParams, WriteObjectParams } from './types'
+
+export function buildWriteObjectWorkerPayload(params: {
+  params: WriteObjectParams
+  published: false | string[]
+}): { type: 'WRITE_OBJECT'; data: Record<string, unknown> } {
+  return {
+    type: 'WRITE_OBJECT',
+    data: {
+      objectType: params.params.objectType,
+      hash: params.params.hash,
+      event: params.params.event,
+      parsed: params.params.parsed,
+      version: params.params.version,
+      hidden: params.params.hidden,
+      index: params.params.index,
+      published: params.published,
+    },
+  }
+}
+
+export function buildCreateNotificationWorkerPayload(params: CreateNotificationParams): {
+  type: 'CREATE_NOTIFICATION'
+  data: Record<string, unknown>
+} {
+  return {
+    type: 'CREATE_NOTIFICATION',
+    data: {
+      type: params.type,
+      objectType: params.objectType,
+      objectId: params.objectId,
+      eventId: params.eventId,
+      notificationData: params.data,
+    },
+  }
+}
diff --git a/lib/writeService/singleton.ts b/lib/writeService/singleton.ts
new file mode 100644
index 0000000..f7abb1a
--- /dev/null
+++ b/lib/writeService/singleton.ts
@@ -0,0 +1,4 @@
+import { WriteService } from './WriteService'
+
+export const writeService = new WriteService()
+
diff --git a/lib/writeService/types.ts b/lib/writeService/types.ts
new file mode 100644
index 0000000..c8cf498
--- /dev/null
+++ b/lib/writeService/types.ts
@@ -0,0 +1,42 @@
+import type { NostrEvent } from 'nostr-tools'
+import type { ObjectType } from '../objectCache'
+
+export interface WriteObjectParams {
+  objectType: ObjectType
+  hash: string
+  event: NostrEvent
+  parsed: unknown
+  version: number
+  hidden: boolean
+  index?: number
+  published?: false | string[]
+}
+
+export interface CreateNotificationParams {
+  type: string
+  objectType: string
+  objectId: string
+  eventId: string
+  data?: Record<string, unknown>
+}
+
+export interface LogPublicationParams {
+  eventId: string
+  relayUrl: string
+  success: boolean
+  error?: string
+  objectType?: string
+  objectId?: string
+}
+
+export interface WorkerMessageEnvelope {
+  type: string
+  data?: unknown
+}
+
+export interface WorkerErrorData {
+  originalType: string | undefined
+  taskId: string | undefined
+  error: string | undefined
+}
+
diff --git a/lib/writeService/workerInit.ts b/lib/writeService/workerInit.ts
new file mode 100644
index 0000000..835d92d
--- /dev/null
+++ b/lib/writeService/workerInit.ts
@@ -0,0 +1,63 @@
+import { isWorkerMessageEnvelope } from './workerMessage'
+
+export function isWebWorkerAvailable(): boolean {
+  return typeof window !== 'undefined' && Boolean(window.Worker)
+}
+
+export function createWriteWorkerInitPromise(params: { setWorker: (worker: Worker | null) => void }): Promise<void> {
+  return new Promise((resolve) => {
+    if (!isWebWorkerAvailable()) {
+      console.warn('[WriteService] Web Workers not available, using direct writes')
+      resolve()
+      return
+    }
+
+    try {
+      const worker = new Worker('/writeWorker.js', { type: 'classic' })
+      params.setWorker(worker)
+      registerWorkerListeners({ worker, resolve, setWorker: params.setWorker })
+    } catch (error) {
+      console.warn('[WriteService] Failed to create worker, using direct writes:', error)
+      resolve()
+    }
+  })
+}
+
+function registerWorkerListeners(params: {
+  worker: Worker
+  resolve: () => void
+  setWorker: (worker: Worker | null) => void
+}): void {
+  params.worker.addEventListener('message', (event: MessageEvent<unknown>) => {
+    if (!isWorkerMessageEnvelope(event.data)) {
+      console.error('[WriteService] Received invalid worker message envelope', { data: event.data })
+      return
+    }
+    if (event.data.type === 'ERROR') {
+      console.error('[WriteService] Worker error:', event.data.data)
+    }
+  })
+
+  params.worker.addEventListener('error', (error) => {
+    console.error('[WriteService] Worker error:', error)
+    console.warn('[WriteService] Falling back to direct writes')
+    params.setWorker(null)
+    params.resolve()
+  })
+
+  const readyTimeout = setTimeout(() => {
+    console.warn('[WriteService] Worker ready timeout, using direct writes')
+    params.worker.terminate()
+    params.setWorker(null)
+    params.resolve()
+  }, 2000)
+
+  const readyHandler = (event: MessageEvent<unknown>): void => {
+    if (isWorkerMessageEnvelope(event.data) && event.data.type === 'WORKER_READY') {
+      clearTimeout(readyTimeout)
+      params.worker.removeEventListener('message', readyHandler)
+      params.resolve()
+    }
+  }
+  params.worker.addEventListener('message', readyHandler)
+}
diff --git a/lib/writeService/workerMessage.ts b/lib/writeService/workerMessage.ts
new file mode 100644
index 0000000..b86f540
--- /dev/null
+++ b/lib/writeService/workerMessage.ts
@@ -0,0 +1,31 @@
+import type { WorkerErrorData, WorkerMessageEnvelope } from './types'
+
+function isRecordInternal(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null
+}
+
+export function isWorkerMessageEnvelope(value: unknown): value is WorkerMessageEnvelope {
+  return isRecordInternal(value) && typeof value.type === 'string'
+}
+
+function readString(value: unknown): string | undefined {
+  return typeof value === 'string' ? value : undefined
+}
+
+export function readWorkerErrorData(value: unknown): WorkerErrorData {
+  if (!isRecordInternal(value)) {
+    return { originalType: undefined, taskId: undefined, error: undefined }
+  }
+  return { originalType: readString(value.originalType), taskId: readString(value.taskId), error: readString(value.error) }
+}
+
+export function isWorkerErrorForOperation(errorData: WorkerErrorData, operation: string): boolean {
+  if (errorData.originalType === operation) {
+    return true
+  }
+  return errorData.taskId?.startsWith(operation) === true
+}
+
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return isRecordInternal(value)
+}
diff --git a/lib/writeService/workerPayloads.ts b/lib/writeService/workerPayloads.ts
new file mode 100644
index 0000000..57ca91f
--- /dev/null
+++ b/lib/writeService/workerPayloads.ts
@@ -0,0 +1,25 @@
+import type { CreateNotificationParams, WriteObjectParams } from './types'
+
+export function buildWriteObjectWorkerPayload(params: {
+  params: WriteObjectParams
+  published: false | string[]
+}): { type: 'WRITE_OBJECT'; data: Record<string, unknown> } {
+  return {
+    type: 'WRITE_OBJECT',
+    data: {
+      objectType: params.params.objectType,
+      hash: params.params.hash,
+      event: params.params.event,
+      parsed: params.params.parsed,
+      version: params.params.version,
+      hidden: params.params.hidden,
+      index: params.params.index,
+      published: params.published,
+    },
+  }
+}
+
+export function buildCreateNotificationWorkerPayload(params: CreateNotificationParams): { type: 'CREATE_NOTIFICATION'; data: Record<string, unknown> } {
+  return { type: 'CREATE_NOTIFICATION', data: { type: params.type, objectType: params.objectType, objectId: params.objectId, eventId: params.eventId, notificationData: params.data } }
+}
+
diff --git a/pages/_app.tsx b/pages/_app.tsx
index 6632e42..77deae6 100644
--- a/pages/_app.tsx
+++ b/pages/_app.tsx
@@ -52,27 +52,43 @@ function I18nProvider({ children }: { children: React.ReactNode }): React.ReactE
 }
 
 export default function App({ Component, pageProps }: AppProps): React.ReactElement {
-  // Initialize relay session manager on app mount (reset all relays to active)
+  useRelaySessionInitialization()
+  useServiceWorkerInitialization()
+  usePublishWorkerLifecycle()
+  usePlatformSyncOnNavigation()
+  useUserSyncOnNavigationAndAuth()
+
+  return (
+    <I18nProvider>
+      <Component {...pageProps} />
+    </I18nProvider>
+  )
+}
+
+function useRelaySessionInitialization(): void {
   React.useEffect(() => {
     void relaySessionManager.initialize()
   }, [])
+}
 
-  // Initialize Service Worker and sync handler
+function useServiceWorkerInitialization(): void {
   React.useEffect(() => {
     if (typeof window !== 'undefined') {
       void swSyncHandler.initialize()
     }
   }, [])
+}
 
-  // Start publish worker on app mount to republish unpublished objects
+function usePublishWorkerLifecycle(): void {
   React.useEffect(() => {
     void publishWorker.start()
     return () => {
       void publishWorker.stop()
     }
   }, [])
+}
 
-  // Start platform sync on app mount via Service Worker only
+function usePlatformSyncOnNavigation(): void {
   React.useEffect(() => {
     const startPlatformSync = async (): Promise<void> => {
       try {
@@ -84,31 +100,25 @@ export default function App({ Component, pageProps }: AppProps): React.ReactElem
         console.warn('[App] Service Worker not available for platform sync:', error)
       }
     }
-
     void startPlatformSync()
-
-    // Trigger sync on each page navigation
     const handleRouteChange = (): void => {
       void startPlatformSync()
     }
-
-    // Listen to route changes
     Router.events?.on('routeChangeComplete', handleRouteChange)
-
     return () => {
       Router.events?.off('routeChangeComplete', handleRouteChange)
       void swClient.stopPlatformSync()
     }
   }, [])
+}
 
-  // Start user content sync on app mount via Service Worker only
+function useUserSyncOnNavigationAndAuth(): void {
   React.useEffect(() => {
     const startUserSync = async (): Promise<void> => {
       const state = nostrAuthService.getState()
       if (!state.connected || !state.pubkey) {
         return
       }
-
       try {
         const isReady = await swClient.isReady()
         if (isReady) {
@@ -118,32 +128,19 @@ export default function App({ Component, pageProps }: AppProps): React.ReactElem
         console.warn('[App] Service Worker not available for user content sync:', error)
       }
     }
-
-    // Try to start sync immediately
     void startUserSync()
-
-    // Also listen to connection changes and route changes to sync when user connects or navigates
     const handleRouteChange = (): void => {
       void startUserSync()
     }
-
     Router.events?.on('routeChangeComplete', handleRouteChange)
-
     const unsubscribe = nostrAuthService.subscribe((state) => {
       if (state.connected && state.pubkey) {
         void startUserSync()
       }
     })
-
     return () => {
       Router.events?.off('routeChangeComplete', handleRouteChange)
       unsubscribe()
     }
   }, [])
-
-  return (
-    <I18nProvider>
-      <Component {...pageProps} />
-    </I18nProvider>
-  )
 }
diff --git a/pages/api/nip95-upload.ts b/pages/api/nip95-upload.ts
deleted file mode 100644
index 63cebce..0000000
--- a/pages/api/nip95-upload.ts
+++ /dev/null
@@ -1,536 +0,0 @@
-import { NextApiRequest, NextApiResponse } from 'next'
-import { IncomingForm, File as FormidableFile } from 'formidable'
-import type { Fields, Files } from 'formidable'
-import FormData from 'form-data'
-import fs from 'fs'
-import https from 'https'
-import http from 'http'
-import { URL } from 'url'
-
-const MAX_FILE_SIZE = 50 * 1024 * 1024 // 50MB
-
-export const config = {
-  api: {
-    bodyParser: false, // Disable bodyParser to handle multipart
-  },
-}
-
-interface ParseResult {
-  fields: Fields
-  files: Files
-}
-
-function isRecord(value: unknown): value is Record<string, unknown> {
-  return typeof value === 'object' && value !== null
-}
-
-function readString(value: unknown): string | undefined {
-  return typeof value === 'string' ? value : undefined
-}
-
-function getFirstFile(files: Files, fieldName: string): FormidableFile | null {
-  const value = files[fieldName]
-  if (!value) {
-    return null
-  }
-  if (Array.isArray(value)) {
-    const first = value[0]
-    return first ?? null
-  }
-  return value
-}
-
-function getFormDataHeaders(formData: FormData): http.OutgoingHttpHeaders {
-  const raw: unknown = formData.getHeaders()
-  if (!isRecord(raw)) {
-    return {}
-  }
-  const headers: http.OutgoingHttpHeaders = {}
-  for (const [key, value] of Object.entries(raw)) {
-    const str = readString(value)
-    if (str !== undefined) {
-      headers[key] = str
-    }
-  }
-  return headers
-}
-
-function getRedirectLocation(headers: unknown): string | undefined {
-  if (!isRecord(headers)) {
-    return undefined
-  }
-  const {location} = headers
-  if (typeof location === 'string') {
-    return location
-  }
-  if (Array.isArray(location) && typeof location[0] === 'string') {
-    return location[0]
-  }
-  return undefined
-}
-
-export default async function handler(req: NextApiRequest, res: NextApiResponse): Promise<void> {
-  if (req.method !== 'POST') {
-    return res.status(405).json({ error: 'Method not allowed' })
-  }
-
-  const { targetEndpoint, authToken } = readProxyQueryParams(req)
-  const currentUrl = new URL(targetEndpoint)
-
-  const fileField = await parseFileFromMultipartRequest(req)
-  if (!fileField) {
-    return res.status(400).json({ error: 'No file provided' })
-  }
-
-  try {
-    const response = await makeRequestWithRedirects({
-      targetEndpoint,
-      url: currentUrl,
-      file: fileField,
-      authToken,
-      redirectCount: 0,
-      maxRedirects: 5,
-    })
-    return handleProxyResponse({ res, response, targetEndpoint })
-  } catch (error) {
-    return handleProxyError({ res, error, targetEndpoint, hostname: currentUrl.hostname, file: fileField })
-  } finally {
-    safeUnlink(fileField.filepath)
-  }
-}
-
-function readProxyQueryParams(req: NextApiRequest): { targetEndpoint: string; authToken: string | undefined } {
-  return {
-    targetEndpoint: (req.query.endpoint as string) ?? 'https://void.cat/upload',
-    authToken: req.query.auth as string | undefined,
-  }
-}
-
-async function parseFileFromMultipartRequest(req: NextApiRequest): Promise<FormidableFile | null> {
-  const form = new IncomingForm({ maxFileSize: MAX_FILE_SIZE, keepExtensions: true })
-  const parseResult = await new Promise<ParseResult>((resolve, reject) => {
-    form.parse(req, (err, fields, files) => {
-      if (err) {
-        console.error('Formidable parse error:', err)
-        reject(err)
-        return
-      }
-      resolve({ fields, files })
-    })
-  })
-  return getFirstFile(parseResult.files, 'file')
-}
-
-function safeUnlink(filepath: string): void {
-  try {
-    fs.unlinkSync(filepath)
-  } catch (unlinkError) {
-    console.error('Error deleting temp file:', unlinkError)
-  }
-}
-
-interface ProxyUploadResponse {
-  statusCode: number
-  statusMessage: string
-  body: string
-  headers: http.IncomingHttpHeaders
-  finalUrl: string
-}
-
-async function makeRequestWithRedirects(params: {
-  targetEndpoint: string
-  url: URL
-  file: FormidableFile
-  authToken: string | undefined
-  redirectCount: number
-  maxRedirects: number
-}): Promise<ProxyUploadResponse> {
-  if (params.redirectCount > params.maxRedirects) {
-    throw new Error(`Too many redirects (max ${params.maxRedirects})`)
-  }
-
-  const response = await makeRequestOnce({
-    targetEndpoint: params.targetEndpoint,
-    url: params.url,
-    file: params.file,
-    authToken: params.authToken,
-  })
-
-  const redirectUrl = tryGetRedirectUrl({ url: params.url, response })
-  if (!redirectUrl) {
-    return response
-  }
-
-  console.warn('NIP-95 proxy redirect:', {
-    from: params.url.toString(),
-    to: redirectUrl.toString(),
-    statusCode: response.statusCode,
-    redirectCount: params.redirectCount + 1,
-  })
-
-  return makeRequestWithRedirects({
-    ...params,
-    url: redirectUrl,
-    redirectCount: params.redirectCount + 1,
-  })
-}
-
-function tryGetRedirectUrl(params: { url: URL; response: ProxyUploadResponse }): URL | null {
-  if (!isRedirectStatus(params.response.statusCode)) {
-    return null
-  }
-  const location = getRedirectLocation(params.response.headers as unknown)
-  if (!location) {
-    throw new Error('Redirect response missing location header')
-  }
-  try {
-    return new URL(location, params.url.toString())
-  } catch (urlError) {
-    console.error('NIP-95 proxy invalid redirect URL:', {
-      location,
-      error: urlError instanceof Error ? urlError.message : 'Unknown error',
-    })
-    throw new Error(`Invalid redirect URL: ${location}`)
-  }
-}
-
-function isRedirectStatus(statusCode: number): boolean {
-  return statusCode === 301 || statusCode === 302 || statusCode === 307 || statusCode === 308
-}
-
-async function makeRequestOnce(params: {
-  targetEndpoint: string
-  url: URL
-  file: FormidableFile
-  authToken: string | undefined
-}): Promise<ProxyUploadResponse> {
-  const { requestFormData, fileStream } = buildUploadFormData(params.file)
-  const headers = buildProxyRequestHeaders(requestFormData, params.authToken)
-  const { clientModule, requestOptions } = buildProxyRequestOptions({ url: params.url, headers })
-  return sendFormDataRequest({
-    clientModule,
-    requestOptions,
-    requestFormData,
-    fileStream,
-    targetEndpoint: params.targetEndpoint,
-    hostname: params.url.hostname,
-    finalUrl: params.url.toString(),
-    filepath: params.file.filepath,
-  })
-}
-
-function buildUploadFormData(file: FormidableFile): { requestFormData: FormData; fileStream: fs.ReadStream } {
-  const requestFormData = new FormData()
-  const fileStream = fs.createReadStream(file.filepath)
-  requestFormData.append('file', fileStream, {
-    filename: file.originalFilename ?? file.newFilename ?? 'upload',
-    contentType: file.mimetype ?? 'application/octet-stream',
-  })
-  return { requestFormData, fileStream }
-}
-
-function buildProxyRequestHeaders(requestFormData: FormData, authToken: string | undefined): http.OutgoingHttpHeaders {
-  const headers = getFormDataHeaders(requestFormData)
-  headers['Accept'] = 'application/json'
-  headers['User-Agent'] = 'zapwall.fr/1.0'
-  if (authToken) {
-    headers['Authorization'] = `Nostr ${authToken}`
-  }
-  return headers
-}
-
-function buildProxyRequestOptions(params: { url: URL; headers: http.OutgoingHttpHeaders }): {
-  clientModule: typeof http | typeof https
-  requestOptions: http.RequestOptions
-} {
-  const isHttps = params.url.protocol === 'https:'
-  return {
-    clientModule: isHttps ? https : http,
-    requestOptions: {
-      hostname: params.url.hostname,
-      port: params.url.port ?? (isHttps ? 443 : 80),
-      path: params.url.pathname + params.url.search,
-      method: 'POST',
-      headers: params.headers,
-      timeout: 30000,
-    },
-  }
-}
-
-async function sendFormDataRequest(params: {
-  clientModule: typeof http | typeof https
-  requestOptions: http.RequestOptions
-  requestFormData: FormData
-  fileStream: fs.ReadStream
-  targetEndpoint: string
-  hostname: string
-  finalUrl: string
-  filepath: string
-}): Promise<ProxyUploadResponse> {
-  return new Promise<ProxyUploadResponse>((resolve, reject) => {
-    const proxyRequest = params.clientModule.request(params.requestOptions, (proxyResponse: http.IncomingMessage) => {
-      void readProxyResponse({ proxyResponse, finalUrl: params.finalUrl }).then(resolve).catch(reject)
-    })
-    attachProxyRequestHandlers({
-      proxyRequest,
-      requestFormData: params.requestFormData,
-      fileStream: params.fileStream,
-      targetEndpoint: params.targetEndpoint,
-      hostname: params.hostname,
-      filepath: params.filepath,
-      reject,
-    })
-    params.requestFormData.pipe(proxyRequest)
-  })
-}
-
-function attachProxyRequestHandlers(params: {
-  proxyRequest: http.ClientRequest
-  requestFormData: FormData
-  fileStream: fs.ReadStream
-  targetEndpoint: string
-  hostname: string
-  filepath: string
-  reject: (error: unknown) => void
-}): void {
-  params.proxyRequest.setTimeout(30000, () => {
-    params.proxyRequest.destroy()
-    params.reject(new Error('Request timeout after 30 seconds'))
-  })
-  params.proxyRequest.on('error', (error) => {
-    params.reject(handleProxyRequestError({ error, targetEndpoint: params.targetEndpoint, hostname: params.hostname }))
-  })
-  params.requestFormData.on('error', (error) => {
-    console.error('NIP-95 proxy FormData error:', { targetEndpoint: params.targetEndpoint, hostname: params.hostname, error })
-    params.reject(error)
-  })
-  params.fileStream.on('error', (error) => {
-    console.error('NIP-95 proxy file stream error:', { targetEndpoint: params.targetEndpoint, hostname: params.hostname, filepath: params.filepath, error })
-    params.reject(error)
-  })
-}
-
-async function readProxyResponse(params: { proxyResponse: http.IncomingMessage; finalUrl: string }): Promise<ProxyUploadResponse> {
-  const statusCode = params.proxyResponse.statusCode ?? 500
-  const body = await readIncomingMessageBody(params.proxyResponse)
-  return {
-    statusCode,
-    statusMessage: params.proxyResponse.statusMessage ?? 'Internal Server Error',
-    body,
-    headers: params.proxyResponse.headers,
-    finalUrl: params.finalUrl,
-  }
-}
-
-async function readIncomingMessageBody(message: http.IncomingMessage): Promise<string> {
-  return new Promise<string>((resolve, reject) => {
-    let body = ''
-    message.setEncoding('utf8')
-    message.on('data', (chunk) => {
-      body += chunk
-    })
-    message.on('end', () => resolve(body))
-    message.on('error', reject)
-  })
-}
-
-function handleProxyRequestError(params: { error: unknown; targetEndpoint: string; hostname: string }): Error {
-  const errorMessage = params.error instanceof Error ? params.error.message : 'Unknown request error'
-  const errorCode = getErrnoCode(params.error)
-  if (errorCode === 'ENOTFOUND' || errorCode === 'EAI_AGAIN') {
-    console.error('NIP-95 proxy DNS error:', {
-      targetEndpoint: params.targetEndpoint,
-      hostname: params.hostname,
-      errorCode,
-      errorMessage,
-      suggestion: 'Check DNS resolution or network connectivity on the server',
-    })
-    return new Error(`DNS resolution failed for ${params.hostname}: ${errorMessage}`)
-  }
-  return params.error instanceof Error ? params.error : new Error(errorMessage)
-}
-
-function handleProxyError(params: {
-  res: NextApiResponse
-  error: unknown
-  targetEndpoint: string
-  hostname: string
-  file: FormidableFile
-}): void {
-  const errorMessage = params.error instanceof Error ? params.error.message : 'Unknown request error'
-  const isDnsError = errorMessage.includes('DNS resolution failed') || errorMessage.includes('ENOTFOUND') || errorMessage.includes('EAI_AGAIN')
-
-  console.error('NIP-95 proxy request error:', {
-    targetEndpoint: params.targetEndpoint,
-    hostname: params.hostname,
-    error: errorMessage,
-    isDnsError,
-    fileSize: params.file.size,
-    fileName: params.file.originalFilename,
-    suggestion: isDnsError ? 'The server cannot resolve the domain name. Check DNS configuration and network connectivity.' : undefined,
-  })
-
-  if (isDnsError) {
-    params.res.status(500).json({
-      error: `DNS resolution failed for ${params.hostname}. The server cannot resolve the domain name. Please check DNS configuration and network connectivity.`,
-    })
-    return
-  }
-
-  params.res.status(500).json({ error: `Failed to connect to upload endpoint: ${errorMessage}` })
-}
-
-function handleProxyResponse(params: {
-  res: NextApiResponse
-  response: ProxyUploadResponse
-  targetEndpoint: string
-}): void {
-  if (params.response.statusCode < 200 || params.response.statusCode >= 300) {
-    return respondNonOk({ res: params.res, response: params.response, targetEndpoint: params.targetEndpoint })
-  }
-
-  if (isHtmlResponse(params.response.body)) {
-    return respondHtml({ res: params.res, response: params.response, targetEndpoint: params.targetEndpoint })
-  }
-
-  const parseResult = parseJsonSafe(params.response.body)
-  if (!parseResult.ok) {
-    console.error('NIP-95 proxy JSON parse error:', {
-      targetEndpoint: params.targetEndpoint,
-      bodyPreview: params.response.body.substring(0, 100),
-    })
-    params.res.status(500).json({
-      error: `Invalid upload response: Invalid JSON response. The endpoint may not be a valid NIP-95 upload endpoint.`,
-    })
-    return
-  }
-
-  params.res.status(200).json(parseResult.value)
-}
-
-function respondNonOk(params: { res: NextApiResponse; response: ProxyUploadResponse; targetEndpoint: string }): void {
-  const errorText = params.response.body.substring(0, 200)
-  console.error('NIP-95 proxy response error:', {
-    targetEndpoint: params.targetEndpoint,
-    finalUrl: params.response.finalUrl,
-    status: params.response.statusCode,
-    statusText: params.response.statusMessage,
-    errorText,
-  })
-
-  params.res.status(params.response.statusCode).json({
-    error: buildUserFriendlyHttpError(params.response.statusCode, params.response.statusMessage, errorText),
-  })
-}
-
-function buildUserFriendlyHttpError(statusCode: number, statusMessage: string, errorText: string): string {
-  if (statusCode === 401) {
-    return 'Authentication required. This endpoint requires authorization headers.'
-  }
-  if (statusCode === 403) {
-    return 'Access forbidden. This endpoint may require authentication or have restrictions.'
-  }
-  if (statusCode === 405) {
-    return 'Method not allowed. This endpoint may not support POST requests or the URL may be incorrect.'
-  }
-  if (statusCode === 413) {
-    return 'File too large. The file exceeds the maximum size allowed by this endpoint.'
-  }
-  if (statusCode >= 500) {
-    return `Server error (${statusCode}). The endpoint server encountered an error.`
-  }
-  return errorText || `Upload failed: ${statusCode} ${statusMessage}`
-}
-
-function isHtmlResponse(body: string): boolean {
-  const trimmedBody = body.trim()
-  return trimmedBody.startsWith('<!DOCTYPE') || trimmedBody.startsWith('<html') || trimmedBody.startsWith('<!')
-}
-
-function respondHtml(params: { res: NextApiResponse; response: ProxyUploadResponse; targetEndpoint: string }): void {
-  const title = readHtmlTitle(params.response.body)
-  const h1 = readHtmlH1(params.response.body)
-  const errorText = title ?? h1 ?? 'HTML error page returned'
-  const flags = detectHtmlErrorFlags({ body: params.response.body, title })
-
-  console.error('NIP-95 proxy HTML response error:', {
-    targetEndpoint: params.targetEndpoint,
-    finalUrl: params.response.finalUrl,
-    status: params.response.statusCode,
-    errorText,
-    is404: flags.is404,
-    is403: flags.is403,
-    is500: flags.is500,
-    bodyPreview: params.response.body.substring(0, 500),
-    contentType: 'HTML (expected JSON)',
-    suggestion: buildHtmlErrorSuggestion(flags),
-  })
-
-  params.res.status(500).json({
-    error: buildHtmlUserMessage({ is404: flags.is404, is403: flags.is403, is500: flags.is500, finalUrl: params.response.finalUrl, errorText }),
-  })
-}
-
-function buildHtmlUserMessage(params: { is404: boolean; is403: boolean; is500: boolean; finalUrl: string; errorText: string }): string {
-  if (params.is404) {
-    return `Endpoint not found (404). The URL may be incorrect: ${params.finalUrl}`
-  }
-  if (params.is403) {
-    return `Access forbidden (403). The endpoint may require authentication or have restrictions.`
-  }
-  if (params.is500) {
-    return `Server error (500). The endpoint server encountered an error.`
-  }
-  return `Endpoint returned an HTML error page instead of JSON. The endpoint may be unavailable, the URL may be incorrect, or specific headers may be required. Error: ${params.errorText}`
-}
-
-type JsonParseResult = { ok: true; value: unknown } | { ok: false }
-
-function parseJsonSafe(body: string): JsonParseResult {
-  try {
-    return { ok: true, value: JSON.parse(body) as unknown }
-  } catch {
-    return { ok: false }
-  }
-}
-
-function readHtmlTitle(body: string): string | undefined {
-  return body.match(/<title[^>]*>([^<]+)<\/title>/i)?.[1]
-}
-
-function readHtmlH1(body: string): string | undefined {
-  return body.match(/<h1[^>]*>([^<]+)<\/h1>/i)?.[1]
-}
-
-function detectHtmlErrorFlags(params: { body: string; title: string | undefined }): { is404: boolean; is403: boolean; is500: boolean } {
-  const is404 = isHtmlErrorForCode({ body: params.body, title: params.title, code: '404', marker: 'Not Found' })
-  const is403 = isHtmlErrorForCode({ body: params.body, title: params.title, code: '403', marker: 'Forbidden' })
-  const is500 = isHtmlErrorForCode({ body: params.body, title: params.title, code: '500', marker: 'Internal Server Error' })
-  return { is404, is403, is500 }
-}
-
-function isHtmlErrorForCode(params: { body: string; title: string | undefined; code: string; marker: string }): boolean {
-  const titleHasCode = params.title?.includes(params.code) === true
-  return params.body.includes(params.code) || params.body.includes(params.marker) || titleHasCode
-}
-
-function buildHtmlErrorSuggestion(params: { is404: boolean; is403: boolean; is500: boolean }): string {
-  if (params.is404) {
-    return 'The endpoint URL may be incorrect or the endpoint does not exist'
-  }
-  if (params.is403) {
-    return 'The endpoint may require authentication or have access restrictions'
-  }
-  if (params.is500) {
-    return 'The endpoint server encountered an error'
-  }
-  return 'The endpoint may not be a valid NIP-95 upload endpoint or may require specific headers'
-}
-
-function getErrnoCode(error: unknown): string | undefined {
-  if (typeof error !== 'object' || error === null) {
-    return undefined
-  }
-  const maybe = error as { code?: unknown }
-  return typeof maybe.code === 'string' ? maybe.code : undefined
-}
diff --git a/pages/api/nip95-upload/handler.ts b/pages/api/nip95-upload/handler.ts
new file mode 100644
index 0000000..3659fa6
--- /dev/null
+++ b/pages/api/nip95-upload/handler.ts
@@ -0,0 +1,37 @@
+import type { NextApiRequest, NextApiResponse } from 'next'
+import { URL } from 'url'
+import type { ProxyQueryParams } from './types'
+import { parseFileFromMultipartRequest, safeUnlink } from './multipart'
+import { makeRequestWithRedirects } from './proxyRequest'
+import { handleProxyError } from './requestErrorResponse'
+import { handleProxyResponse } from './responseFormatting'
+
+export async function nip95UploadHandler(req: NextApiRequest, res: NextApiResponse): Promise<void> {
+  if (req.method !== 'POST') {
+    res.status(405).json({ error: 'Method not allowed' })
+    return
+  }
+
+  const { targetEndpoint, authToken } = readProxyQueryParams(req)
+  const currentUrl = new URL(targetEndpoint)
+
+  const fileField = await parseFileFromMultipartRequest(req)
+  if (!fileField) {
+    res.status(400).json({ error: 'No file provided' })
+    return
+  }
+
+  try {
+    const response = await makeRequestWithRedirects({ targetEndpoint, url: currentUrl, file: fileField, authToken, redirectCount: 0, maxRedirects: 5 })
+    handleProxyResponse({ res, response, targetEndpoint })
+  } catch (error) {
+    handleProxyError({ res, error, targetEndpoint, hostname: currentUrl.hostname, file: fileField })
+  } finally {
+    safeUnlink(fileField.filepath)
+  }
+}
+
+function readProxyQueryParams(req: NextApiRequest): ProxyQueryParams {
+  return { targetEndpoint: (req.query.endpoint as string) ?? 'https://void.cat/upload', authToken: req.query.auth as string | undefined }
+}
+
diff --git a/pages/api/nip95-upload/index.ts b/pages/api/nip95-upload/index.ts
new file mode 100644
index 0000000..2d7a49d
--- /dev/null
+++ b/pages/api/nip95-upload/index.ts
@@ -0,0 +1,11 @@
+import type { NextApiRequest, NextApiResponse } from 'next'
+import { nip95UploadHandler } from './handler'
+
+export const config = {
+  api: { bodyParser: false },
+}
+
+export default async function handler(req: NextApiRequest, res: NextApiResponse): Promise<void> {
+  return nip95UploadHandler(req, res)
+}
+
diff --git a/pages/api/nip95-upload/multipart.ts b/pages/api/nip95-upload/multipart.ts
new file mode 100644
index 0000000..8be196f
--- /dev/null
+++ b/pages/api/nip95-upload/multipart.ts
@@ -0,0 +1,43 @@
+import type { NextApiRequest } from 'next'
+import { IncomingForm, File as FormidableFile } from 'formidable'
+import type { Files } from 'formidable'
+import fs from 'fs'
+import type { ParseResult, UploadedFile } from './types'
+
+const MAX_FILE_SIZE = 50 * 1024 * 1024 // 50MB
+
+export async function parseFileFromMultipartRequest(req: NextApiRequest): Promise<UploadedFile | null> {
+  const form = new IncomingForm({ maxFileSize: MAX_FILE_SIZE, keepExtensions: true })
+  const parseResult = await new Promise<ParseResult>((resolve, reject) => {
+    form.parse(req, (err, fields, files) => {
+      if (err) {
+        console.error('Formidable parse error:', err)
+        reject(err)
+        return
+      }
+      resolve({ fields, files })
+    })
+  })
+  return getFirstFile(parseResult.files, 'file')
+}
+
+function getFirstFile(files: Files, fieldName: string): FormidableFile | null {
+  const value = files[fieldName]
+  if (!value) {
+    return null
+  }
+  if (Array.isArray(value)) {
+    const first = value[0]
+    return first ?? null
+  }
+  return value
+}
+
+export function safeUnlink(filepath: string): void {
+  try {
+    fs.unlinkSync(filepath)
+  } catch (unlinkError) {
+    console.error('Error deleting temp file:', unlinkError)
+  }
+}
+
diff --git a/pages/api/nip95-upload/proxyRequest.ts b/pages/api/nip95-upload/proxyRequest.ts
new file mode 100644
index 0000000..9dbca5b
--- /dev/null
+++ b/pages/api/nip95-upload/proxyRequest.ts
@@ -0,0 +1,144 @@
+import type { UploadedFile, ProxyUploadResponse } from './types'
+import FormData from 'form-data'
+import fs from 'fs'
+import https from 'https'
+import http from 'http'
+import { URL } from 'url'
+import { getFormDataHeaders, getRedirectLocation } from './utils'
+import { handleProxyRequestError } from './proxyRequestErrors'
+
+export async function makeRequestWithRedirects(params: {
+  targetEndpoint: string
+  url: URL
+  file: UploadedFile
+  authToken: string | undefined
+  redirectCount: number
+  maxRedirects: number
+}): Promise<ProxyUploadResponse> {
+  if (params.redirectCount > params.maxRedirects) {
+    throw new Error(`Too many redirects (max ${params.maxRedirects})`)
+  }
+  const response = await makeRequestOnce({ targetEndpoint: params.targetEndpoint, url: params.url, file: params.file, authToken: params.authToken })
+  const redirectUrl = tryGetRedirectUrl({ url: params.url, response })
+  if (!redirectUrl) {
+    return response
+  }
+  console.warn('NIP-95 proxy redirect:', { from: params.url.toString(), to: redirectUrl.toString(), statusCode: response.statusCode, redirectCount: params.redirectCount + 1 })
+  return makeRequestWithRedirects({ ...params, url: redirectUrl, redirectCount: params.redirectCount + 1 })
+}
+
+async function makeRequestOnce(params: { targetEndpoint: string; url: URL; file: UploadedFile; authToken: string | undefined }): Promise<ProxyUploadResponse> {
+  const { requestFormData, fileStream } = buildUploadFormData(params.file)
+  const headers = buildProxyRequestHeaders(requestFormData, params.authToken)
+  const { clientModule, requestOptions } = buildProxyRequestOptions({ url: params.url, headers })
+  return sendFormDataRequest({ clientModule, requestOptions, requestFormData, fileStream, targetEndpoint: params.targetEndpoint, hostname: params.url.hostname, finalUrl: params.url.toString(), filepath: params.file.filepath })
+}
+
+function tryGetRedirectUrl(params: { url: URL; response: ProxyUploadResponse }): URL | null {
+  if (!isRedirectStatus(params.response.statusCode)) {
+    return null
+  }
+  const location = getRedirectLocation(params.response.headers as unknown)
+  if (!location) {
+    throw new Error('Redirect response missing location header')
+  }
+  try {
+    return new URL(location, params.url.toString())
+  } catch (urlError) {
+    console.error('NIP-95 proxy invalid redirect URL:', { location, error: urlError instanceof Error ? urlError.message : 'Unknown error' })
+    throw new Error(`Invalid redirect URL: ${location}`)
+  }
+}
+
+function isRedirectStatus(statusCode: number): boolean {
+  return statusCode === 301 || statusCode === 302 || statusCode === 307 || statusCode === 308
+}
+
+function buildUploadFormData(file: UploadedFile): { requestFormData: FormData; fileStream: fs.ReadStream } {
+  const requestFormData = new FormData()
+  const fileStream = fs.createReadStream(file.filepath)
+  requestFormData.append('file', fileStream, { filename: file.originalFilename ?? file.newFilename ?? 'upload', contentType: file.mimetype ?? 'application/octet-stream' })
+  return { requestFormData, fileStream }
+}
+
+function buildProxyRequestHeaders(requestFormData: FormData, authToken: string | undefined): http.OutgoingHttpHeaders {
+  const headers = getFormDataHeaders(requestFormData)
+  headers.Accept = 'application/json'
+  headers['User-Agent'] = 'zapwall.fr/1.0'
+  if (authToken) {
+    headers.Authorization = `Nostr ${authToken}`
+  }
+  return headers
+}
+
+function buildProxyRequestOptions(params: { url: URL; headers: http.OutgoingHttpHeaders }): { clientModule: typeof http | typeof https; requestOptions: http.RequestOptions } {
+  const isHttps = params.url.protocol === 'https:'
+  return {
+    clientModule: isHttps ? https : http,
+    requestOptions: { hostname: params.url.hostname, port: params.url.port ?? (isHttps ? 443 : 80), path: params.url.pathname + params.url.search, method: 'POST', headers: params.headers, timeout: 30000 },
+  }
+}
+
+async function sendFormDataRequest(params: {
+  clientModule: typeof http | typeof https
+  requestOptions: http.RequestOptions
+  requestFormData: FormData
+  fileStream: fs.ReadStream
+  targetEndpoint: string
+  hostname: string
+  finalUrl: string
+  filepath: string
+}): Promise<ProxyUploadResponse> {
+  return new Promise<ProxyUploadResponse>((resolve, reject) => {
+    const proxyRequest = params.clientModule.request(params.requestOptions, (proxyResponse: http.IncomingMessage) => {
+      void readProxyResponse({ proxyResponse, finalUrl: params.finalUrl }).then(resolve).catch(reject)
+    })
+    attachProxyRequestHandlers({ proxyRequest, requestFormData: params.requestFormData, fileStream: params.fileStream, targetEndpoint: params.targetEndpoint, hostname: params.hostname, filepath: params.filepath, reject })
+    params.requestFormData.pipe(proxyRequest)
+  })
+}
+
+function attachProxyRequestHandlers(params: {
+  proxyRequest: http.ClientRequest
+  requestFormData: FormData
+  fileStream: fs.ReadStream
+  targetEndpoint: string
+  hostname: string
+  filepath: string
+  reject: (error: unknown) => void
+}): void {
+  params.proxyRequest.setTimeout(30000, () => {
+    params.proxyRequest.destroy()
+    params.reject(new Error('Request timeout after 30 seconds'))
+  })
+  params.proxyRequest.on('error', (error) => {
+    params.reject(handleProxyRequestError({ error, targetEndpoint: params.targetEndpoint, hostname: params.hostname }))
+  })
+  params.requestFormData.on('error', (error) => {
+    console.error('NIP-95 proxy FormData error:', { targetEndpoint: params.targetEndpoint, hostname: params.hostname, error })
+    params.reject(error)
+  })
+  params.fileStream.on('error', (error) => {
+    console.error('NIP-95 proxy file stream error:', { targetEndpoint: params.targetEndpoint, hostname: params.hostname, filepath: params.filepath, error })
+    params.reject(error)
+  })
+}
+
+async function readProxyResponse(params: { proxyResponse: http.IncomingMessage; finalUrl: string }): Promise<ProxyUploadResponse> {
+  const statusCode = params.proxyResponse.statusCode ?? 500
+  const body = await readIncomingMessageBody(params.proxyResponse)
+  return { statusCode, statusMessage: params.proxyResponse.statusMessage ?? 'Internal Server Error', body, headers: params.proxyResponse.headers, finalUrl: params.finalUrl }
+}
+
+async function readIncomingMessageBody(message: http.IncomingMessage): Promise<string> {
+  return new Promise<string>((resolve, reject) => {
+    let body = ''
+    message.setEncoding('utf8')
+    message.on('data', (chunk) => {
+      body += chunk
+    })
+    message.on('end', () => resolve(body))
+    message.on('error', reject)
+  })
+}
+
diff --git a/pages/api/nip95-upload/proxyRequestErrors.ts b/pages/api/nip95-upload/proxyRequestErrors.ts
new file mode 100644
index 0000000..217619f
--- /dev/null
+++ b/pages/api/nip95-upload/proxyRequestErrors.ts
@@ -0,0 +1,18 @@
+import { getErrnoCode } from './systemErrors'
+
+export function handleProxyRequestError(params: { error: unknown; targetEndpoint: string; hostname: string }): Error {
+  const errorMessage = params.error instanceof Error ? params.error.message : 'Unknown request error'
+  const errorCode = getErrnoCode(params.error)
+  if (errorCode === 'ENOTFOUND' || errorCode === 'EAI_AGAIN') {
+    console.error('NIP-95 proxy DNS error:', {
+      targetEndpoint: params.targetEndpoint,
+      hostname: params.hostname,
+      errorCode,
+      errorMessage,
+      suggestion: 'Check DNS resolution or network connectivity on the server',
+    })
+    return new Error(`DNS resolution failed for ${params.hostname}: ${errorMessage}`)
+  }
+  return params.error instanceof Error ? params.error : new Error(errorMessage)
+}
+
diff --git a/pages/api/nip95-upload/requestErrorResponse.ts b/pages/api/nip95-upload/requestErrorResponse.ts
new file mode 100644
index 0000000..54e79cd
--- /dev/null
+++ b/pages/api/nip95-upload/requestErrorResponse.ts
@@ -0,0 +1,33 @@
+import type { NextApiResponse } from 'next'
+import type { UploadedFile } from './types'
+
+export function handleProxyError(params: {
+  res: NextApiResponse
+  error: unknown
+  targetEndpoint: string
+  hostname: string
+  file: UploadedFile
+}): void {
+  const errorMessage = params.error instanceof Error ? params.error.message : 'Unknown request error'
+  const isDnsError = errorMessage.includes('DNS resolution failed') || errorMessage.includes('ENOTFOUND') || errorMessage.includes('EAI_AGAIN')
+
+  console.error('NIP-95 proxy request error:', {
+    targetEndpoint: params.targetEndpoint,
+    hostname: params.hostname,
+    error: errorMessage,
+    isDnsError,
+    fileSize: params.file.size,
+    fileName: params.file.originalFilename,
+    suggestion: isDnsError ? 'The server cannot resolve the domain name. Check DNS configuration and network connectivity.' : undefined,
+  })
+
+  if (isDnsError) {
+    params.res.status(500).json({
+      error: `DNS resolution failed for ${params.hostname}. The server cannot resolve the domain name. Please check DNS configuration and network connectivity.`,
+    })
+    return
+  }
+
+  params.res.status(500).json({ error: `Failed to connect to upload endpoint: ${errorMessage}` })
+}
+
diff --git a/pages/api/nip95-upload/responseFormatting.ts b/pages/api/nip95-upload/responseFormatting.ts
new file mode 100644
index 0000000..c31b2cb
--- /dev/null
+++ b/pages/api/nip95-upload/responseFormatting.ts
@@ -0,0 +1,133 @@
+import type { NextApiResponse } from 'next'
+import type { ProxyUploadResponse } from './types'
+
+export function handleProxyResponse(params: { res: NextApiResponse; response: ProxyUploadResponse; targetEndpoint: string }): void {
+  if (params.response.statusCode < 200 || params.response.statusCode >= 300) {
+    respondNonOk({ res: params.res, response: params.response, targetEndpoint: params.targetEndpoint })
+    return
+  }
+  if (isHtmlResponse(params.response.body)) {
+    respondHtml({ res: params.res, response: params.response, targetEndpoint: params.targetEndpoint })
+    return
+  }
+  const parseResult = parseJsonSafe(params.response.body)
+  if (!parseResult.ok) {
+    console.error('NIP-95 proxy JSON parse error:', { targetEndpoint: params.targetEndpoint, bodyPreview: params.response.body.substring(0, 100) })
+    params.res.status(500).json({ error: 'Invalid upload response: Invalid JSON response. The endpoint may not be a valid NIP-95 upload endpoint.' })
+    return
+  }
+  params.res.status(200).json(parseResult.value)
+}
+
+function respondNonOk(params: { res: NextApiResponse; response: ProxyUploadResponse; targetEndpoint: string }): void {
+  const errorText = params.response.body.substring(0, 200)
+  console.error('NIP-95 proxy response error:', {
+    targetEndpoint: params.targetEndpoint,
+    finalUrl: params.response.finalUrl,
+    status: params.response.statusCode,
+    statusText: params.response.statusMessage,
+    errorText,
+  })
+  params.res.status(params.response.statusCode).json({ error: buildUserFriendlyHttpError(params.response.statusCode, params.response.statusMessage, errorText) })
+}
+
+function buildUserFriendlyHttpError(statusCode: number, statusMessage: string, errorText: string): string {
+  if (statusCode === 401) {
+    return 'Authentication required. This endpoint requires authorization headers.'
+  }
+  if (statusCode === 403) {
+    return 'Access forbidden. This endpoint may require authentication or have restrictions.'
+  }
+  if (statusCode === 405) {
+    return 'Method not allowed. This endpoint may not support POST requests or the URL may be incorrect.'
+  }
+  if (statusCode === 413) {
+    return 'File too large. The file exceeds the maximum size allowed by this endpoint.'
+  }
+  if (statusCode >= 500) {
+    return `Server error (${statusCode}). The endpoint server encountered an error.`
+  }
+  return errorText || `Upload failed: ${statusCode} ${statusMessage}`
+}
+
+export function isHtmlResponse(body: string): boolean {
+  const trimmedBody = body.trim()
+  return trimmedBody.startsWith('<!DOCTYPE') || trimmedBody.startsWith('<html') || trimmedBody.startsWith('<!')
+}
+
+function respondHtml(params: { res: NextApiResponse; response: ProxyUploadResponse; targetEndpoint: string }): void {
+  const title = readHtmlTitle(params.response.body)
+  const h1 = readHtmlH1(params.response.body)
+  const errorText = title ?? h1 ?? 'HTML error page returned'
+  const flags = detectHtmlErrorFlags({ body: params.response.body, title })
+  console.error('NIP-95 proxy HTML response error:', {
+    targetEndpoint: params.targetEndpoint,
+    finalUrl: params.response.finalUrl,
+    status: params.response.statusCode,
+    errorText,
+    is404: flags.is404,
+    is403: flags.is403,
+    is500: flags.is500,
+    bodyPreview: params.response.body.substring(0, 500),
+    contentType: 'HTML (expected JSON)',
+    suggestion: buildHtmlErrorSuggestion(flags),
+  })
+  params.res.status(500).json({ error: buildHtmlUserMessage({ ...flags, finalUrl: params.response.finalUrl, errorText }) })
+}
+
+function buildHtmlUserMessage(params: { is404: boolean; is403: boolean; is500: boolean; finalUrl: string; errorText: string }): string {
+  if (params.is404) {
+    return `Endpoint not found (404). The URL may be incorrect: ${params.finalUrl}`
+  }
+  if (params.is403) {
+    return 'Access forbidden (403). The endpoint may require authentication or have restrictions.'
+  }
+  if (params.is500) {
+    return 'Server error (500). The endpoint server encountered an error.'
+  }
+  return `Endpoint returned an HTML error page instead of JSON. The endpoint may be unavailable, the URL may be incorrect, or specific headers may be required. Error: ${params.errorText}`
+}
+
+type JsonParseResult = { ok: true; value: unknown } | { ok: false }
+
+function parseJsonSafe(body: string): JsonParseResult {
+  try {
+    return { ok: true, value: JSON.parse(body) as unknown }
+  } catch {
+    return { ok: false }
+  }
+}
+
+function readHtmlTitle(body: string): string | undefined {
+  return body.match(/<title[^>]*>([^<]+)<\/title>/i)?.[1]
+}
+
+function readHtmlH1(body: string): string | undefined {
+  return body.match(/<h1[^>]*>([^<]+)<\/h1>/i)?.[1]
+}
+
+function detectHtmlErrorFlags(params: { body: string; title: string | undefined }): { is404: boolean; is403: boolean; is500: boolean } {
+  const is404 = isHtmlErrorForCode({ body: params.body, title: params.title, code: '404', marker: 'Not Found' })
+  const is403 = isHtmlErrorForCode({ body: params.body, title: params.title, code: '403', marker: 'Forbidden' })
+  const is500 = isHtmlErrorForCode({ body: params.body, title: params.title, code: '500', marker: 'Internal Server Error' })
+  return { is404, is403, is500 }
+}
+
+function isHtmlErrorForCode(params: { body: string; title: string | undefined; code: string; marker: string }): boolean {
+  const titleHasCode = params.title?.includes(params.code) === true
+  return params.body.includes(params.code) || params.body.includes(params.marker) || titleHasCode
+}
+
+function buildHtmlErrorSuggestion(params: { is404: boolean; is403: boolean; is500: boolean }): string {
+  if (params.is404) {
+    return 'The endpoint URL may be incorrect or the endpoint does not exist'
+  }
+  if (params.is403) {
+    return 'The endpoint may require authentication or have restrictions'
+  }
+  if (params.is500) {
+    return 'The endpoint server encountered an internal error'
+  }
+  return 'The endpoint returned HTML instead of JSON; verify URL and required headers'
+}
+
diff --git a/pages/api/nip95-upload/systemErrors.ts b/pages/api/nip95-upload/systemErrors.ts
new file mode 100644
index 0000000..a30fd05
--- /dev/null
+++ b/pages/api/nip95-upload/systemErrors.ts
@@ -0,0 +1,8 @@
+export function getErrnoCode(error: unknown): string | undefined {
+  if (typeof error !== 'object' || error === null) {
+    return undefined
+  }
+  const rec = error as Record<string, unknown>
+  return typeof rec.code === 'string' ? rec.code : undefined
+}
+
diff --git a/pages/api/nip95-upload/types.ts b/pages/api/nip95-upload/types.ts
new file mode 100644
index 0000000..868beb6
--- /dev/null
+++ b/pages/api/nip95-upload/types.ts
@@ -0,0 +1,26 @@
+import type { NextApiRequest, NextApiResponse } from 'next'
+import type { File as FormidableFile, Fields, Files } from 'formidable'
+import type http from 'http'
+
+export type Nip95UploadHandler = (req: NextApiRequest, res: NextApiResponse) => Promise<void>
+
+export interface ParseResult {
+  fields: Fields
+  files: Files
+}
+
+export interface ProxyUploadResponse {
+  statusCode: number
+  statusMessage: string
+  body: string
+  headers: http.IncomingHttpHeaders
+  finalUrl: string
+}
+
+export interface ProxyQueryParams {
+  targetEndpoint: string
+  authToken: string | undefined
+}
+
+export type UploadedFile = FormidableFile
+
diff --git a/pages/api/nip95-upload/utils.ts b/pages/api/nip95-upload/utils.ts
new file mode 100644
index 0000000..efcbfa9
--- /dev/null
+++ b/pages/api/nip95-upload/utils.ts
@@ -0,0 +1,39 @@
+import type http from 'http'
+
+export function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null
+}
+
+export function readString(value: unknown): string | undefined {
+  return typeof value === 'string' ? value : undefined
+}
+
+export function getFormDataHeaders(formData: import('form-data')): http.OutgoingHttpHeaders {
+  const raw: unknown = formData.getHeaders()
+  if (!isRecord(raw)) {
+    return {}
+  }
+  const headers: http.OutgoingHttpHeaders = {}
+  for (const [key, value] of Object.entries(raw)) {
+    const str = readString(value)
+    if (str !== undefined) {
+      headers[key] = str
+    }
+  }
+  return headers
+}
+
+export function getRedirectLocation(headers: unknown): string | undefined {
+  if (!isRecord(headers)) {
+    return undefined
+  }
+  const { location } = headers
+  if (typeof location === 'string') {
+    return location
+  }
+  if (Array.isArray(location) && typeof location[0] === 'string') {
+    return location[0]
+  }
+  return undefined
+}
+
diff --git a/pages/author/[pubkey].tsx b/pages/author/[pubkey].tsx
index f65a0ca..0de9edf 100644
--- a/pages/author/[pubkey].tsx
+++ b/pages/author/[pubkey].tsx
@@ -21,59 +21,60 @@ function AuthorPageHeader({ presentation }: { presentation: AuthorPresentationAr
   if (!presentation) {
     return null
   }
-
-  // Extract author name from title (format: "Présentation de <name>")
-  const trimmed = presentation.title.replace(/^Présentation de /, '').trim()
-  const authorName = trimmed || presentation.title
-
+  const authorName = getAuthorNameFromPresentationTitle(presentation.title)
   return (
     <div className="space-y-4 mb-8">
       <div className="flex items-start gap-6">
-        {presentation.bannerUrl && (
-          <div className="relative w-32 h-32 rounded-lg overflow-hidden border border-neon-cyan/20 flex-shrink-0">
-            <Image
-              src={presentation.bannerUrl}
-              alt={t('author.profilePicture')}
-              fill
-              className="object-cover"
-            />
-          </div>
-        )}
+        <AuthorProfileImage {...(presentation.bannerUrl ? { bannerUrl: presentation.bannerUrl } : {})} />
         <div className="flex-1 space-y-4">
-          <div>
-            <h1 className="text-3xl font-bold text-neon-cyan mb-2">
-              {authorName}
-            </h1>
-            <p className="text-xs text-cyber-accent/60 italic mb-4">
-              {t('author.profileNote')}
-            </p>
-          </div>
-          {presentation.description && (
-            <div className="space-y-2">
-              <h2 className="text-lg font-semibold text-neon-cyan">
-                {t('presentation.field.presentation')}
-              </h2>
-              <div className="prose prose-invert max-w-none">
-                <p className="text-cyber-accent whitespace-pre-wrap">{presentation.description}</p>
-              </div>
-            </div>
-          )}
-          {presentation.contentDescription && (
-            <div className="space-y-2">
-              <h2 className="text-lg font-semibold text-neon-cyan">
-                {t('presentation.field.contentDescription')}
-              </h2>
-              <div className="prose prose-invert max-w-none">
-                <p className="text-cyber-accent whitespace-pre-wrap">{presentation.contentDescription}</p>
-              </div>
-            </div>
-          )}
+          <AuthorHeaderTitle authorName={authorName} />
+          <AuthorPresentationSection title={t('presentation.field.presentation')} text={presentation.description} />
+          <AuthorPresentationSection title={t('presentation.field.contentDescription')} text={presentation.contentDescription} />
         </div>
       </div>
     </div>
   )
 }
 
+function getAuthorNameFromPresentationTitle(title: string): string {
+  const trimmed = title.replace(/^Présentation de /, '').trim()
+  return trimmed.length > 0 ? trimmed : title
+}
+
+function AuthorProfileImage(params: { bannerUrl?: string }): React.ReactElement | null {
+  if (!params.bannerUrl) {
+    return null
+  }
+  return (
+    <div className="relative w-32 h-32 rounded-lg overflow-hidden border border-neon-cyan/20 flex-shrink-0">
+      <Image src={params.bannerUrl} alt={t('author.profilePicture')} fill className="object-cover" />
+    </div>
+  )
+}
+
+function AuthorHeaderTitle(params: { authorName: string }): React.ReactElement {
+  return (
+    <div>
+      <h1 className="text-3xl font-bold text-neon-cyan mb-2">{params.authorName}</h1>
+      <p className="text-xs text-cyber-accent/60 italic mb-4">{t('author.profileNote')}</p>
+    </div>
+  )
+}
+
+function AuthorPresentationSection(params: { title: string; text: string | undefined }): React.ReactElement | null {
+  if (!params.text) {
+    return null
+  }
+  return (
+    <div className="space-y-2">
+      <h2 className="text-lg font-semibold text-neon-cyan">{params.title}</h2>
+      <div className="prose prose-invert max-w-none">
+        <p className="text-cyber-accent whitespace-pre-wrap">{params.text}</p>
+      </div>
+    </div>
+  )
+}
+
 type SponsoringSummaryProps = {
   totalSponsoring: number
   author: AuthorPresentationArticle | null
@@ -86,45 +87,61 @@ function SponsoringSummary({ totalSponsoring, author, onSponsor }: SponsoringSum
 
   return (
     <div className="bg-cyber-dark/50 border border-neon-cyan/20 rounded-lg p-6 mb-8">
-      <div className="flex items-center justify-between mb-4">
-        <h2 className="text-xl font-semibold text-neon-cyan">{t('author.sponsoring')}</h2>
-        {author && (
-          <button
-            onClick={() => {
-              setShowForm(true)
-            }}
-            className="px-4 py-2 bg-neon-green/20 hover:bg-neon-green/30 text-neon-green rounded-lg font-medium transition-all border border-neon-green/50"
-          >
-            {t('sponsoring.form.submit')}
-          </button>
-        )}
-      </div>
-      <div className="space-y-2">
-        <p className="text-cyber-accent">
-          {t('author.sponsoring.total', { amount: totalBTC.toFixed(6) })}
-        </p>
-        <p className="text-cyber-accent">
-          {t('author.sponsoring.sats', { amount: totalSponsoring.toLocaleString() })}
-        </p>
-      </div>
-      {showForm && author && (
-        <div className="mt-4">
-          <SponsoringForm
-            author={author}
-            onSuccess={() => {
-              setShowForm(false)
-              onSponsor()
-            }}
-            onCancel={() => {
-              setShowForm(false)
-            }}
-          />
-        </div>
+      <SponsoringSummaryHeader showSponsorButton={author !== null} onSponsorClick={() => setShowForm(true)} />
+      <SponsoringTotals totalBTC={totalBTC} totalSats={totalSponsoring} />
+      <SponsoringFormPanel show={showForm} author={author} onClose={() => setShowForm(false)} onSponsor={onSponsor} />
+    </div>
+  )
+}
+
+function SponsoringSummaryHeader(params: { showSponsorButton: boolean; onSponsorClick: () => void }): React.ReactElement {
+  return (
+    <div className="flex items-center justify-between mb-4">
+      <h2 className="text-xl font-semibold text-neon-cyan">{t('author.sponsoring')}</h2>
+      {params.showSponsorButton && (
+        <button
+          onClick={params.onSponsorClick}
+          className="px-4 py-2 bg-neon-green/20 hover:bg-neon-green/30 text-neon-green rounded-lg font-medium transition-all border border-neon-green/50"
+        >
+          {t('sponsoring.form.submit')}
+        </button>
       )}
     </div>
   )
 }
 
+function SponsoringTotals(params: { totalBTC: number; totalSats: number }): React.ReactElement {
+  return (
+    <div className="space-y-2">
+      <p className="text-cyber-accent">{t('author.sponsoring.total', { amount: params.totalBTC.toFixed(6) })}</p>
+      <p className="text-cyber-accent">{t('author.sponsoring.sats', { amount: params.totalSats.toLocaleString() })}</p>
+    </div>
+  )
+}
+
+function SponsoringFormPanel(params: {
+  show: boolean
+  author: AuthorPresentationArticle | null
+  onClose: () => void
+  onSponsor: () => void
+}): React.ReactElement | null {
+  if (!params.show || !params.author) {
+    return null
+  }
+  return (
+    <div className="mt-4">
+      <SponsoringForm
+        author={params.author}
+        onSuccess={() => {
+          params.onClose()
+          params.onSponsor()
+        }}
+        onCancel={params.onClose}
+      />
+    </div>
+  )
+}
+
 function SeriesList({ series, authorPubkey, onSeriesCreated }: { series: Series[]; authorPubkey: string; onSeriesCreated: () => void }): React.ReactElement {
   const { pubkey, isUnlocked } = useNostrAuth()
   const [showCreateModal, setShowCreateModal] = useState(false)
@@ -282,25 +299,7 @@ export default function AuthorPage(): React.ReactElement {
   // Parse the URL parameter - it can be either:
   // 1. Old format: /author/<pubkey> (for backward compatibility)
   // 2. New format: /author/<hash>_<index>_<version> (standard format)
-  let hashIdOrPubkey: string | null = null
-
-  if (typeof pubkey === 'string') {
-    // Try to parse as new format first (hash_index_version)
-    const urlMatch = pubkey.match(/^([a-f0-9]+)_(\d+)_(\d+)$/i)
-    if (urlMatch?.[1]) {
-      // Extract hash ID from the format hash_index_version
-      hashIdOrPubkey = urlMatch[1]
-    } else {
-      // Try to parse as full URL format
-      const parsedUrl = parseObjectUrl(`https://zapwall.fr/author/${pubkey}`)
-      if (parsedUrl.objectType === 'author' && parsedUrl.idHash) {
-        hashIdOrPubkey = parsedUrl.idHash
-      } else {
-        // Legacy: treat as pubkey for backward compatibility (64 hex chars)
-        hashIdOrPubkey = pubkey
-      }
-    }
-  }
+  const hashIdOrPubkey = resolveAuthorHashIdOrPubkey(pubkey)
 
   const { presentation, series, totalSponsoring, loading, error, reload } = useAuthorData(hashIdOrPubkey ?? '')
   const onSeriesCreated = (): void => {
@@ -339,3 +338,18 @@ export default function AuthorPage(): React.ReactElement {
     </>
   )
 }
+
+function resolveAuthorHashIdOrPubkey(pubkeyParam: string | string[] | undefined): string | null {
+  if (typeof pubkeyParam !== 'string') {
+    return null
+  }
+  const urlMatch = pubkeyParam.match(/^([a-f0-9]+)_(\d+)_(\d+)$/i)
+  if (urlMatch?.[1]) {
+    return urlMatch[1]
+  }
+  const parsedUrl = parseObjectUrl(`https://zapwall.fr/author/${pubkeyParam}`)
+  if (parsedUrl.objectType === 'author' && parsedUrl.idHash) {
+    return parsedUrl.idHash
+  }
+  return pubkeyParam
+}
diff --git a/pages/docs.tsx b/pages/docs.tsx
index 8c49398..e1a2d7f 100644
--- a/pages/docs.tsx
+++ b/pages/docs.tsx
@@ -7,33 +7,7 @@ import { useDocs, type DocLink, type DocSection } from '@/hooks/useDocs'
 import { t } from '@/lib/i18n'
 
 export default function DocsPage(): React.ReactElement {
-  const docs: DocLink[] = [
-    {
-      id: 'user-guide',
-      title: t('docs.userGuide'),
-      file: 'user-guide.md',
-    },
-    {
-      id: 'faq',
-      title: t('docs.faq'),
-      file: 'faq.md',
-    },
-    {
-      id: 'publishing',
-      title: t('docs.publishing'),
-      file: 'publishing-guide.md',
-    },
-    {
-      id: 'payment',
-      title: t('docs.payment'),
-      file: 'payment-guide.md',
-    },
-    {
-      id: 'fees-and-contributions',
-      title: t('docs.feesAndContributions'),
-      file: 'fees-and-contributions.md',
-    },
-  ]
+  const docs = buildDocsLinks()
 
   const { selectedDoc, docContent, loading, loadDoc } = useDocs(docs)
 
@@ -66,3 +40,13 @@ export default function DocsPage(): React.ReactElement {
     </>
   )
 }
+
+function buildDocsLinks(): DocLink[] {
+  return [
+    { id: 'user-guide', title: t('docs.userGuide'), file: 'user-guide.md' },
+    { id: 'faq', title: t('docs.faq'), file: 'faq.md' },
+    { id: 'publishing', title: t('docs.publishing'), file: 'publishing-guide.md' },
+    { id: 'payment', title: t('docs.payment'), file: 'payment-guide.md' },
+    { id: 'fees-and-contributions', title: t('docs.feesAndContributions'), file: 'fees-and-contributions.md' },
+  ]
+}
diff --git a/pages/index.tsx b/pages/index.tsx
index 9257904..2ecec8b 100644
--- a/pages/index.tsx
+++ b/pages/index.tsx
@@ -133,33 +133,23 @@ function useHomeController(): {
   useCategorySync(selectedCategory, setFilters)
   const articles = useFilteredArticles(allArticlesRaw, searchQuery, filters, presentationArticles)
   const handleUnlock = useUnlockHandler(loadArticleContent, setUnlockedArticles)
+  const { authors, allAuthors } = useAuthorsByCategory(presentationArticles, selectedCategory)
 
-  // Get authors by category
+  return { searchQuery, setSearchQuery, selectedCategory, setSelectedCategory, filters, setFilters, articles, allArticles, authors, allAuthors, loading, error, unlockedArticles, handleUnlock }
+}
+
+function useAuthorsByCategory(
+  presentationArticles: Map<string, Article>,
+  selectedCategory: ArticleFilters['category']
+): { authors: Article[]; allAuthors: Article[] } {
   const allAuthors = useMemo((): Article[] => {
     const authorsArray = Array.from(presentationArticles.values())
     return sortAuthors(authorsArray)
   }, [presentationArticles])
 
-  const authors = useMemo((): Article[] => {
-    return getAuthorsByCategory(presentationArticles, selectedCategory)
-  }, [presentationArticles, selectedCategory])
+  const authors = useMemo((): Article[] => getAuthorsByCategory(presentationArticles, selectedCategory), [presentationArticles, selectedCategory])
 
-  return {
-    searchQuery,
-    setSearchQuery,
-    selectedCategory,
-    setSelectedCategory,
-    filters,
-    setFilters,
-    articles,
-    allArticles,
-    authors,
-    allAuthors,
-    loading,
-    error,
-    unlockedArticles,
-    handleUnlock,
-  }
+  return { authors, allAuthors }
 }
 
 export default function Home(): React.ReactElement {
diff --git a/pages/purchase/[id].tsx b/pages/purchase/[id].tsx
index 4b0428b..251f75e 100644
--- a/pages/purchase/[id].tsx
+++ b/pages/purchase/[id].tsx
@@ -19,24 +19,7 @@ export default function PurchasePage(): React.ReactElement | null {
     if (!purchaseId) {
       return
     }
-    const load = async (): Promise<void> => {
-      setLoading(true)
-      setError(null)
-      try {
-        const p = await getPurchaseById(purchaseId)
-        if (!p) {
-          setError('Paiement introuvable')
-          setLoading(false)
-          return
-        }
-        setPurchase(p)
-      } catch (e) {
-        setError(e instanceof Error ? e.message : 'Erreur lors du chargement du paiement')
-      } finally {
-        setLoading(false)
-      }
-    }
-    void load()
+    void loadPurchase({ purchaseId, setPurchase, setLoading, setError })
   }, [purchaseId])
 
   if (!purchaseId) {
@@ -56,26 +39,7 @@ export default function PurchasePage(): React.ReactElement | null {
           {purchase && (
             <div className="bg-cyber-darker border border-neon-cyan/30 rounded-lg p-6 space-y-4">
               <h1 className="text-3xl font-bold text-neon-cyan">Paiement d&apos;article</h1>
-              <div className="space-y-2">
-                <p className="text-cyber-accent">
-                  <span className="font-semibold">Montant :</span> {purchase.amount} sats
-                </p>
-                <p className="text-cyber-accent">
-                  <span className="font-semibold">Article ID :</span> {purchase.articleId}
-                </p>
-                <p className="text-cyber-accent">
-                  <span className="font-semibold">Auteur :</span> {purchase.authorPubkey.substring(0, 16)}...
-                </p>
-                <p className="text-cyber-accent">
-                  <span className="font-semibold">Payeur :</span> {purchase.payerPubkey.substring(0, 16)}...
-                </p>
-                <p className="text-cyber-accent">
-                  <span className="font-semibold">Hash de paiement :</span> {purchase.paymentHash}
-                </p>
-                <p className="text-cyber-accent">
-                  <span className="font-semibold">Date :</span> {new Date(purchase.createdAt * 1000).toLocaleString()}
-                </p>
-              </div>
+              <PurchaseDetails purchase={purchase} />
             </div>
           )}
         </div>
@@ -84,3 +48,51 @@ export default function PurchasePage(): React.ReactElement | null {
     </>
   )
 }
+
+async function loadPurchase(params: {
+  purchaseId: string
+  setPurchase: (value: Purchase | null) => void
+  setLoading: (value: boolean) => void
+  setError: (value: string | null) => void
+}): Promise<void> {
+  params.setLoading(true)
+  params.setError(null)
+  try {
+    const p = await getPurchaseById(params.purchaseId)
+    if (!p) {
+      params.setError('Paiement introuvable')
+      return
+    }
+    params.setPurchase(p)
+  } catch (e) {
+    params.setError(e instanceof Error ? e.message : 'Erreur lors du chargement du paiement')
+  } finally {
+    params.setLoading(false)
+  }
+}
+
+function PurchaseDetails(params: { purchase: Purchase }): React.ReactElement {
+  const {purchase} = params
+  return (
+    <div className="space-y-2">
+      <p className="text-cyber-accent">
+        <span className="font-semibold">Montant :</span> {purchase.amount} sats
+      </p>
+      <p className="text-cyber-accent">
+        <span className="font-semibold">Article ID :</span> {purchase.articleId}
+      </p>
+      <p className="text-cyber-accent">
+        <span className="font-semibold">Auteur :</span> {purchase.authorPubkey.substring(0, 16)}...
+      </p>
+      <p className="text-cyber-accent">
+        <span className="font-semibold">Payeur :</span> {purchase.payerPubkey.substring(0, 16)}...
+      </p>
+      <p className="text-cyber-accent">
+        <span className="font-semibold">Hash de paiement :</span> {purchase.paymentHash}
+      </p>
+      <p className="text-cyber-accent">
+        <span className="font-semibold">Date :</span> {new Date(purchase.createdAt * 1000).toLocaleString()}
+      </p>
+    </div>
+  )
+}
diff --git a/pages/review-tip/[id].tsx b/pages/review-tip/[id].tsx
index 5500d11..499cc09 100644
--- a/pages/review-tip/[id].tsx
+++ b/pages/review-tip/[id].tsx
@@ -19,24 +19,7 @@ export default function ReviewTipPage(): React.ReactElement | null {
     if (!reviewTipId) {
       return
     }
-    const load = async (): Promise<void> => {
-      setLoading(true)
-      setError(null)
-      try {
-        const rt = await getReviewTipById(reviewTipId)
-        if (!rt) {
-          setError('Remerciement introuvable')
-          setLoading(false)
-          return
-        }
-        setReviewTip(rt)
-      } catch (e) {
-        setError(e instanceof Error ? e.message : 'Erreur lors du chargement du remerciement')
-      } finally {
-        setLoading(false)
-      }
-    }
-    void load()
+    void loadReviewTip({ reviewTipId, setReviewTip, setLoading, setError })
   }, [reviewTipId])
 
   if (!reviewTipId) {
@@ -56,32 +39,7 @@ export default function ReviewTipPage(): React.ReactElement | null {
           {reviewTip && (
             <div className="bg-cyber-darker border border-neon-cyan/30 rounded-lg p-6 space-y-4">
               <h1 className="text-3xl font-bold text-neon-cyan">Remerciement d&apos;avis</h1>
-              <div className="space-y-2">
-                <p className="text-cyber-accent">
-                  <span className="font-semibold">Montant :</span> {reviewTip.amount} sats
-                </p>
-                <p className="text-cyber-accent">
-                  <span className="font-semibold">Article ID :</span> {reviewTip.articleId}
-                </p>
-                <p className="text-cyber-accent">
-                  <span className="font-semibold">Avis ID :</span> {reviewTip.reviewId}
-                </p>
-                <p className="text-cyber-accent">
-                  <span className="font-semibold">Auteur :</span> {reviewTip.authorPubkey.substring(0, 16)}...
-                </p>
-                <p className="text-cyber-accent">
-                  <span className="font-semibold">Critique :</span> {reviewTip.reviewerPubkey.substring(0, 16)}...
-                </p>
-                <p className="text-cyber-accent">
-                  <span className="font-semibold">Payeur :</span> {reviewTip.payerPubkey.substring(0, 16)}...
-                </p>
-                <p className="text-cyber-accent">
-                  <span className="font-semibold">Hash de paiement :</span> {reviewTip.paymentHash}
-                </p>
-                <p className="text-cyber-accent">
-                  <span className="font-semibold">Date :</span> {new Date(reviewTip.createdAt * 1000).toLocaleString()}
-                </p>
-              </div>
+              <ReviewTipDetails reviewTip={reviewTip} />
             </div>
           )}
         </div>
@@ -90,3 +48,57 @@ export default function ReviewTipPage(): React.ReactElement | null {
     </>
   )
 }
+
+async function loadReviewTip(params: {
+  reviewTipId: string
+  setReviewTip: (value: ReviewTip | null) => void
+  setLoading: (value: boolean) => void
+  setError: (value: string | null) => void
+}): Promise<void> {
+  params.setLoading(true)
+  params.setError(null)
+  try {
+    const rt = await getReviewTipById(params.reviewTipId)
+    if (!rt) {
+      params.setError('Remerciement introuvable')
+      return
+    }
+    params.setReviewTip(rt)
+  } catch (e) {
+    params.setError(e instanceof Error ? e.message : 'Erreur lors du chargement du remerciement')
+  } finally {
+    params.setLoading(false)
+  }
+}
+
+function ReviewTipDetails(params: { reviewTip: ReviewTip }): React.ReactElement {
+  const {reviewTip} = params
+  return (
+    <div className="space-y-2">
+      <p className="text-cyber-accent">
+        <span className="font-semibold">Montant :</span> {reviewTip.amount} sats
+      </p>
+      <p className="text-cyber-accent">
+        <span className="font-semibold">Article ID :</span> {reviewTip.articleId}
+      </p>
+      <p className="text-cyber-accent">
+        <span className="font-semibold">Avis ID :</span> {reviewTip.reviewId}
+      </p>
+      <p className="text-cyber-accent">
+        <span className="font-semibold">Auteur :</span> {reviewTip.authorPubkey.substring(0, 16)}...
+      </p>
+      <p className="text-cyber-accent">
+        <span className="font-semibold">Critique :</span> {reviewTip.reviewerPubkey.substring(0, 16)}...
+      </p>
+      <p className="text-cyber-accent">
+        <span className="font-semibold">Payeur :</span> {reviewTip.payerPubkey.substring(0, 16)}...
+      </p>
+      <p className="text-cyber-accent">
+        <span className="font-semibold">Hash de paiement :</span> {reviewTip.paymentHash}
+      </p>
+      <p className="text-cyber-accent">
+        <span className="font-semibold">Date :</span> {new Date(reviewTip.createdAt * 1000).toLocaleString()}
+      </p>
+    </div>
+  )
+}
diff --git a/pages/series/[id]/publish.tsx b/pages/series/[id]/publish.tsx
index e8ca4b0..ecd794f 100644
--- a/pages/series/[id]/publish.tsx
+++ b/pages/series/[id]/publish.tsx
@@ -49,87 +49,81 @@ export default function SeriesPublishPage(): React.ReactElement | null {
   }
 
   if (loading) {
-    return (
-      <main className="min-h-screen bg-gray-50">
-        <div className="w-full px-4 py-8">
-          <p className="text-sm text-gray-600">{t('common.loading')}</p>
-        </div>
-      </main>
-    )
+    return <SeriesPublishLoading />
   }
-
   if (error || !series) {
-    return (
-      <main className="min-h-screen bg-gray-50">
-        <div className="w-full px-4 py-8">
-          <p className="text-sm text-red-600">{error ?? 'Série introuvable'}</p>
-          <button
-            onClick={() => {
-              void router.back()
-            }}
-            className="mt-4 text-blue-600 hover:text-blue-700 text-sm"
-          >
-            {t('common.back')}
-          </button>
-        </div>
-      </main>
-    )
+    return <SeriesPublishError error={error} onBack={() => { void router.back() }} />
   }
-
   if (!isAuthor) {
-    return (
-      <main className="min-h-screen bg-gray-50">
-        <div className="w-full px-4 py-8">
-          <p className="text-sm text-red-600">{t('series.publish.error.notAuthor')}</p>
-          <button
-            onClick={() => {
-              void router.push(`/series/${seriesId}`)
-            }}
-            className="mt-4 text-blue-600 hover:text-blue-700 text-sm"
-          >
-            {t('common.back')}
-          </button>
-        </div>
-      </main>
-    )
+    return <SeriesPublishNotAuthor onBack={() => { void router.push(`/series/${seriesId}`) }} />
   }
+  return <SeriesPublishEditorView series={series} seriesId={seriesId} onBack={() => { void router.push(`/series/${seriesId}`) }} onAfterPublish={() => { void router.push(`/series/${seriesId}`) }} />
+}
 
+function SeriesPublishLoading(): React.ReactElement {
+  return (
+    <main className="min-h-screen bg-gray-50">
+      <div className="w-full px-4 py-8">
+        <p className="text-sm text-gray-600">{t('common.loading')}</p>
+      </div>
+    </main>
+  )
+}
+
+function SeriesPublishError(params: { error: string | null; onBack: () => void }): React.ReactElement {
+  return (
+    <main className="min-h-screen bg-gray-50">
+      <div className="w-full px-4 py-8">
+        <p className="text-sm text-red-600">{params.error ?? 'Série introuvable'}</p>
+        <button onClick={params.onBack} className="mt-4 text-blue-600 hover:text-blue-700 text-sm">
+          {t('common.back')}
+        </button>
+      </div>
+    </main>
+  )
+}
+
+function SeriesPublishNotAuthor(params: { onBack: () => void }): React.ReactElement {
+  return (
+    <main className="min-h-screen bg-gray-50">
+      <div className="w-full px-4 py-8">
+        <p className="text-sm text-red-600">{t('series.publish.error.notAuthor')}</p>
+        <button onClick={params.onBack} className="mt-4 text-blue-600 hover:text-blue-700 text-sm">
+          {t('common.back')}
+        </button>
+      </div>
+    </main>
+  )
+}
+
+function SeriesPublishEditorView(params: { series: Series; seriesId: string; onBack: () => void; onAfterPublish: () => void }): React.ReactElement {
   const handlePublishSuccess = (): void => {
     setTimeout(() => {
-      void router.push(`/series/${seriesId}`)
+      params.onAfterPublish()
     }, 2000)
   }
-
   return (
     <>
-      <PublishHeader series={series} />
+      <PublishHeader series={params.series} />
       <main className="min-h-screen bg-gray-50">
         <header className="bg-white shadow-sm">
           <div className="w-full px-4 py-4 flex justify-between items-center">
             <h1 className="text-2xl font-bold text-gray-900">zapwall4Science</h1>
           </div>
         </header>
-
         <div className="w-full px-4 py-8">
-          <button
-            onClick={() => {
-              void router.push(`/series/${seriesId}`)
-            }}
-            className="text-blue-600 hover:text-blue-700 text-sm font-medium mb-4"
-          >
+          <button onClick={params.onBack} className="text-blue-600 hover:text-blue-700 text-sm font-medium mb-4">
             {t('common.back')}
           </button>
-          <SeriesHeader series={series} />
+          <SeriesHeader series={params.series} />
           <ArticleEditor
             onPublishSuccess={handlePublishSuccess}
-            onCancel={() => {
-              void router.push(`/series/${seriesId}`)
-            }}
-            seriesOptions={[{ id: series.id, title: series.title }]}
+            onCancel={params.onBack}
+            seriesOptions={[{ id: params.series.id, title: params.series.title }]}
             onSelectSeries={() => {
               // Series is already selected and cannot be changed
             }}
-            defaultSeriesId={series.id}
+            defaultSeriesId={params.series.id}
           />
         </div>
       </main>
diff --git a/pages/sponsoring/[id].tsx b/pages/sponsoring/[id].tsx
index e9d3f09..2d411b1 100644
--- a/pages/sponsoring/[id].tsx
+++ b/pages/sponsoring/[id].tsx
@@ -19,24 +19,7 @@ export default function SponsoringPage(): React.ReactElement | null {
     if (!sponsoringId) {
       return
     }
-    const load = async (): Promise<void> => {
-      setLoading(true)
-      setError(null)
-      try {
-        const s = await getSponsoringById(sponsoringId)
-        if (!s) {
-          setError('Sponsoring introuvable')
-          setLoading(false)
-          return
-        }
-        setSponsoring(s)
-      } catch (e) {
-        setError(e instanceof Error ? e.message : 'Erreur lors du chargement du sponsoring')
-      } finally {
-        setLoading(false)
-      }
-    }
-    void load()
+    void loadSponsoring({ sponsoringId, setSponsoring, setLoading, setError })
   }, [sponsoringId])
 
   if (!sponsoringId) {
@@ -56,33 +39,7 @@ export default function SponsoringPage(): React.ReactElement | null {
           {sponsoring && (
             <div className="bg-cyber-darker border border-neon-cyan/30 rounded-lg p-6 space-y-4">
               <h1 className="text-3xl font-bold text-neon-cyan">Sponsoring</h1>
-              <div className="space-y-2">
-                <p className="text-cyber-accent">
-                  <span className="font-semibold">Montant :</span> {sponsoring.amount} sats
-                </p>
-                <p className="text-cyber-accent">
-                  <span className="font-semibold">Auteur :</span> {sponsoring.authorPubkey.substring(0, 16)}...
-                </p>
-                <p className="text-cyber-accent">
-                  <span className="font-semibold">Payeur :</span> {sponsoring.payerPubkey.substring(0, 16)}...
-                </p>
-                {sponsoring.seriesId && (
-                  <p className="text-cyber-accent">
-                    <span className="font-semibold">Série ID :</span> {sponsoring.seriesId}
-                  </p>
-                )}
-                {sponsoring.articleId && (
-                  <p className="text-cyber-accent">
-                    <span className="font-semibold">Article ID :</span> {sponsoring.articleId}
-                  </p>
-                )}
-                <p className="text-cyber-accent">
-                  <span className="font-semibold">Hash de paiement :</span> {sponsoring.paymentHash}
-                </p>
-                <p className="text-cyber-accent">
-                  <span className="font-semibold">Date :</span> {new Date(sponsoring.createdAt * 1000).toLocaleString()}
-                </p>
-              </div>
+              <SponsoringDetails sponsoring={sponsoring} />
             </div>
           )}
         </div>
@@ -91,3 +48,58 @@ export default function SponsoringPage(): React.ReactElement | null {
     </>
   )
 }
+
+async function loadSponsoring(params: {
+  sponsoringId: string
+  setSponsoring: (value: Sponsoring | null) => void
+  setLoading: (value: boolean) => void
+  setError: (value: string | null) => void
+}): Promise<void> {
+  params.setLoading(true)
+  params.setError(null)
+  try {
+    const s = await getSponsoringById(params.sponsoringId)
+    if (!s) {
+      params.setError('Sponsoring introuvable')
+      return
+    }
+    params.setSponsoring(s)
+  } catch (e) {
+    params.setError(e instanceof Error ? e.message : 'Erreur lors du chargement du sponsoring')
+  } finally {
+    params.setLoading(false)
+  }
+}
+
+function SponsoringDetails(params: { sponsoring: Sponsoring }): React.ReactElement {
+  const {sponsoring} = params
+  return (
+    <div className="space-y-2">
+      <p className="text-cyber-accent">
+        <span className="font-semibold">Montant :</span> {sponsoring.amount} sats
+      </p>
+      <p className="text-cyber-accent">
+        <span className="font-semibold">Auteur :</span> {sponsoring.authorPubkey.substring(0, 16)}...
+      </p>
+      <p className="text-cyber-accent">
+        <span className="font-semibold">Payeur :</span> {sponsoring.payerPubkey.substring(0, 16)}...
+      </p>
+      {sponsoring.seriesId && (
+        <p className="text-cyber-accent">
+          <span className="font-semibold">Série ID :</span> {sponsoring.seriesId}
+        </p>
+      )}
+      {sponsoring.articleId && (
+        <p className="text-cyber-accent">
+          <span className="font-semibold">Article ID :</span> {sponsoring.articleId}
+        </p>
+      )}
+      <p className="text-cyber-accent">
+        <span className="font-semibold">Hash de paiement :</span> {sponsoring.paymentHash}
+      </p>
+      <p className="text-cyber-accent">
+        <span className="font-semibold">Date :</span> {new Date(sponsoring.createdAt * 1000).toLocaleString()}
+      </p>
+    </div>
+  )
+}
diff --git a/types/nostr-tools-extended.ts b/types/nostr-tools-extended.ts
index ba92470..9b2f2f6 100644
--- a/types/nostr-tools-extended.ts
+++ b/types/nostr-tools-extended.ts
@@ -25,45 +25,63 @@ export function createSubscription(
   relays: string[],
   filters: Filter[]
 ): Subscription {
-  const events: Event[] = []
-  let eoseReceived = false
-  const eventCallbacks: Array<(event: Event) => void> = []
-  const eoseCallbacks: Array<() => void> = []
+  const state = createSubscriptionState()
+  const subscription = pool.subscribe(relays, filters[0] ?? {}, {
+    onevent: (event: Event) => onSubscriptionEvent({ state, event }),
+    oneose: () => onSubscriptionEose({ state }),
+  })
+  return buildSubscriptionWrapper({ state, subscription })
+}
 
-  const subscription = pool.subscribe(
-    relays,
-    filters[0] ?? {},
-    {
-      onevent: (event: Event) => {
-        events.push(event)
-        eventCallbacks.forEach((cb) => cb(event))
-      },
-      oneose: () => {
-        eoseReceived = true
-        eoseCallbacks.forEach((cb) => cb())
-      },
-    }
-  )
+function createSubscriptionState(): {
+  events: Event[]
+  eoseReceived: boolean
+  eventCallbacks: Array<(event: Event) => void>
+  eoseCallbacks: Array<() => void>
+} {
+  return { events: [], eoseReceived: false, eventCallbacks: [], eoseCallbacks: [] }
+}
 
-  const subscriptionWrapper: Subscription = {
+function onSubscriptionEvent(params: { state: ReturnType<typeof createSubscriptionState>; event: Event }): void {
+  params.state.events.push(params.event)
+  params.state.eventCallbacks.forEach((cb) => cb(params.event))
+}
+
+function onSubscriptionEose(params: { state: ReturnType<typeof createSubscriptionState> }): void {
+  const { state } = params
+  state.eoseReceived = true
+  state.eoseCallbacks.forEach((cb) => cb())
+}
+
+function buildSubscriptionWrapper(params: {
+  state: ReturnType<typeof createSubscriptionState>
+  subscription: { close: () => void }
+}): Subscription {
+  return {
     on(event: 'event' | 'eose', callback: ((event: Event) => void) | (() => void)): void {
-      if (event === 'event') {
-        const eventCb = callback as (event: Event) => void
-        eventCallbacks.push(eventCb)
-        // Emit any events that were already received
-        events.forEach((e) => eventCb(e))
-      } else if (event === 'eose') {
-        const eoseCb = callback as () => void
-        if (eoseReceived) {
-          eoseCb()
-        } else {
-          eoseCallbacks.push(eoseCb)
-        }
-      }
+      handleSubscriptionOn({ state: params.state, event, callback })
     },
     unsub(): void {
-      subscription.close()
+      params.subscription.close()
     },
   }
-  return subscriptionWrapper
+}
+
+function handleSubscriptionOn(params: {
+  state: ReturnType<typeof createSubscriptionState>
+  event: 'event' | 'eose'
+  callback: ((event: Event) => void) | (() => void)
+}): void {
+  if (params.event === 'event') {
+    const eventCb = params.callback as (event: Event) => void
+    params.state.eventCallbacks.push(eventCb)
+    params.state.events.forEach((e) => eventCb(e))
+    return
+  }
+  const eoseCb = params.callback as () => void
+  if (params.state.eoseReceived) {
+    eoseCb()
+    return
+  }
+  params.state.eoseCallbacks.push(eoseCb)
 }