diff --git a/.env.example b/.env.example
index 6369a1d8..b7261c27 100644
--- a/.env.example
+++ b/.env.example
@@ -58,3 +58,14 @@ NEXT_PUBLIC_BLOCKFROST_API_KEY_PREPROD="your-blockfrost-preprod-api-key"
 # DISCORD_CLIENT_SECRET="your-discord-client-secret"
 # DISCORD_BOT_TOKEN="your-discord-bot-token"
 # DISCORD_GUILD_ID="your-discord-guild-id"
+
+# Optional: Email notifications via Resend
+# RESEND_API_KEY="re_..."
+# EMAIL_FROM="Mesh Multisig <notifications@your-domain.example>"
+# EMAIL_REPLY_TO="support@your-domain.example"
+# Optional: override notification email links. Required for localhost links when
+# using `next start` locally (NODE_ENV is production). Defaults to
+# http://localhost:3000 in `next dev` and the production site URL otherwise.
+# NOTIFICATION_LINK_BASE_URL="http://localhost:3000"
+# NOTIFICATION_DRAIN_SECRET="your-notification-drain-secret"
+# NOTIFICATIONS_EMAIL_ENABLED="false"
diff --git a/.github/workflows/trpc-integration-tests.yml b/.github/workflows/trpc-integration-tests.yml
index bc7b2381..8a75c1f5 100644
--- a/.github/workflows/trpc-integration-tests.yml
+++ b/.github/workflows/trpc-integration-tests.yml
@@ -13,7 +13,7 @@ on:
 jobs:
   trpc-tests:
     runs-on: ubuntu-latest
-    timeout-minutes: 15
+    timeout-minutes: 25
 
     services:
       postgres:
@@ -46,8 +46,14 @@ jobs:
           node-version: 22
           cache: npm
 
+      - name: Use repo npm version
+        run: npm install -g "$(node -p 'require("./package.json").packageManager')" && npm --version
+
       - name: Install dependencies
-        run: npm ci
+        run: npm ci --ignore-scripts
+
+      - name: Generate Prisma client
+        run: npx prisma generate
 
       - name: Run database migrations
         run: npx prisma migrate deploy
diff --git a/.github/workflows/unit-tests.yml b/.github/workflows/unit-tests.yml
index c6e8ca3d..bb06dec0 100644
--- a/.github/workflows/unit-tests.yml
+++ b/.github/workflows/unit-tests.yml
@@ -14,7 +14,7 @@ jobs:
   unit-tests:
     name: Transaction builder unit tests
     runs-on: ubuntu-latest
-    timeout-minutes: 10
+    timeout-minutes: 20
 
     steps:
       - name: Checkout repository
@@ -25,8 +25,14 @@ jobs:
         with:
           node-version: 22
 
+      - name: Use repo npm version
+        run: npm install -g "$(node -p 'require("./package.json").packageManager')" && npm --version
+
       - name: Install dependencies
-        run: npm ci
+        run: npm ci --ignore-scripts
+
+      - name: Generate Prisma client
+        run: npx prisma generate
 
       - name: Run transaction builder tests
         run: npm run test:ci -- --testPathPatterns="src/__tests__/tx-builders"
diff --git a/.gitignore b/.gitignore
index 2c85f24b..870d4384 100644
--- a/.gitignore
+++ b/.gitignore
@@ -38,6 +38,7 @@ yarn-error.log*
 # do not commit any .env files to git, except for the .env.example file. https://create.t3.gg/en/usage/env-variables#using-environment-variables
 .env
 .env*.local
+.env.playwright
 
 # bot ref client config (contains secret)
 scripts/bot-ref/bot-config.json
diff --git a/Dockerfile.ci b/Dockerfile.ci
index 2389dea2..827ab8e8 100644
--- a/Dockerfile.ci
+++ b/Dockerfile.ci
@@ -24,7 +24,10 @@ ENV NODE_OPTIONS=--experimental-wasm-modules
 COPY package.json package-lock.json* ./
 COPY prisma ./prisma
 COPY prisma.config.ts ./
-RUN npm ci
+RUN npm install -g "$(node -p 'require("./package.json").packageManager')" \
+  && npm --version
+RUN npm ci --ignore-scripts
+RUN npx prisma generate
 
 # Copy full source for containerized CI runs.
 COPY . .
diff --git a/docs/notification-center-plan.md b/docs/notification-center-plan.md
new file mode 100644
index 00000000..1ad88681
--- /dev/null
+++ b/docs/notification-center-plan.md
@@ -0,0 +1,446 @@
+# Notification Center Implementation Plan
+
+## Goal
+
+Build a reusable notification center that can send email notifications when a wallet signer needs to act, starting with "signature required" notifications for pending multisig transactions and signable datum payloads.
+
+The first channel will be email via Resend. A signer only receives email if they have provided and verified an email address, so notification delivery is opt-in and does not block wallet or transaction creation.
+
+## Current Codebase Context
+
+- Wallet signer data is currently stored as parallel arrays on `Wallet` and `NewWallet` in `prisma/schema.prisma`: `signersAddresses`, `signersStakeKeys`, `signersDRepKeys`, and `signersDescriptions`.
+- User records in `User` are keyed by wallet `address` and currently include `stakeAddress`, `drepKeyHash`, optional `nostrKey`, and `discordId`, but no email field.
+- Pending transaction creation happens in multiple places:
+  - `src/hooks/useTransaction.ts` for in-app transaction creation.
+  - `src/server/api/routers/transactions.ts` for tRPC create/import.
+  - `src/lib/server/createPendingMultisigTransaction.ts` for server/API/bot/proxy transaction builders.
+  - `src/pages/api/v1/addTransaction.ts` for external transaction submission.
+- Pending datum/signable creation happens through:
+  - `src/server/api/routers/signable.ts`.
+  - `src/pages/api/v1/submitDatum.ts`.
+- Existing reminders are Discord-only and client-triggered:
+  - `src/components/pages/wallet/transactions/transaction-card.tsx`.
+  - `src/components/pages/wallet/signing/signable-card.tsx`.
+  - `src/components/pages/wallet/new-transaction/index.tsx`.
+- Existing observability uses append-only `AuditLog`; notification delivery should follow the same audit-friendly posture.
+
+## Design Principles
+
+- Reusable first: notification orchestration should not know about Resend directly.
+- Server-owned delivery: do not send transactional notifications from React components.
+- Non-blocking: transaction/signable creation should succeed even if notification dispatch fails.
+- Idempotent: one event-recipient-channel combination should not send duplicate emails.
+- Consent-aware: only verified or explicit opt-in email addresses receive messages.
+- Email-client realistic: HTML emails should include a plain text fallback and avoid decorative assets in the first version.
+
+## Phase 1: Email Identity and Preferences
+
+### Data model
+
+Add signer notification metadata without adding more parallel arrays to `Wallet`.
+
+Recommended Prisma models:
+
+```prisma
+model SignerNotificationProfile {
+  id              String    @id @default(cuid())
+  address         String    @unique
+  email           String?
+  emailNormalized String?
+  emailVerifiedAt DateTime?
+  emailOptIn      Boolean   @default(true)
+  createdAt       DateTime  @default(now())
+  updatedAt       DateTime  @updatedAt
+
+  @@index([emailNormalized])
+}
+
+model NotificationPreference {
+  id          String   @id @default(cuid())
+  address     String
+  eventType   String
+  channel     String
+  enabled     Boolean  @default(true)
+  createdAt   DateTime @default(now())
+  updatedAt   DateTime @updatedAt
+
+  @@unique([address, eventType, channel])
+  @@index([address])
+}
+```
+
+Optional later model if wallet-specific routing is needed:
+
+```prisma
+model WalletSignerNotificationSetting {
+  walletId      String
+  signerAddress String
+  eventType     String
+  channel       String
+  enabled       Boolean @default(true)
+
+  @@id([walletId, signerAddress, eventType, channel])
+  @@index([signerAddress])
+  @@index([walletId])
+}
+```
+
+Why not add `signersEmails String[]`:
+
+- The existing signer arrays already need index alignment. Adding another parallel array would make wallet updates and imports more fragile.
+- Email belongs to a signer identity and can be reused across wallets.
+- Verification, opt-in, and unsubscribe state do not belong in `Wallet`.
+
+### User model relationship
+
+Do not rely only on `User.email`.
+
+`User` is only present for onboarded wallet users. Some signers can exist in wallet arrays before they have joined or created a user record. `SignerNotificationProfile` lets the notification center resolve email by signer address even before a full `User` profile exists.
+
+If desired, add `email` and `emailVerifiedAt` to `User` too, but treat `SignerNotificationProfile` as the delivery source of truth and keep it synchronized when the current user changes email.
+
+### Email verification
+
+Add a simple verification token model:
+
+```prisma
+model EmailVerificationToken {
+  id            String    @id @default(cuid())
+  address       String
+  emailNormalized String
+  tokenHash     String    @unique
+  expiresAt     DateTime
+  consumedAt    DateTime?
+  createdAt     DateTime  @default(now())
+
+  @@index([address])
+  @@index([expiresAt])
+}
+```
+
+Flow:
+
+1. Signer enters an email in their user/profile page or during invite acceptance.
+2. Server validates and normalizes it.
+3. Server stores a pending token hash and sends a verification email.
+4. Clicking `/api/notifications/email/verify?token=...` sets `emailVerifiedAt`.
+5. Only verified emails are eligible for signature-required notifications.
+
+## Phase 2: Notification Outbox
+
+Add an outbox so notification creation and notification delivery are separate concerns.
+
+Recommended Prisma model:
+
+```prisma
+model NotificationDelivery {
+  id             String    @id @default(cuid())
+  eventType      String
+  channel        String
+  recipientAddress String
+  recipientEmail String?
+  resourceType   String
+  resourceId     String
+  walletId       String?
+  idempotencyKey String    @unique
+  subject        String
+  payload        Json
+  status         String    @default("pending")
+  provider       String?
+  providerMessageId String?
+  attempts       Int       @default(0)
+  lastError      String?
+  nextAttemptAt  DateTime  @default(now())
+  sentAt         DateTime?
+  createdAt      DateTime  @default(now())
+  updatedAt      DateTime  @updatedAt
+
+  @@index([status, nextAttemptAt])
+  @@index([recipientAddress])
+  @@index([walletId])
+  @@index([resourceType, resourceId])
+}
+```
+
+Postgres notes:
+
+- Keep `idempotencyKey` unique so retries and concurrent trigger paths cannot duplicate sends.
+- Index `status, nextAttemptAt` because the worker/drain endpoint will repeatedly query pending rows.
+- Index recipient, wallet, and resource columns because the notification center UI will filter by those fields.
+- Consider a partial index for pending rows in a SQL migration if Prisma does not express the exact desired index well:
+
+```sql
+create index "NotificationDelivery_pending_idx"
+on "NotificationDelivery" ("nextAttemptAt", "createdAt")
+where "status" in ('pending', 'retrying');
+```
+
+## Phase 3: Notification Library Layout
+
+Create a reusable module under `src/lib/notifications/`.
+
+Recommended structure:
+
+```text
+src/lib/notifications/
+  center.ts
+  events.ts
+  recipients.ts
+  outbox.ts
+  templates/
+    shared.ts
+    signatureRequired.ts
+    verifyEmail.ts
+  channels/
+    email/
+      resend.ts
+      types.ts
+  worker.ts
+```
+
+Responsibilities:
+
+- `events.ts`: event names, payload types, and resource metadata.
+- `recipients.ts`: resolve signer addresses to verified email profiles and preferences.
+- `outbox.ts`: create idempotent `NotificationDelivery` rows.
+- `center.ts`: public API used by wallet, transaction, signable, and future features.
+- `templates/*`: pure functions that return `{ subject, html, text }`.
+- `channels/email/resend.ts`: the only place that imports the Resend SDK.
+- `worker.ts`: drains pending deliveries, handles retry/backoff, and records provider responses.
+
+Public API sketch:
+
+```ts
+await notificationCenter.enqueueSignatureRequired({
+  walletId,
+  walletName,
+  resourceType: "transaction",
+  resourceId: transaction.id,
+  requiredSignerAddresses,
+  alreadySignedAddresses,
+  createdByAddress,
+  actionUrl,
+  description,
+});
+```
+
+The reusable lower-level API should support future features:
+
+```ts
+await notificationCenter.enqueue({
+  eventType: "signature.required",
+  channel: "email",
+  recipientAddress,
+  resourceType,
+  resourceId,
+  walletId,
+  payload,
+});
+```
+
+## Phase 4: Resend Integration
+
+Install:
+
+```bash
+npm install resend
+```
+
+Add server env vars in `src/env.js` and `.env.example`:
+
+```text
+RESEND_API_KEY=
+EMAIL_FROM="Mesh Multisig <notifications@your-domain.example>"
+EMAIL_REPLY_TO=
+NOTIFICATION_DRAIN_SECRET=
+```
+
+Implementation details:
+
+- Use `new Resend(env.RESEND_API_KEY)` inside `src/lib/notifications/channels/email/resend.ts`.
+- Send with `from`, `to`, `subject`, `html`, and `text`.
+- Store Resend's returned message id on `NotificationDelivery.providerMessageId`.
+- Use outbox-level idempotency before provider calls. If the Resend SDK supports passing an HTTP idempotency header in the current version at implementation time, also pass the delivery idempotency key to Resend.
+- Tag messages when possible with stable ASCII tags such as `event:signature_required`, `resource:transaction`, and `wallet:<walletId-short>` for provider-side filtering.
+
+## Phase 5: Signature Required Triggering
+
+### Recipient resolver
+
+For each wallet action, compute:
+
+```ts
+requiredSignerAddresses =
+  wallet.signersAddresses
+    .filter((address) => !signedAddresses.includes(address))
+    .filter((address) => !rejectedAddresses.includes(address))
+    .filter((address) => address !== createdByAddress);
+```
+
+Notes:
+
+- For `type === "any"` or `numRequiredSigners === 1`, there may be no pending notification because the transaction can submit immediately.
+- For `atLeast`, notify unsigned signers until the threshold is met. After threshold completion and submission, do not send further reminders.
+- For `all`, notify every unsigned signer.
+
+### Hook points
+
+Add notification enqueue calls after a pending row is successfully created.
+
+Primary hook points:
+
+- `src/lib/server/createPendingMultisigTransaction.ts`: notify for server-built pending transactions used by bot, proxy, staking, governance, and v1 flows.
+- `src/server/api/routers/transactions.ts`: notify for tRPC-created and imported pending transactions. Longer term, consider routing all creation through the server helper so this is not duplicated.
+- `src/pages/api/v1/addTransaction.ts`: if it does not route through the helper in every pending path, add notification enqueue after DB create.
+- `src/server/api/routers/signable.ts`: notify for `createSignable` when `state === 0`.
+- `src/pages/api/v1/submitDatum.ts`: notify for API-created `Signable` rows.
+
+Avoid adding new email logic to:
+
+- `src/components/pages/wallet/new-transaction/index.tsx`
+- `src/components/pages/wallet/transactions/transaction-card.tsx`
+- `src/components/pages/wallet/signing/signable-card.tsx`
+
+Those should eventually call a server "send reminder" mutation or endpoint if manual reminders remain.
+
+## Phase 6: Notification Center UI
+
+Add a notification/preferences section to `src/pages/user/index.tsx`.
+
+Minimum UI:
+
+- Email address field.
+- Verification status.
+- "Send verification email" action.
+- Channel preferences:
+  - Signature required for transactions.
+  - Signature required for datum/signable payloads.
+- Opt out action.
+
+Add a wallet-level notification center later under wallet info if needed:
+
+- Show which signers have email enabled without revealing full emails to other signers.
+- Show delivery status for recent notifications:
+  - pending
+  - sent
+  - retrying
+  - failed
+  - skipped-no-email
+  - skipped-not-verified
+  - skipped-opted-out
+
+## Phase 7: Email Template Design
+
+Use HTML emails with table-safe layout and inline styles.
+
+Template requirements:
+
+- `subject`: clear and action-oriented, for example `Signature required: <wallet name>`.
+- `text`: plain text fallback with wallet name, action link, and why the user is receiving it.
+- `html`: branded transactional email with:
+  - wallet name
+  - resource type
+  - transaction/signable description if present
+  - signer progress, for example `1 of 3 signatures collected`
+  - CTA button to open `/wallets/<walletId>/transactions` or `/wallets/<walletId>/signing`
+  - unsubscribe/preferences link
+
+Keep the first version simple:
+
+- Use HTML and inline CSS only.
+- Do not include animated SVGs or embedded SVG markup.
+- Do not include JavaScript or external decorative assets.
+- Keep all critical CTA content as readable HTML text/buttons.
+- Test in Gmail, Apple Mail, and Outlook before production rollout.
+
+Suggested template files:
+
+```text
+src/lib/notifications/templates/signatureRequired.ts
+src/lib/notifications/templates/verifyEmail.ts
+src/lib/notifications/templates/shared.ts
+```
+
+## Phase 8: Delivery Worker
+
+Start simple:
+
+- After enqueueing notifications, call a best-effort `drainNotificationOutbox({ limit: 10 })` server-side.
+- Add `src/pages/api/notifications/drain.ts` protected by `NOTIFICATION_DRAIN_SECRET`.
+- Configure a scheduled job later to call the drain endpoint every few minutes.
+
+Retry behavior:
+
+- Attempt 1 immediately.
+- Retry after 5 minutes, 30 minutes, then 2 hours.
+- Mark `failed` after a small max attempt count, for example 5.
+- Store short error strings only; do not store provider secrets or full request bodies.
+
+## Phase 9: Manual Reminders
+
+Replace Discord-only client reminders with a server endpoint/mutation:
+
+```ts
+api.notification.sendSignatureReminder.useMutation(...)
+```
+
+Rules:
+
+- Caller must be a wallet signer or owner.
+- Recipient must be a wallet signer.
+- Recipient must still need to sign.
+- Apply rate limits per `walletId + resourceId + recipientAddress`.
+- Enqueue `signature.reminder` using the same channel/template stack.
+
+Keep Discord as optional later channel if desired, but route it through the same notification center rather than calling `sendDiscordMessage` directly from components.
+
+## Phase 10: Testing
+
+Unit tests:
+
+- recipient resolution excludes already signed, rejected, and creator addresses.
+- unverified email is skipped.
+- opted-out signer is skipped.
+- idempotency key prevents duplicate delivery rows.
+- email templates escape dynamic values and include text fallback.
+
+Integration tests:
+
+- pending tRPC transaction creates notification deliveries.
+- server-built pending transaction through `createPendingMultisigTransaction` creates notification deliveries.
+- `submitDatum` creates signable notification deliveries.
+- drain worker calls the Resend adapter once per pending delivery and records message ids.
+- Resend failure moves row to retrying without breaking transaction creation.
+
+Manual QA:
+
+- Create a 2-of-3 wallet with one signer email verified and one missing email.
+- Create a pending transaction.
+- Confirm one email delivery and one skipped/no-email outcome.
+- Sign with another signer until threshold is met.
+- Confirm no more signature-required notifications are created.
+- Open the email in Gmail, Apple Mail, and Outlook.
+
+## Phase 11: Rollout
+
+1. Add schema and env validation.
+2. Add profile/preference UI and email verification.
+3. Add outbox and Resend adapter behind feature flag `NOTIFICATIONS_EMAIL_ENABLED`.
+4. Add transaction/signable enqueue hooks.
+5. Enable drain endpoint in staging.
+6. Send test notifications from staging domain.
+7. Enable production for verified internal/test signers.
+8. Remove or migrate client-side Discord reminder calls after email path is stable.
+
+## Open Questions
+
+- Should wallet creators be allowed to enter another signer's email, or should emails only be entered and verified by the signer themselves?
+- Should emails be global per signer address or configurable per wallet?
+- Should notification history be visible to all wallet signers or only to the recipient/current user?
+- What production sending domain should be verified in Resend?
+- Should Discord remain as a supported channel after email launches?
+
+## External References
+
+- Resend Node.js quickstart: https://resend.com/docs/send-with-nodejs
+- Resend Send Email API: https://resend.com/docs/api-reference/emails/send-email
diff --git a/package-lock.json b/package-lock.json
index 002958a7..c5a59011 100644
--- a/package-lock.json
+++ b/package-lock.json
@@ -63,6 +63,7 @@
         "react-dropzone": "^14.3.5",
         "react-markdown": "^10.1.0",
         "remark-gfm": "^4.0.1",
+        "resend": "^6.12.4",
         "superjson": "^2.2.1",
         "swagger-jsdoc": "^6.2.8",
         "swagger-ui-react": "^5.22.0",
@@ -6775,6 +6776,12 @@
         "@sinonjs/commons": "^3.0.1"
       }
     },
+    "node_modules/@stablelib/base64": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/@stablelib/base64/-/base64-1.0.1.tgz",
+      "integrity": "sha512-1bnPQqSxSuc3Ii6MhBysoWCg58j97aUjuCSZrGSmDxNqtytIi0k8utUenAwTZN4V5mXXYGsVUI9zeBqy+jBOSQ==",
+      "license": "MIT"
+    },
     "node_modules/@standard-schema/spec": {
       "version": "1.1.0",
       "resolved": "https://registry.npmjs.org/@standard-schema/spec/-/spec-1.1.0.tgz",
@@ -12420,6 +12427,12 @@
       "dev": true,
       "license": "MIT"
     },
+    "node_modules/fast-sha256": {
+      "version": "1.3.0",
+      "resolved": "https://registry.npmjs.org/fast-sha256/-/fast-sha256-1.3.0.tgz",
+      "integrity": "sha512-n11RGP/lrWEFI/bWdygLxhI+pVeo1ZYIVwvvPkW7azl/rOy+F3HYRZ2K5zeE9mmkhQppyv9sQFx0JM9UabnpPQ==",
+      "license": "Unlicense"
+    },
     "node_modules/fast-uri": {
       "version": "3.1.2",
       "resolved": "https://registry.npmjs.org/fast-uri/-/fast-uri-3.1.2.tgz",
@@ -19634,6 +19647,12 @@
         "node": ">= 0.4"
       }
     },
+    "node_modules/postal-mime": {
+      "version": "2.7.4",
+      "resolved": "https://registry.npmjs.org/postal-mime/-/postal-mime-2.7.4.tgz",
+      "integrity": "sha512-0WdnFQYUrPGGTFu1uOqD2s7omwua8xaeYGdO6rb88oD5yJ/4pPHDA4sdWqfD8wQVfCny563n/HQS7zTFft+f/g==",
+      "license": "MIT-0"
+    },
     "node_modules/postcss": {
       "version": "8.5.15",
       "resolved": "https://registry.npmjs.org/postcss/-/postcss-8.5.15.tgz",
@@ -20896,6 +20915,27 @@
       "integrity": "sha512-AgZ3UOZm3YndfrJ4OYjgrT7bmCm/1iqkjvEfH/oYjzh6PD2qw4QuT3jjnXIrpdt4MTpMXclMT3lXbmRY+XRakw==",
       "license": "MIT"
     },
+    "node_modules/resend": {
+      "version": "6.12.4",
+      "resolved": "https://registry.npmjs.org/resend/-/resend-6.12.4.tgz",
+      "integrity": "sha512-lRpJ2Hxd+ht+JPDm97juRcUp9HOMuZyxaRFRFmc9Tx8iNWiei94Dx9v6SWufgKk2667C/uCeKKspMotOHSpCSg==",
+      "license": "MIT",
+      "dependencies": {
+        "postal-mime": "2.7.4",
+        "standardwebhooks": "1.0.0"
+      },
+      "engines": {
+        "node": ">=20"
+      },
+      "peerDependencies": {
+        "@react-email/render": "*"
+      },
+      "peerDependenciesMeta": {
+        "@react-email/render": {
+          "optional": true
+        }
+      }
+    },
     "node_modules/resolve": {
       "version": "2.0.0-next.7",
       "resolved": "https://registry.npmjs.org/resolve/-/resolve-2.0.0-next.7.tgz",
@@ -21563,6 +21603,16 @@
         "node": ">=8"
       }
     },
+    "node_modules/standardwebhooks": {
+      "version": "1.0.0",
+      "resolved": "https://registry.npmjs.org/standardwebhooks/-/standardwebhooks-1.0.0.tgz",
+      "integrity": "sha512-BbHGOQK9olHPMvQNHWul6MYlrRTAOKn03rOe4A8O3CLWhNf4YHBqq2HJKKC+sfqpxiBY52pNeesD6jIiLDz8jg==",
+      "license": "MIT",
+      "dependencies": {
+        "@stablelib/base64": "^1.0.0",
+        "fast-sha256": "^1.3.0"
+      }
+    },
     "node_modules/stats-gl": {
       "version": "2.4.2",
       "resolved": "https://registry.npmjs.org/stats-gl/-/stats-gl-2.4.2.tgz",
diff --git a/package.json b/package.json
index c2c0c07c..808a7d37 100644
--- a/package.json
+++ b/package.json
@@ -87,6 +87,7 @@
     "react-dropzone": "^14.3.5",
     "react-markdown": "^10.1.0",
     "remark-gfm": "^4.0.1",
+    "resend": "^6.12.4",
     "superjson": "^2.2.1",
     "swagger-jsdoc": "^6.2.8",
     "swagger-ui-react": "^5.22.0",
diff --git a/prisma/migrations/20260617070000_add_notification_center/migration.sql b/prisma/migrations/20260617070000_add_notification_center/migration.sql
new file mode 100644
index 00000000..9b7fb7f0
--- /dev/null
+++ b/prisma/migrations/20260617070000_add_notification_center/migration.sql
@@ -0,0 +1,97 @@
+-- CreateTable
+CREATE TABLE "WalletSignerNotificationSetting" (
+    "id" TEXT NOT NULL,
+    "walletId" TEXT NOT NULL,
+    "signerAddress" TEXT NOT NULL,
+    "email" TEXT,
+    "emailNormalized" TEXT,
+    "emailVerifiedAt" TIMESTAMP(3),
+    "emailOptIn" BOOLEAN NOT NULL DEFAULT true,
+    "notifyTransactionSignatures" BOOLEAN NOT NULL DEFAULT true,
+    "notifySignableSignatures" BOOLEAN NOT NULL DEFAULT true,
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+
+    CONSTRAINT "WalletSignerNotificationSetting_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "EmailVerificationToken" (
+    "id" TEXT NOT NULL,
+    "walletId" TEXT NOT NULL,
+    "signerAddress" TEXT NOT NULL,
+    "emailNormalized" TEXT NOT NULL,
+    "tokenHash" TEXT NOT NULL,
+    "expiresAt" TIMESTAMP(3) NOT NULL,
+    "consumedAt" TIMESTAMP(3),
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+
+    CONSTRAINT "EmailVerificationToken_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateTable
+CREATE TABLE "NotificationDelivery" (
+    "id" TEXT NOT NULL,
+    "eventType" TEXT NOT NULL,
+    "channel" TEXT NOT NULL,
+    "recipientAddress" TEXT NOT NULL,
+    "recipientEmail" TEXT,
+    "resourceType" TEXT NOT NULL,
+    "resourceId" TEXT NOT NULL,
+    "walletId" TEXT,
+    "idempotencyKey" TEXT NOT NULL,
+    "subject" TEXT NOT NULL,
+    "payload" JSONB NOT NULL,
+    "status" TEXT NOT NULL DEFAULT 'pending',
+    "provider" TEXT,
+    "providerMessageId" TEXT,
+    "attempts" INTEGER NOT NULL DEFAULT 0,
+    "lastError" TEXT,
+    "nextAttemptAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "sentAt" TIMESTAMP(3),
+    "createdAt" TIMESTAMP(3) NOT NULL DEFAULT CURRENT_TIMESTAMP,
+    "updatedAt" TIMESTAMP(3) NOT NULL,
+
+    CONSTRAINT "NotificationDelivery_pkey" PRIMARY KEY ("id")
+);
+
+-- CreateIndex
+CREATE UNIQUE INDEX "WalletSignerNotificationSetting_walletId_signerAddress_key" ON "WalletSignerNotificationSetting"("walletId", "signerAddress");
+
+-- CreateIndex
+CREATE INDEX "WalletSignerNotificationSetting_walletId_idx" ON "WalletSignerNotificationSetting"("walletId");
+
+-- CreateIndex
+CREATE INDEX "WalletSignerNotificationSetting_signerAddress_idx" ON "WalletSignerNotificationSetting"("signerAddress");
+
+-- CreateIndex
+CREATE INDEX "WalletSignerNotificationSetting_emailNormalized_idx" ON "WalletSignerNotificationSetting"("emailNormalized");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "EmailVerificationToken_tokenHash_key" ON "EmailVerificationToken"("tokenHash");
+
+-- CreateIndex
+CREATE INDEX "EmailVerificationToken_walletId_signerAddress_idx" ON "EmailVerificationToken"("walletId", "signerAddress");
+
+-- CreateIndex
+CREATE INDEX "EmailVerificationToken_expiresAt_idx" ON "EmailVerificationToken"("expiresAt");
+
+-- CreateIndex
+CREATE UNIQUE INDEX "NotificationDelivery_idempotencyKey_key" ON "NotificationDelivery"("idempotencyKey");
+
+-- CreateIndex
+CREATE INDEX "NotificationDelivery_status_nextAttemptAt_idx" ON "NotificationDelivery"("status", "nextAttemptAt");
+
+-- CreateIndex
+CREATE INDEX "NotificationDelivery_recipientAddress_idx" ON "NotificationDelivery"("recipientAddress");
+
+-- CreateIndex
+CREATE INDEX "NotificationDelivery_walletId_idx" ON "NotificationDelivery"("walletId");
+
+-- CreateIndex
+CREATE INDEX "NotificationDelivery_resourceType_resourceId_idx" ON "NotificationDelivery"("resourceType", "resourceId");
+
+-- CreateIndex
+CREATE INDEX "NotificationDelivery_pending_idx"
+ON "NotificationDelivery" ("nextAttemptAt", "createdAt")
+WHERE "status" IN ('pending', 'retrying');
diff --git a/prisma/schema.prisma b/prisma/schema.prisma
index f753e5b2..5bbc49bf 100644
--- a/prisma/schema.prisma
+++ b/prisma/schema.prisma
@@ -211,6 +211,67 @@ model Contact {
   @@index([address])
 }
 
+model WalletSignerNotificationSetting {
+  id                          String    @id @default(cuid())
+  walletId                    String
+  signerAddress               String
+  email                       String?
+  emailNormalized             String?
+  emailVerifiedAt             DateTime?
+  emailOptIn                  Boolean   @default(true)
+  notifyTransactionSignatures Boolean   @default(true)
+  notifySignableSignatures    Boolean   @default(true)
+  createdAt                   DateTime  @default(now())
+  updatedAt                   DateTime  @updatedAt
+
+  @@unique([walletId, signerAddress])
+  @@index([walletId])
+  @@index([signerAddress])
+  @@index([emailNormalized])
+}
+
+model EmailVerificationToken {
+  id              String    @id @default(cuid())
+  walletId        String
+  signerAddress   String
+  emailNormalized String
+  tokenHash       String    @unique
+  expiresAt       DateTime
+  consumedAt      DateTime?
+  createdAt       DateTime  @default(now())
+
+  @@index([walletId, signerAddress])
+  @@index([expiresAt])
+}
+
+model NotificationDelivery {
+  id                 String    @id @default(cuid())
+  eventType          String
+  channel            String
+  recipientAddress   String
+  recipientEmail     String?
+  resourceType       String
+  resourceId         String
+  walletId           String?
+  idempotencyKey     String    @unique
+  subject            String
+  payload            Json
+  status             String    @default("pending")
+  provider           String?
+  providerMessageId  String?
+  attempts           Int       @default(0)
+  lastError          String?
+  nextAttemptAt      DateTime  @default(now())
+  sentAt             DateTime?
+  createdAt          DateTime  @default(now())
+  updatedAt          DateTime  @updatedAt
+
+  @@index([status, nextAttemptAt])
+  @@index([recipientAddress])
+  @@index([walletId])
+  @@index([resourceType, resourceId])
+}
+
 model BotKey {
   id           String   @id @default(cuid())
   ownerAddress String // Human creator
diff --git a/src/__tests__/notifications.test.ts b/src/__tests__/notifications.test.ts
new file mode 100644
index 00000000..ac8803ef
--- /dev/null
+++ b/src/__tests__/notifications.test.ts
@@ -0,0 +1,125 @@
+import { describe, expect, it, jest } from "@jest/globals";
+
+import {
+  NOTIFICATION_STATUS_SKIPPED_DISABLED,
+  NOTIFICATION_STATUS_SKIPPED_NO_EMAIL,
+  NOTIFICATION_STATUS_SKIPPED_NOT_VERIFIED,
+  NOTIFICATION_STATUS_SKIPPED_OPTED_OUT,
+} from "@/lib/notifications/events";
+import { resolveSignatureRecipients } from "@/lib/notifications/recipients";
+import { renderSignatureRequiredEmail } from "@/lib/notifications/templates/signatureRequired";
+
+describe("notification recipient resolution", () => {
+  it("returns only verified opted-in signers that still need to sign", async () => {
+    const db = {
+      walletSignerNotificationSetting: {
+        findMany: jest.fn(async () => [
+          {
+            signerAddress: "addr_verified",
+            email: "Signer@Example.com",
+            emailNormalized: "signer@example.com",
+            emailVerifiedAt: new Date(),
+            emailOptIn: true,
+            notifyTransactionSignatures: true,
+            notifySignableSignatures: true,
+          },
+          {
+            signerAddress: "addr_unverified",
+            email: "unverified@example.com",
+            emailNormalized: "unverified@example.com",
+            emailVerifiedAt: null,
+            emailOptIn: true,
+            notifyTransactionSignatures: true,
+            notifySignableSignatures: true,
+          },
+          {
+            signerAddress: "addr_opted_out",
+            email: "out@example.com",
+            emailNormalized: "out@example.com",
+            emailVerifiedAt: new Date(),
+            emailOptIn: false,
+            notifyTransactionSignatures: true,
+            notifySignableSignatures: true,
+          },
+          {
+            signerAddress: "addr_disabled",
+            email: "disabled@example.com",
+            emailNormalized: "disabled@example.com",
+            emailVerifiedAt: new Date(),
+            emailOptIn: true,
+            notifyTransactionSignatures: false,
+            notifySignableSignatures: true,
+          },
+        ]),
+      },
+    };
+
+    const result = await resolveSignatureRecipients(db as any, {
+      walletId: "wallet_1",
+      signerAddresses: [
+        "addr_creator",
+        "addr_signed",
+        "addr_rejected",
+        "addr_verified",
+        "addr_unverified",
+        "addr_opted_out",
+        "addr_disabled",
+        "addr_missing",
+      ],
+      resourceType: "transaction",
+      signedAddresses: ["addr_signed"],
+      rejectedAddresses: ["addr_rejected"],
+      creatorAddress: "addr_creator",
+    });
+
+    expect(result.eligible).toEqual([
+      {
+        address: "addr_verified",
+        email: "Signer@Example.com",
+        emailNormalized: "signer@example.com",
+      },
+    ]);
+    expect(result.skipped).toEqual(
+      expect.arrayContaining([
+        {
+          address: "addr_unverified",
+          reason: NOTIFICATION_STATUS_SKIPPED_NOT_VERIFIED,
+        },
+        {
+          address: "addr_opted_out",
+          reason: NOTIFICATION_STATUS_SKIPPED_OPTED_OUT,
+        },
+        {
+          address: "addr_disabled",
+          reason: NOTIFICATION_STATUS_SKIPPED_DISABLED,
+        },
+        {
+          address: "addr_missing",
+          reason: NOTIFICATION_STATUS_SKIPPED_NO_EMAIL,
+        },
+      ]),
+    );
+  });
+});
+
+describe("notification email templates", () => {
+  it("escapes dynamic values and returns html plus text bodies", () => {
+    const email = renderSignatureRequiredEmail({
+      walletName: "<Vault>",
+      resourceType: "transaction",
+      description: "<script>alert('x')</script>",
+      signedCount: 1,
+      requiredCount: 2,
+      totalSigners: 3,
+      actionUrl: "https://example.com/sign?x=<bad>",
+      preferencesUrl: "https://example.com/preferences",
+    });
+
+    expect(email.subject).toBe("Signature required: <Vault>");
+    expect(email.html).toContain("&lt;Vault&gt;");
+    expect(email.html).toContain("&lt;script&gt;alert(&#39;x&#39;)&lt;/script&gt;");
+    expect(email.html).not.toContain("<script>alert");
+    expect(email.text).toContain("A transaction in <Vault> is waiting");
+    expect(email.text).toContain("Review and sign:");
+  });
+});
diff --git a/src/components/pages/wallet/info/index.tsx b/src/components/pages/wallet/info/index.tsx
index 6a499c07..27e8ec9f 100644
--- a/src/components/pages/wallet/info/index.tsx
+++ b/src/components/pages/wallet/info/index.tsx
@@ -10,6 +10,7 @@ import { UpgradeStakingWallet } from "./upgrade-staking-wallet";
 import ProxyControlCard from "./proxy-control";
 import { UpgradeGovernanceWallet } from "./upgrade-governance-wallet";
 import WalletDetailSkeleton from "@/components/pages/wallet/wallet-detail-skeleton";
+import { WalletNotificationSettings } from "./wallet-notification-settings";
 
 export default function WalletInfo() {
   const { appWallet } = useAppWallet();
@@ -22,6 +23,7 @@ export default function WalletInfo() {
       <div className="grid grid-cols-1 gap-4 sm:gap-6">
         <CardInfo appWallet={appWallet} />
         <CardSigners appWallet={appWallet} />
+        <WalletNotificationSettings appWallet={appWallet} />
         <ManageContacts appWallet={appWallet} />
         <MigrateWallet appWallet={appWallet} />
         <ProxyControlCard />
diff --git a/src/components/pages/wallet/info/wallet-notification-settings.tsx b/src/components/pages/wallet/info/wallet-notification-settings.tsx
new file mode 100644
index 00000000..fb8a0d7c
--- /dev/null
+++ b/src/components/pages/wallet/info/wallet-notification-settings.tsx
@@ -0,0 +1,376 @@
+import { useEffect, useMemo, useState } from "react";
+import { useAddress } from "@meshsdk/react";
+import { Mail, Send, Save } from "lucide-react";
+
+import CardUI from "@/components/ui/card-content";
+import { Input } from "@/components/ui/input";
+import { Label } from "@/components/ui/label";
+import { Button } from "@/components/ui/button";
+import { Switch } from "@/components/ui/switch";
+import { Alert, AlertDescription } from "@/components/ui/alert";
+import { Badge } from "@/components/ui/badge";
+import { api } from "@/utils/api";
+import { useToast } from "@/hooks/use-toast";
+import { useUserStore } from "@/lib/zustand/user";
+import { normalizeAddressToBech32 } from "@/utils/addressCompatibility";
+import type { Wallet } from "@/types/wallet";
+
+function addressesEqual(a: string, b: string): boolean {
+  return normalizeAddressToBech32(a) === normalizeAddressToBech32(b);
+}
+
+export function WalletNotificationSettings({
+  appWallet,
+}: {
+  appWallet: Wallet;
+}) {
+  const rawAddress = useAddress();
+  const storeAddress = useUserStore((state) => state.userAddress);
+  const connectedAddress = useMemo(() => {
+    const hookAddress = rawAddress ? normalizeAddressToBech32(rawAddress) : "";
+    const persistedAddress = storeAddress
+      ? normalizeAddressToBech32(storeAddress)
+      : "";
+    return hookAddress || persistedAddress;
+  }, [rawAddress, storeAddress]);
+  const signerScope = connectedAddress
+    ? `${appWallet.id}:${connectedAddress}`
+    : "";
+
+  const isSigner = useMemo(
+    () =>
+      Boolean(
+        connectedAddress &&
+          appWallet.signersAddresses.some((address) =>
+            addressesEqual(address, connectedAddress),
+          ),
+      ),
+    [appWallet.signersAddresses, connectedAddress],
+  );
+
+  const { data: walletSession } = api.auth.getWalletSession.useQuery(
+    { address: connectedAddress },
+    { enabled: connectedAddress.length > 0, refetchOnWindowFocus: false },
+  );
+  const isSessionAuthorized = useMemo(
+    () =>
+      (walletSession?.wallets ?? []).some((wallet) =>
+        addressesEqual(wallet, connectedAddress),
+      ),
+    [walletSession?.wallets, connectedAddress],
+  );
+
+  const { toast } = useToast();
+  const utils = api.useUtils();
+  const {
+    data: setting,
+    isLoading,
+    isFetching,
+    isSuccess,
+    isError,
+    fetchStatus,
+  } = api.notification.getWalletSignerSetting.useQuery(
+    { walletId: appWallet.id, signerAddress: connectedAddress },
+    {
+      enabled: isSigner && connectedAddress.length > 0,
+      staleTime: 0,
+      refetchOnMount: "always",
+      retry: (failureCount, error) => {
+        if (
+          error &&
+          typeof error === "object" &&
+          ("data" in error
+            ? (error as { data?: { httpStatus?: number } }).data?.httpStatus ===
+              403
+            : false)
+        ) {
+          return false;
+        }
+        return failureCount < 1;
+      },
+    },
+  );
+
+  const settingMatchesConnectedSigner =
+    Boolean(setting) &&
+    connectedAddress.length > 0 &&
+    addressesEqual(setting!.signerAddress, connectedAddress);
+
+  const isSettingResolved =
+    isSuccess &&
+    fetchStatus === "idle" &&
+    !isFetching &&
+    settingMatchesConnectedSigner;
+
+  const [email, setEmail] = useState("");
+  const [emailOptIn, setEmailOptIn] = useState(true);
+  const [notifyTransactions, setNotifyTransactions] = useState(true);
+  const [notifySignables, setNotifySignables] = useState(true);
+  const [appliedScope, setAppliedScope] = useState<string | null>(null);
+
+  useEffect(() => {
+    setAppliedScope(null);
+    setEmail("");
+    setEmailOptIn(true);
+    setNotifyTransactions(true);
+    setNotifySignables(true);
+    void utils.notification.getWalletSignerSetting.cancel();
+    void utils.notification.getWalletSignerSetting.reset();
+  }, [signerScope, utils.notification.getWalletSignerSetting]);
+
+  useEffect(() => {
+    if (!isSettingResolved || !setting || !signerScope) return;
+    setAppliedScope(signerScope);
+    setEmail(setting.email ?? "");
+    setEmailOptIn(setting.emailOptIn);
+    setNotifyTransactions(setting.notifyTransactionSignatures);
+    setNotifySignables(setting.notifySignableSignatures);
+  }, [isSettingResolved, setting, signerScope]);
+
+  const canShowSavedSettings = appliedScope === signerScope && isSettingResolved;
+
+  const invalidate = async () => {
+    if (!connectedAddress) return;
+    await utils.notification.getWalletSignerSetting.invalidate({
+      walletId: appWallet.id,
+      signerAddress: connectedAddress,
+    });
+  };
+
+  const { mutate: saveSetting, isPending: saving } =
+    api.notification.upsertWalletSignerSetting.useMutation({
+      onSuccess: async () => {
+        await invalidate();
+        toast({
+          title: "Notification settings saved",
+          description: "Your wallet email preferences have been updated.",
+          duration: 4000,
+        });
+      },
+      onError: (error) => {
+        toast({
+          title: "Unable to save notification settings",
+          description: error.message,
+          variant: "destructive",
+          duration: 6000,
+        });
+      },
+    });
+
+  const { mutate: sendVerification, isPending: sendingVerification } =
+    api.notification.sendVerificationEmail.useMutation({
+      onSuccess: async (result) => {
+        await invalidate();
+        toast({
+          title: result.emailEnabled
+            ? "Verification email queued"
+            : "Verification email prepared",
+          description: result.emailEnabled
+            ? "Check your inbox for the verification link."
+            : "Email delivery is disabled in this environment.",
+          duration: 5000,
+        });
+      },
+      onError: (error) => {
+        toast({
+          title: "Unable to send verification email",
+          description: error.message,
+          variant: "destructive",
+          duration: 6000,
+        });
+      },
+    });
+
+  if (!isSigner) {
+    return null;
+  }
+
+  const needsAuthorization =
+    !isSessionAuthorized || (isError && !isSettingResolved);
+  const isResolvingSettings =
+    connectedAddress.length > 0 &&
+    (isLoading || isFetching || !canShowSavedSettings);
+
+  if (needsAuthorization && !isResolvingSettings) {
+    return (
+      <CardUI
+        title="Email Notifications"
+        description="Manage email alerts for signatures needed from your signer address on this wallet."
+        icon={Mail}
+        cardClassName="col-span-2"
+      >
+        <Alert>
+          <AlertDescription>
+            Authorize your connected wallet before managing notification settings.
+          </AlertDescription>
+        </Alert>
+      </CardUI>
+    );
+  }
+
+  const verified = canShowSavedSettings
+    ? Boolean(setting?.emailVerifiedAt)
+    : false;
+  const savedEmail = canShowSavedSettings ? (setting?.email ?? "") : "";
+  const emailChanged = email.trim() !== savedEmail;
+  const canSendVerification = Boolean(savedEmail) && !emailChanged;
+  const inputEmail = canShowSavedSettings ? email : "";
+
+  const persist = (overrides: Partial<{
+    email: string;
+    emailOptIn: boolean;
+    notifyTransactionSignatures: boolean;
+    notifySignableSignatures: boolean;
+  }> = {}) => {
+    if (!connectedAddress || !canShowSavedSettings) return;
+    saveSetting({
+      walletId: appWallet.id,
+      signerAddress: connectedAddress,
+      email: inputEmail,
+      emailOptIn,
+      notifyTransactionSignatures: notifyTransactions,
+      notifySignableSignatures: notifySignables,
+      ...overrides,
+    });
+  };
+
+  return (
+    <CardUI
+      title="Email Notifications"
+      description="Manage email alerts for signatures needed from your signer address on this wallet."
+      icon={Mail}
+      cardClassName="col-span-2"
+    >
+      <div className="space-y-5">
+        <div className="flex flex-wrap items-center gap-2">
+          <Badge variant={verified ? "default" : "secondary"}>
+            {isResolvingSettings
+              ? "Loading"
+              : verified
+                ? "Verified"
+                : savedEmail
+                  ? "Not verified"
+                  : "No email"}
+          </Badge>
+          {canShowSavedSettings && savedEmail && (
+            <span className="text-sm text-muted-foreground">{savedEmail}</span>
+          )}
+        </div>
+
+        {!verified && savedEmail && !emailChanged && canShowSavedSettings && (
+          <Alert>
+            <AlertDescription>
+              Verify this email before signature-required notifications can be sent.
+            </AlertDescription>
+          </Alert>
+        )}
+
+        {canShowSavedSettings && !savedEmail && (
+          <Alert>
+            <AlertDescription>
+              Add your email address below to receive alerts when this wallet needs your signature.
+            </AlertDescription>
+          </Alert>
+        )}
+
+        <div className="space-y-2">
+          <Label htmlFor="wallet-notification-email">Email address</Label>
+          <div className="flex flex-col gap-2 sm:flex-row">
+            <Input
+              id="wallet-notification-email"
+              type="email"
+              value={inputEmail}
+              disabled={isResolvingSettings || saving}
+              onChange={(event) => setEmail(event.target.value)}
+              placeholder="you@example.com"
+            />
+            <Button
+              type="button"
+              disabled={isResolvingSettings || saving || !canShowSavedSettings}
+              onClick={() => persist()}
+              className="shrink-0"
+            >
+              <Save className="mr-2 h-4 w-4" />
+              Save
+            </Button>
+          </div>
+        </div>
+
+        <div className="space-y-4">
+          <div className="flex items-center justify-between gap-4">
+            <div>
+              <p className="text-sm font-medium">Email notifications</p>
+              <p className="text-xs text-muted-foreground">
+                Master opt-in for this wallet and signer address.
+              </p>
+            </div>
+            <Switch
+              checked={emailOptIn}
+              disabled={isResolvingSettings || saving || !canShowSavedSettings}
+              onCheckedChange={(checked) => {
+                setEmailOptIn(checked);
+                persist({ emailOptIn: checked });
+              }}
+              aria-label="Toggle email notifications"
+            />
+          </div>
+
+          <div className="flex items-center justify-between gap-4">
+            <div>
+              <p className="text-sm font-medium">Transaction signatures</p>
+              <p className="text-xs text-muted-foreground">
+                Email me when a pending transaction needs my signature.
+              </p>
+            </div>
+            <Switch
+              checked={notifyTransactions}
+              disabled={isResolvingSettings || saving || !canShowSavedSettings}
+              onCheckedChange={(checked) => {
+                setNotifyTransactions(checked);
+                persist({ notifyTransactionSignatures: checked });
+              }}
+              aria-label="Toggle transaction signature notifications"
+            />
+          </div>
+
+          <div className="flex items-center justify-between gap-4">
+            <div>
+              <p className="text-sm font-medium">Signable payloads</p>
+              <p className="text-xs text-muted-foreground">
+                Email me when a datum or payload needs my signature.
+              </p>
+            </div>
+            <Switch
+              checked={notifySignables}
+              disabled={isResolvingSettings || saving || !canShowSavedSettings}
+              onCheckedChange={(checked) => {
+                setNotifySignables(checked);
+                persist({ notifySignableSignatures: checked });
+              }}
+              aria-label="Toggle signable payload notifications"
+            />
+          </div>
+        </div>
+
+        <Button
+          type="button"
+          variant="outline"
+          disabled={
+            !canShowSavedSettings ||
+            !canSendVerification ||
+            sendingVerification
+          }
+          onClick={() =>
+            sendVerification({
+              walletId: appWallet.id,
+              signerAddress: connectedAddress,
+            })
+          }
+        >
+          <Send className="mr-2 h-4 w-4" />
+          {sendingVerification ? "Sending..." : "Send verification email"}
+        </Button>
+      </div>
+    </CardUI>
+  );
+}
diff --git a/src/env.js b/src/env.js
index 53e41578..40e94fa1 100644
--- a/src/env.js
+++ b/src/env.js
@@ -33,6 +33,14 @@ export const env = createEnv({
      * "*" to allow any public hostname (still SSRF-guarded against private ranges).
      */
     OG_ALLOWED_HOSTS: z.string().optional(),
+    RESEND_API_KEY: z.string().optional(),
+    EMAIL_FROM: z.string().optional(),
+    EMAIL_REPLY_TO: z.string().email().optional(),
+    NOTIFICATION_LINK_BASE_URL: z.string().url().optional(),
+    NOTIFICATION_DRAIN_SECRET: z.string().optional(),
+    NOTIFICATIONS_EMAIL_ENABLED: z
+      .enum(["true", "false"])
+      .default("false"),
     // NEXTAUTH_SECRET / NEXTAUTH_URL / DISCORD_* are intentionally commented.
     // NextAuth runs with PrismaAdapter only — no auth providers configured yet.
     // Uncomment and add to runtimeEnv below when adding an OAuth provider.
@@ -114,6 +122,13 @@ export const env = createEnv({
     BLOCKFROST_API_KEY_MAINNET: process.env.BLOCKFROST_API_KEY_MAINNET,
     EKKLESIA_API_BASE: process.env.EKKLESIA_API_BASE,
     OG_ALLOWED_HOSTS: process.env.OG_ALLOWED_HOSTS,
+    RESEND_API_KEY: process.env.RESEND_API_KEY,
+    EMAIL_FROM: process.env.EMAIL_FROM,
+    EMAIL_REPLY_TO: process.env.EMAIL_REPLY_TO,
+    NOTIFICATION_LINK_BASE_URL: process.env.NOTIFICATION_LINK_BASE_URL,
+    NOTIFICATION_DRAIN_SECRET: process.env.NOTIFICATION_DRAIN_SECRET,
+    NOTIFICATIONS_EMAIL_ENABLED:
+      process.env.NOTIFICATIONS_EMAIL_ENABLED ?? "false",
   },
   /**
    * Run `build` or `dev` with `SKIP_ENV_VALIDATION` to skip env validation. This is especially
@@ -125,4 +140,4 @@ export const env = createEnv({
    * `SOME_VAR=''` will throw an error.
    */
   emptyStringAsUndefined: true,
-});
\ No newline at end of file
+});
diff --git a/src/lib/notifications/center.ts b/src/lib/notifications/center.ts
new file mode 100644
index 00000000..27b1aa30
--- /dev/null
+++ b/src/lib/notifications/center.ts
@@ -0,0 +1,202 @@
+import type { PrismaClient } from "@prisma/client";
+
+import { env } from "@/env";
+import { SITE_URL } from "@/lib/seo";
+import {
+  NOTIFICATION_EVENT_SIGNATURE_REQUIRED,
+  NOTIFICATION_STATUS_PENDING,
+  type NotificationEventType,
+  type SignatureResourceType,
+} from "./events";
+import { createNotificationDelivery } from "./outbox";
+import { resolveSignatureRecipients } from "./recipients";
+import { renderSignatureRequiredEmail } from "./templates/signatureRequired";
+import { drainNotificationOutbox } from "./worker";
+
+type WalletNotificationShape = {
+  id: string;
+  name: string;
+  signersAddresses: string[];
+  numRequiredSigners: number | null;
+  type: string;
+};
+
+export type EnqueueSignatureRequiredInput = {
+  wallet: WalletNotificationShape;
+  resourceType: SignatureResourceType;
+  resourceId: string;
+  signedAddresses?: string[];
+  rejectedAddresses?: string[];
+  creatorAddress?: string | null;
+  description?: string | null;
+  onlyRecipientAddress?: string | null;
+  eventType?: NotificationEventType;
+};
+
+export function notificationsEmailEnabled(): boolean {
+  return env.NOTIFICATIONS_EMAIL_ENABLED === "true";
+}
+
+export function getSiteUrl(): string {
+  if (env.NOTIFICATION_LINK_BASE_URL) {
+    return env.NOTIFICATION_LINK_BASE_URL.replace(/\/$/, "");
+  }
+
+  if (env.NODE_ENV === "development") {
+    return "http://localhost:3000";
+  }
+
+  // NEXT_PUBLIC_* defaults from env.js are not always present on the server at
+  // runtime; SITE_URL applies the same production fallback as SEO metadata.
+  return SITE_URL;
+}
+
+function getRequiredSignerCount(wallet: WalletNotificationShape): number {
+  if (wallet.type === "any") return 1;
+  if (wallet.type === "all") return wallet.signersAddresses.length;
+  if (typeof wallet.numRequiredSigners === "number") {
+    return wallet.numRequiredSigners;
+  }
+  return wallet.signersAddresses.length;
+}
+
+function actionPathFor(resourceType: SignatureResourceType, walletId: string) {
+  return resourceType === "transaction"
+    ? `/wallets/${walletId}/transactions`
+    : `/wallets/${walletId}/signing`;
+}
+
+function signatureIdempotencyKey(args: {
+  eventType: NotificationEventType;
+  resourceType: SignatureResourceType;
+  resourceId: string;
+  walletId: string;
+  recipientAddress: string;
+}) {
+  return [
+    args.eventType,
+    "email",
+    args.resourceType,
+    args.resourceId,
+    args.walletId,
+    args.recipientAddress,
+  ].join(":");
+}
+
+export async function enqueueSignatureRequiredNotifications(
+  db: PrismaClient,
+  input: EnqueueSignatureRequiredInput,
+) {
+  const signedAddresses = input.signedAddresses ?? [];
+  const rejectedAddresses = input.rejectedAddresses ?? [];
+  const requiredCount = getRequiredSignerCount(input.wallet);
+
+  if (signedAddresses.length >= requiredCount) {
+    return [];
+  }
+
+  const eventType = input.eventType ?? NOTIFICATION_EVENT_SIGNATURE_REQUIRED;
+  const siteUrl = getSiteUrl();
+  const actionUrl = `${siteUrl}${actionPathFor(input.resourceType, input.wallet.id)}`;
+  const preferencesUrl = `${siteUrl}/wallets/${input.wallet.id}/info`;
+  const template = renderSignatureRequiredEmail({
+    walletName: input.wallet.name,
+    resourceType: input.resourceType,
+    description: input.description ?? null,
+    signedCount: signedAddresses.length,
+    requiredCount,
+    totalSigners: input.wallet.signersAddresses.length,
+    actionUrl,
+    preferencesUrl,
+  });
+
+  const recipients = await resolveSignatureRecipients(db, {
+    walletId: input.wallet.id,
+    signerAddresses: input.wallet.signersAddresses,
+    resourceType: input.resourceType,
+    signedAddresses,
+    rejectedAddresses,
+    creatorAddress: input.creatorAddress,
+    onlyRecipientAddress: input.onlyRecipientAddress,
+  });
+
+  const payloadBase = {
+    walletId: input.wallet.id,
+    walletName: input.wallet.name,
+    resourceType: input.resourceType,
+    resourceId: input.resourceId,
+    actionUrl,
+    preferencesUrl,
+    signedCount: signedAddresses.length,
+    requiredCount,
+    totalSigners: input.wallet.signersAddresses.length,
+    description: input.description ?? null,
+  };
+
+  const deliveries = [];
+
+  for (const recipient of recipients.eligible) {
+    deliveries.push(
+      await createNotificationDelivery(db, {
+        eventType,
+        recipientAddress: recipient.address,
+        recipientEmail: recipient.email,
+        resourceType: input.resourceType,
+        resourceId: input.resourceId,
+        walletId: input.wallet.id,
+        idempotencyKey: signatureIdempotencyKey({
+          eventType,
+          resourceType: input.resourceType,
+          resourceId: input.resourceId,
+          walletId: input.wallet.id,
+          recipientAddress: recipient.address,
+        }),
+        subject: template.subject,
+        payload: {
+          ...payloadBase,
+          recipientAddress: recipient.address,
+          html: template.html,
+          text: template.text,
+        },
+        status: NOTIFICATION_STATUS_PENDING,
+      }),
+    );
+  }
+
+  for (const skipped of recipients.skipped) {
+    deliveries.push(
+      await createNotificationDelivery(db, {
+        eventType,
+        recipientAddress: skipped.address,
+        recipientEmail: null,
+        resourceType: input.resourceType,
+        resourceId: input.resourceId,
+        walletId: input.wallet.id,
+        idempotencyKey: signatureIdempotencyKey({
+          eventType,
+          resourceType: input.resourceType,
+          resourceId: input.resourceId,
+          walletId: input.wallet.id,
+          recipientAddress: skipped.address,
+        }),
+        subject: "Signature notification skipped",
+        payload: {
+          ...payloadBase,
+          recipientAddress: skipped.address,
+          skipReason: skipped.reason,
+        },
+        status: skipped.reason,
+      }),
+    );
+  }
+
+  if (notificationsEmailEnabled() && recipients.eligible.length > 0) {
+    try {
+      await drainNotificationOutbox(db, { limit: 10 });
+    } catch (error) {
+      console.error("Notification outbox drain failed", error);
+    }
+  }
+
+  return deliveries;
+}
diff --git a/src/lib/notifications/channels/email/resend.ts b/src/lib/notifications/channels/email/resend.ts
new file mode 100644
index 00000000..e7524001
--- /dev/null
+++ b/src/lib/notifications/channels/email/resend.ts
@@ -0,0 +1,44 @@
+import { Resend } from "resend";
+
+import { env } from "@/env";
+import type { EmailMessage, EmailSendResult } from "./types";
+
+let resendClient: Resend | null = null;
+
+function getResendClient() {
+  if (!env.RESEND_API_KEY) {
+    throw new Error("RESEND_API_KEY is not configured");
+  }
+
+  resendClient ??= new Resend(env.RESEND_API_KEY);
+  return resendClient;
+}
+
+export async function sendEmailViaResend(
+  message: EmailMessage,
+): Promise<EmailSendResult> {
+  if (!env.EMAIL_FROM) {
+    throw new Error("EMAIL_FROM is not configured");
+  }
+
+  const resend = getResendClient();
+  const response = await resend.emails.send({
+    from: env.EMAIL_FROM,
+    to: message.to,
+    subject: message.subject,
+    html: message.html,
+    text: message.text,
+    ...(env.EMAIL_REPLY_TO ? { replyTo: env.EMAIL_REPLY_TO } : {}),
+  });
+
+  if (response.error) {
+    throw new Error(response.error.message);
+  }
+
+  const messageId = response.data?.id;
+  if (!messageId) {
+    throw new Error("Resend did not return a message id");
+  }
+
+  return { provider: "resend", messageId };
+}
diff --git a/src/lib/notifications/channels/email/types.ts b/src/lib/notifications/channels/email/types.ts
new file mode 100644
index 00000000..742f23ed
--- /dev/null
+++ b/src/lib/notifications/channels/email/types.ts
@@ -0,0 +1,11 @@
+export type EmailMessage = {
+  to: string;
+  subject: string;
+  html: string;
+  text: string;
+};
+
+export type EmailSendResult = {
+  provider: "resend";
+  messageId: string;
+};
diff --git a/src/lib/notifications/events.ts b/src/lib/notifications/events.ts
new file mode 100644
index 00000000..3812d955
--- /dev/null
+++ b/src/lib/notifications/events.ts
@@ -0,0 +1,51 @@
+export const NOTIFICATION_CHANNEL_EMAIL = "email" as const;
+
+export const NOTIFICATION_EVENT_EMAIL_VERIFY = "email.verify" as const;
+export const NOTIFICATION_EVENT_SIGNATURE_REQUIRED =
+  "signature.required" as const;
+export const NOTIFICATION_EVENT_SIGNATURE_REMINDER =
+  "signature.reminder" as const;
+
+export const NOTIFICATION_STATUS_PENDING = "pending" as const;
+export const NOTIFICATION_STATUS_RETRYING = "retrying" as const;
+export const NOTIFICATION_STATUS_SENDING = "sending" as const;
+export const NOTIFICATION_STATUS_SENT = "sent" as const;
+export const NOTIFICATION_STATUS_FAILED = "failed" as const;
+export const NOTIFICATION_STATUS_SKIPPED_NO_EMAIL = "skipped_no_email" as const;
+export const NOTIFICATION_STATUS_SKIPPED_NOT_VERIFIED =
+  "skipped_not_verified" as const;
+export const NOTIFICATION_STATUS_SKIPPED_OPTED_OUT =
+  "skipped_opted_out" as const;
+export const NOTIFICATION_STATUS_SKIPPED_DISABLED =
+  "skipped_disabled" as const;
+
+export type NotificationEventType =
+  | typeof NOTIFICATION_EVENT_EMAIL_VERIFY
+  | typeof NOTIFICATION_EVENT_SIGNATURE_REQUIRED
+  | typeof NOTIFICATION_EVENT_SIGNATURE_REMINDER;
+
+export type NotificationResourceType = "transaction" | "signable" | "wallet";
+
+export type SignatureResourceType = Extract<
+  NotificationResourceType,
+  "transaction" | "signable"
+>;
+
+export type NotificationDeliveryStatus =
+  | typeof NOTIFICATION_STATUS_PENDING
+  | typeof NOTIFICATION_STATUS_RETRYING
+  | typeof NOTIFICATION_STATUS_SENDING
+  | typeof NOTIFICATION_STATUS_SENT
+  | typeof NOTIFICATION_STATUS_FAILED
+  | typeof NOTIFICATION_STATUS_SKIPPED_NO_EMAIL
+  | typeof NOTIFICATION_STATUS_SKIPPED_NOT_VERIFIED
+  | typeof NOTIFICATION_STATUS_SKIPPED_OPTED_OUT
+  | typeof NOTIFICATION_STATUS_SKIPPED_DISABLED;
+
+export function getSignatureNotificationPreferenceField(
+  resourceType: SignatureResourceType,
+) {
+  return resourceType === "transaction"
+    ? "notifyTransactionSignatures"
+    : "notifySignableSignatures";
+}
diff --git a/src/lib/notifications/outbox.ts b/src/lib/notifications/outbox.ts
new file mode 100644
index 00000000..4e0a069c
--- /dev/null
+++ b/src/lib/notifications/outbox.ts
@@ -0,0 +1,47 @@
+import type { Prisma, PrismaClient } from "@prisma/client";
+
+import {
+  NOTIFICATION_CHANNEL_EMAIL,
+  NOTIFICATION_STATUS_PENDING,
+  type NotificationDeliveryStatus,
+  type NotificationEventType,
+  type NotificationResourceType,
+} from "./events";
+
+export type CreateNotificationDeliveryInput = {
+  eventType: NotificationEventType;
+  recipientAddress: string;
+  recipientEmail?: string | null;
+  resourceType: NotificationResourceType;
+  resourceId: string;
+  walletId?: string | null;
+  idempotencyKey: string;
+  subject: string;
+  payload: Prisma.InputJsonObject;
+  status?: NotificationDeliveryStatus;
+  nextAttemptAt?: Date;
+};
+
+export async function createNotificationDelivery(
+  db: PrismaClient,
+  input: CreateNotificationDeliveryInput,
+) {
+  return db.notificationDelivery.upsert({
+    where: { idempotencyKey: input.idempotencyKey },
+    update: {},
+    create: {
+      eventType: input.eventType,
+      channel: NOTIFICATION_CHANNEL_EMAIL,
+      recipientAddress: input.recipientAddress,
+      recipientEmail: input.recipientEmail ?? null,
+      resourceType: input.resourceType,
+      resourceId: input.resourceId,
+      walletId: input.walletId ?? null,
+      idempotencyKey: input.idempotencyKey,
+      subject: input.subject,
+      payload: input.payload,
+      status: input.status ?? NOTIFICATION_STATUS_PENDING,
+      nextAttemptAt: input.nextAttemptAt ?? new Date(),
+    },
+  });
+}
diff --git a/src/lib/notifications/recipients.ts b/src/lib/notifications/recipients.ts
new file mode 100644
index 00000000..b92b7376
--- /dev/null
+++ b/src/lib/notifications/recipients.ts
@@ -0,0 +1,125 @@
+import type { PrismaClient } from "@prisma/client";
+
+import {
+  getSignatureNotificationPreferenceField,
+  NOTIFICATION_STATUS_SKIPPED_DISABLED,
+  NOTIFICATION_STATUS_SKIPPED_NO_EMAIL,
+  NOTIFICATION_STATUS_SKIPPED_NOT_VERIFIED,
+  NOTIFICATION_STATUS_SKIPPED_OPTED_OUT,
+  type NotificationDeliveryStatus,
+  type SignatureResourceType,
+} from "./events";
+
+export type SignatureRecipient = {
+  address: string;
+  email: string;
+  emailNormalized: string;
+};
+
+export type SkippedSignatureRecipient = {
+  address: string;
+  reason: NotificationDeliveryStatus;
+};
+
+export type ResolveSignatureRecipientsInput = {
+  walletId: string;
+  signerAddresses: string[];
+  resourceType: SignatureResourceType;
+  signedAddresses?: string[];
+  rejectedAddresses?: string[];
+  creatorAddress?: string | null;
+  onlyRecipientAddress?: string | null;
+};
+
+export type ResolveSignatureRecipientsResult = {
+  eligible: SignatureRecipient[];
+  skipped: SkippedSignatureRecipient[];
+};
+
+export function normalizeEmail(email: string): string {
+  return email.trim().toLowerCase();
+}
+
+export async function resolveSignatureRecipients(
+  db: PrismaClient,
+  input: ResolveSignatureRecipientsInput,
+): Promise<ResolveSignatureRecipientsResult> {
+  const signed = new Set(input.signedAddresses ?? []);
+  const rejected = new Set(input.rejectedAddresses ?? []);
+  const creator = input.creatorAddress ?? null;
+  const preferenceField = getSignatureNotificationPreferenceField(
+    input.resourceType,
+  );
+  const signerSet = new Set(input.signerAddresses);
+
+  const candidateAddresses = input.signerAddresses.filter((address) => {
+    if (input.onlyRecipientAddress && address !== input.onlyRecipientAddress) {
+      return false;
+    }
+    if (address === creator) return false;
+    if (signed.has(address)) return false;
+    if (rejected.has(address)) return false;
+    return true;
+  });
+
+  if (
+    input.onlyRecipientAddress &&
+    !signerSet.has(input.onlyRecipientAddress)
+  ) {
+    return { eligible: [], skipped: [] };
+  }
+
+  if (candidateAddresses.length === 0) {
+    return { eligible: [], skipped: [] };
+  }
+
+  const settings = await db.walletSignerNotificationSetting.findMany({
+    where: {
+      walletId: input.walletId,
+      signerAddress: { in: candidateAddresses },
+    },
+  });
+  const settingsByAddress = new Map(
+    settings.map((setting) => [setting.signerAddress, setting]),
+  );
+
+  const eligible: SignatureRecipient[] = [];
+  const skipped: SkippedSignatureRecipient[] = [];
+
+  for (const address of candidateAddresses) {
+    const setting = settingsByAddress.get(address);
+    if (!setting?.email || !setting.emailNormalized) {
+      skipped.push({ address, reason: NOTIFICATION_STATUS_SKIPPED_NO_EMAIL });
+      continue;
+    }
+    if (!setting.emailVerifiedAt) {
+      skipped.push({
+        address,
+        reason: NOTIFICATION_STATUS_SKIPPED_NOT_VERIFIED,
+      });
+      continue;
+    }
+    if (!setting.emailOptIn) {
+      skipped.push({
+        address,
+        reason: NOTIFICATION_STATUS_SKIPPED_OPTED_OUT,
+      });
+      continue;
+    }
+    if (!setting[preferenceField]) {
+      skipped.push({
+        address,
+        reason: NOTIFICATION_STATUS_SKIPPED_DISABLED,
+      });
+      continue;
+    }
+
+    eligible.push({
+      address,
+      email: setting.email,
+      emailNormalized: setting.emailNormalized,
+    });
+  }
+
+  return { eligible, skipped };
+}
diff --git a/src/lib/notifications/templates/shared.ts b/src/lib/notifications/templates/shared.ts
new file mode 100644
index 00000000..0aea445f
--- /dev/null
+++ b/src/lib/notifications/templates/shared.ts
@@ -0,0 +1,74 @@
+export type EmailTemplate = {
+  subject: string;
+  html: string;
+  text: string;
+};
+
+export function escapeHtml(value: unknown): string {
+  return String(value ?? "")
+    .replace(/&/g, "&amp;")
+    .replace(/</g, "&lt;")
+    .replace(/>/g, "&gt;")
+    .replace(/"/g, "&quot;")
+    .replace(/'/g, "&#39;");
+}
+
+export function renderEmailLayout(args: {
+  title: string;
+  preview: string;
+  bodyHtml: string;
+  ctaLabel?: string;
+  ctaUrl?: string;
+  footerHtml?: string;
+}): string {
+  const cta = args.ctaLabel && args.ctaUrl
+    ? `
+      <tr>
+        <td style="padding:24px 0 8px;">
+          <a href="${escapeHtml(args.ctaUrl)}" style="display:inline-block;background:#111827;color:#ffffff;text-decoration:none;border-radius:6px;padding:12px 18px;font-weight:700;">
+            ${escapeHtml(args.ctaLabel)}
+          </a>
+        </td>
+      </tr>
+    `
+    : "";
+
+  return `<!doctype html>
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <meta http-equiv="Content-Type" content="text/html; charset=UTF-8" />
+    <title>${escapeHtml(args.title)}</title>
+  </head>
+  <body style="margin:0;background:#f6f7fb;color:#111827;font-family:Arial,Helvetica,sans-serif;">
+    <span style="display:none!important;visibility:hidden;opacity:0;color:transparent;height:0;width:0;overflow:hidden;">${escapeHtml(args.preview)}</span>
+    <table role="presentation" width="100%" cellspacing="0" cellpadding="0" style="background:#f6f7fb;margin:0;padding:24px 12px;">
+      <tr>
+        <td align="center">
+          <table role="presentation" width="100%" cellspacing="0" cellpadding="0" style="max-width:640px;background:#ffffff;border:1px solid #e5e7eb;border-radius:8px;overflow:hidden;">
+            <tr>
+              <td style="padding:28px 28px 10px;">
+                <p style="margin:0 0 8px;color:#6b7280;font-size:13px;letter-spacing:0.04em;text-transform:uppercase;">Mesh Multisig</p>
+                <h1 style="margin:0;color:#111827;font-size:24px;line-height:1.25;">${escapeHtml(args.title)}</h1>
+              </td>
+            </tr>
+            <tr>
+              <td style="padding:8px 28px 28px;font-size:15px;line-height:1.6;color:#374151;">
+                ${args.bodyHtml}
+                <table role="presentation" cellspacing="0" cellpadding="0">
+                  ${cta}
+                </table>
+              </td>
+            </tr>
+            <tr>
+              <td style="padding:18px 28px;background:#f9fafb;border-top:1px solid #e5e7eb;color:#6b7280;font-size:12px;line-height:1.5;">
+                ${args.footerHtml ?? "You received this email because notifications are enabled for this multisig wallet."}
+              </td>
+            </tr>
+          </table>
+        </td>
+      </tr>
+    </table>
+  </body>
+</html>`;
+}
diff --git a/src/lib/notifications/templates/signatureRequired.ts b/src/lib/notifications/templates/signatureRequired.ts
new file mode 100644
index 00000000..9583fb27
--- /dev/null
+++ b/src/lib/notifications/templates/signatureRequired.ts
@@ -0,0 +1,66 @@
+import { escapeHtml, renderEmailLayout, type EmailTemplate } from "./shared";
+
+export type SignatureRequiredTemplateInput = {
+  walletName: string;
+  resourceType: "transaction" | "signable";
+  description?: string | null;
+  signedCount: number;
+  requiredCount: number;
+  totalSigners: number;
+  actionUrl: string;
+  preferencesUrl: string;
+};
+
+export function renderSignatureRequiredEmail(
+  input: SignatureRequiredTemplateInput,
+): EmailTemplate {
+  const resourceLabel =
+    input.resourceType === "transaction" ? "transaction" : "signable payload";
+  const subject = `Signature required: ${input.walletName}`;
+  const progress = `${input.signedCount} of ${input.requiredCount} required signatures collected`;
+  const description = input.description?.trim();
+
+  const bodyHtml = `
+    <p style="margin:0 0 16px;">A ${escapeHtml(resourceLabel)} in <strong>${escapeHtml(input.walletName)}</strong> is waiting for your signature.</p>
+    <table role="presentation" width="100%" cellspacing="0" cellpadding="0" style="margin:18px 0;border:1px solid #e5e7eb;border-radius:6px;">
+      <tr>
+        <td style="padding:12px 14px;border-bottom:1px solid #e5e7eb;color:#6b7280;">Progress</td>
+        <td style="padding:12px 14px;border-bottom:1px solid #e5e7eb;text-align:right;font-weight:700;">${escapeHtml(progress)}</td>
+      </tr>
+      <tr>
+        <td style="padding:12px 14px;color:#6b7280;">Signers</td>
+        <td style="padding:12px 14px;text-align:right;">${input.totalSigners}</td>
+      </tr>
+    </table>
+    ${
+      description
+        ? `<p style="margin:0 0 16px;"><strong>Description:</strong> ${escapeHtml(description)}</p>`
+        : ""
+    }
+  `;
+
+  const html = renderEmailLayout({
+    title: "Your signature is required",
+    preview: `${input.walletName} has a ${resourceLabel} awaiting your signature.`,
+    bodyHtml,
+    ctaLabel: "Review and sign",
+    ctaUrl: input.actionUrl,
+    footerHtml: `Manage wallet notification preferences here: <a href="${escapeHtml(input.preferencesUrl)}" style="color:#374151;">${escapeHtml(input.preferencesUrl)}</a>`,
+  });
+
+  const text = [
+    subject,
+    "",
+    `A ${resourceLabel} in ${input.walletName} is waiting for your signature.`,
+    progress,
+    `Total signers: ${input.totalSigners}`,
+    description ? `Description: ${description}` : undefined,
+    "",
+    `Review and sign: ${input.actionUrl}`,
+    `Manage notification preferences: ${input.preferencesUrl}`,
+  ]
+    .filter(Boolean)
+    .join("\n");
+
+  return { subject, html, text };
+}
diff --git a/src/lib/notifications/templates/verifyEmail.ts b/src/lib/notifications/templates/verifyEmail.ts
new file mode 100644
index 00000000..202a93ce
--- /dev/null
+++ b/src/lib/notifications/templates/verifyEmail.ts
@@ -0,0 +1,39 @@
+import { escapeHtml, renderEmailLayout, type EmailTemplate } from "./shared";
+
+export type VerifyEmailTemplateInput = {
+  walletName: string;
+  verifyUrl: string;
+  preferencesUrl: string;
+  expiresHours: number;
+};
+
+export function renderVerifyEmail(
+  input: VerifyEmailTemplateInput,
+): EmailTemplate {
+  const subject = `Verify email notifications for ${input.walletName}`;
+  const bodyHtml = `
+    <p style="margin:0 0 16px;">Confirm that this email address should receive notifications for <strong>${escapeHtml(input.walletName)}</strong>.</p>
+    <p style="margin:0 0 16px;">This verification link expires in ${input.expiresHours} hours.</p>
+  `;
+
+  const html = renderEmailLayout({
+    title: "Verify your notification email",
+    preview: `Confirm email notifications for ${input.walletName}.`,
+    bodyHtml,
+    ctaLabel: "Verify email",
+    ctaUrl: input.verifyUrl,
+    footerHtml: `You can update wallet notification preferences here: <a href="${escapeHtml(input.preferencesUrl)}" style="color:#374151;">${escapeHtml(input.preferencesUrl)}</a>`,
+  });
+
+  const text = [
+    subject,
+    "",
+    `Confirm that this email address should receive notifications for ${input.walletName}.`,
+    `This verification link expires in ${input.expiresHours} hours.`,
+    "",
+    `Verify email: ${input.verifyUrl}`,
+    `Manage notification preferences: ${input.preferencesUrl}`,
+  ].join("\n");
+
+  return { subject, html, text };
+}
diff --git a/src/lib/notifications/worker.ts b/src/lib/notifications/worker.ts
new file mode 100644
index 00000000..f17dff2e
--- /dev/null
+++ b/src/lib/notifications/worker.ts
@@ -0,0 +1,118 @@
+import type { PrismaClient } from "@prisma/client";
+
+import {
+  NOTIFICATION_STATUS_FAILED,
+  NOTIFICATION_STATUS_PENDING,
+  NOTIFICATION_STATUS_RETRYING,
+  NOTIFICATION_STATUS_SENDING,
+  NOTIFICATION_STATUS_SENT,
+} from "./events";
+import { sendEmailViaResend } from "./channels/email/resend";
+
+const RETRY_DELAYS_MS = [
+  5 * 60 * 1000,
+  30 * 60 * 1000,
+  2 * 60 * 60 * 1000,
+  6 * 60 * 60 * 1000,
+];
+const MAX_ATTEMPTS = 5;
+
+function toError(error: unknown): Error {
+  return error instanceof Error ? error : new Error(String(error));
+}
+
+function getNextAttemptAt(attempts: number): Date {
+  const delay = RETRY_DELAYS_MS[Math.min(attempts - 1, RETRY_DELAYS_MS.length - 1)]!;
+  return new Date(Date.now() + delay);
+}
+
+function getPayloadString(
+  payload: unknown,
+  key: "html" | "text",
+): string | null {
+  if (!payload || typeof payload !== "object") return null;
+  const value = (payload as Record<string, unknown>)[key];
+  return typeof value === "string" && value.trim() ? value : null;
+}
+
+export async function drainNotificationOutbox(
+  db: PrismaClient,
+  options: { limit?: number } = {},
+) {
+  const limit = Math.max(1, Math.min(options.limit ?? 25, 100));
+  const now = new Date();
+  const deliveries = await db.notificationDelivery.findMany({
+    where: {
+      status: { in: [NOTIFICATION_STATUS_PENDING, NOTIFICATION_STATUS_RETRYING] },
+      nextAttemptAt: { lte: now },
+      recipientEmail: { not: null },
+    },
+    orderBy: { createdAt: "asc" },
+    take: limit,
+  });
+
+  const results = [];
+
+  for (const delivery of deliveries) {
+    const claimed = await db.notificationDelivery.updateMany({
+      where: {
+        id: delivery.id,
+        status: delivery.status,
+      },
+      data: {
+        status: NOTIFICATION_STATUS_SENDING,
+        attempts: { increment: 1 },
+        lastError: null,
+      },
+    });
+
+    if (claimed.count === 0) {
+      continue;
+    }
+
+    const attempts = delivery.attempts + 1;
+    const html = getPayloadString(delivery.payload, "html");
+    const text = getPayloadString(delivery.payload, "text");
+
+    try {
+      if (!delivery.recipientEmail || !html || !text) {
+        throw new Error("Delivery is missing recipient or rendered email body");
+      }
+
+      const sent = await sendEmailViaResend({
+        to: delivery.recipientEmail,
+        subject: delivery.subject,
+        html,
+        text,
+      });
+
+      const updated = await db.notificationDelivery.update({
+        where: { id: delivery.id },
+        data: {
+          status: NOTIFICATION_STATUS_SENT,
+          provider: sent.provider,
+          providerMessageId: sent.messageId,
+          sentAt: new Date(),
+          lastError: null,
+        },
+      });
+      results.push(updated);
+    } catch (error) {
+      const err = toError(error);
+      const willRetry = attempts < MAX_ATTEMPTS;
+      const updated = await db.notificationDelivery.update({
+        where: { id: delivery.id },
+        data: {
+          status: willRetry
+            ? NOTIFICATION_STATUS_RETRYING
+            : NOTIFICATION_STATUS_FAILED,
+          lastError: err.message.slice(0, 1000),
+          nextAttemptAt: willRetry ? getNextAttemptAt(attempts) : new Date(),
+        },
+      });
+      results.push(updated);
+    }
+  }
+
+  return results;
+}
diff --git a/src/lib/server/createPendingMultisigTransaction.ts b/src/lib/server/createPendingMultisigTransaction.ts
index 7970fb21..53d76fd2 100644
--- a/src/lib/server/createPendingMultisigTransaction.ts
+++ b/src/lib/server/createPendingMultisigTransaction.ts
@@ -1,5 +1,6 @@
 import type { PrismaClient } from "@prisma/client";
 import { getProvider } from "@/utils/get-provider";
+import { enqueueSignatureRequiredNotifications } from "@/lib/notifications/center";
 
 export type WalletSubmitShape = {
   numRequiredSigners: number | null;
@@ -54,7 +55,7 @@ export async function createPendingMultisigTransaction(
     return await blockchainProvider.submitTx(txCbor);
   }
 
-  return await db.transaction.create({
+  const transaction = await db.transaction.create({
     data: {
       walletId,
       txJson: txJsonStr,
@@ -65,4 +66,33 @@ export async function createPendingMultisigTransaction(
       state: 0,
     },
   });
+
+  try {
+    const walletRow = await db.wallet.findUnique({
+      where: { id: walletId },
+      select: {
+        id: true,
+        name: true,
+        signersAddresses: true,
+        numRequiredSigners: true,
+        type: true,
+      },
+    });
+
+    if (walletRow) {
+      await enqueueSignatureRequiredNotifications(db, {
+        wallet: walletRow,
+        resourceType: "transaction",
+        resourceId: transaction.id,
+        signedAddresses: transaction.signedAddresses,
+        rejectedAddresses: transaction.rejectedAddresses,
+        creatorAddress: proposerAddress,
+        description,
+      });
+    }
+  } catch (error) {
+    console.error("Failed to enqueue transaction notifications", error);
+  }
+
+  return transaction;
 }
diff --git a/src/pages/api/notifications/drain.ts b/src/pages/api/notifications/drain.ts
new file mode 100644
index 00000000..519b0a48
--- /dev/null
+++ b/src/pages/api/notifications/drain.ts
@@ -0,0 +1,45 @@
+import type { NextApiRequest, NextApiResponse } from "next";
+
+import { env } from "@/env";
+import { db } from "@/server/db";
+import { drainNotificationOutbox } from "@/lib/notifications/worker";
+import { notificationsEmailEnabled } from "@/lib/notifications/center";
+
+export default async function handler(
+  req: NextApiRequest,
+  res: NextApiResponse,
+) {
+  if (req.method !== "POST") {
+    return res.status(405).json({ error: "Method Not Allowed" });
+  }
+
+  if (!env.NOTIFICATION_DRAIN_SECRET) {
+    return res.status(503).json({ error: "Notification drain is not configured" });
+  }
+
+  const authHeader = req.headers.authorization;
+  const token = authHeader?.startsWith("Bearer ")
+    ? authHeader.slice(7)
+    : null;
+
+  if (token !== env.NOTIFICATION_DRAIN_SECRET) {
+    return res.status(401).json({ error: "Unauthorized" });
+  }
+
+  if (!notificationsEmailEnabled()) {
+    return res.status(200).json({ drained: 0, emailEnabled: false });
+  }
+
+  const rawLimit = Array.isArray(req.query.limit)
+    ? req.query.limit[0]
+    : req.query.limit;
+  const limit = rawLimit ? Number.parseInt(rawLimit, 10) : 25;
+  const deliveries = await drainNotificationOutbox(db, {
+    limit: Number.isFinite(limit) ? limit : 25,
+  });
+
+  return res.status(200).json({
+    drained: deliveries.length,
+    emailEnabled: true,
+  });
+}
diff --git a/src/pages/api/notifications/email/verify.ts b/src/pages/api/notifications/email/verify.ts
new file mode 100644
index 00000000..4474d809
--- /dev/null
+++ b/src/pages/api/notifications/email/verify.ts
@@ -0,0 +1,186 @@
+import { createHash } from "crypto";
+import type { NextApiRequest, NextApiResponse } from "next";
+
+import { getSiteUrl } from "@/lib/notifications/center";
+import { escapeHtml } from "@/lib/notifications/templates/shared";
+import { db } from "@/server/db";
+
+function hashToken(token: string): string {
+  return createHash("sha256").update(token, "utf8").digest("hex");
+}
+
+function walletSettingsUrl(walletId: string): string {
+  return `${getSiteUrl()}/wallets/${encodeURIComponent(walletId)}/info`;
+}
+
+type VerifyPageOptions = {
+  ctaHref?: string;
+  ctaLabel?: string;
+  secondaryMessage?: string;
+};
+
+function renderResult(
+  title: string,
+  message: string,
+  options: VerifyPageOptions = {},
+) {
+  const cta =
+    options.ctaHref && options.ctaLabel
+      ? `<p style="margin:24px 0 0;">
+          <a href="${escapeHtml(options.ctaHref)}" style="display:inline-block;background:#111827;color:#ffffff;text-decoration:none;border-radius:6px;padding:12px 18px;font-weight:700;">
+            ${escapeHtml(options.ctaLabel)}
+          </a>
+        </p>`
+      : "";
+  const secondary = options.secondaryMessage
+    ? `<p style="margin:16px 0 0;color:#6b7280;font-size:14px;line-height:1.5;">${escapeHtml(options.secondaryMessage)}</p>`
+    : "";
+
+  return `<!doctype html>
+<html>
+  <head>
+    <meta name="viewport" content="width=device-width, initial-scale=1.0" />
+    <title>${escapeHtml(title)}</title>
+  </head>
+  <body style="margin:0;background:#f6f7fb;color:#111827;font-family:Arial,Helvetica,sans-serif;">
+    <main style="max-width:560px;margin:48px auto;background:#ffffff;border:1px solid #e5e7eb;border-radius:8px;padding:28px;">
+      <p style="margin:0 0 8px;color:#6b7280;font-size:13px;letter-spacing:0.04em;text-transform:uppercase;">Mesh Multisig</p>
+      <h1 style="margin:0 0 12px;font-size:24px;line-height:1.25;">${escapeHtml(title)}</h1>
+      <p style="margin:0;color:#374151;line-height:1.6;">${escapeHtml(message)}</p>
+      ${cta}
+      ${secondary}
+    </main>
+  </body>
+</html>`;
+}
+
+function sendHtml(
+  res: NextApiResponse,
+  status: number,
+  title: string,
+  message: string,
+  options: VerifyPageOptions = {},
+) {
+  res.status(status);
+  res.setHeader("Content-Type", "text/html; charset=utf-8");
+  return res.send(renderResult(title, message, options));
+}
+
+function walletReturnOptions(walletId: string): VerifyPageOptions {
+  return {
+    ctaHref: walletSettingsUrl(walletId),
+    ctaLabel: "Go to wallet",
+    secondaryMessage: "You can safely close this window.",
+  };
+}
+
+export default async function handler(
+  req: NextApiRequest,
+  res: NextApiResponse,
+) {
+  if (req.method !== "GET") {
+    return res.status(405).json({ error: "Method Not Allowed" });
+  }
+
+  try {
+    const token = typeof req.query.token === "string" ? req.query.token : "";
+    if (!token) {
+      return sendHtml(
+        res,
+        400,
+        "Invalid verification link",
+        "The verification token is missing.",
+      );
+    }
+
+    const tokenHash = hashToken(token);
+    const verification = await db.emailVerificationToken.findUnique({
+      where: { tokenHash },
+    });
+
+    if (!verification) {
+      return sendHtml(
+        res,
+        404,
+        "Invalid verification link",
+        "This verification link was not found.",
+      );
+    }
+
+    if (verification.consumedAt) {
+      return sendHtml(
+        res,
+        200,
+        "Email already verified",
+        "This email verification link has already been used.",
+        walletReturnOptions(verification.walletId),
+      );
+    }
+
+    if (verification.expiresAt < new Date()) {
+      return sendHtml(
+        res,
+        410,
+        "Verification link expired",
+        "Please request a new verification email from your wallet notification settings.",
+        {
+          ctaHref: walletSettingsUrl(verification.walletId),
+          ctaLabel: "Go to wallet",
+        },
+      );
+    }
+
+    const setting = await db.walletSignerNotificationSetting.findUnique({
+      where: {
+        walletId_signerAddress: {
+          walletId: verification.walletId,
+          signerAddress: verification.signerAddress,
+        },
+      },
+    });
+
+    if (!setting || setting.emailNormalized !== verification.emailNormalized) {
+      await db.emailVerificationToken.update({
+        where: { id: verification.id },
+        data: { consumedAt: new Date() },
+      });
+      return sendHtml(
+        res,
+        409,
+        "Email changed",
+        "This verification link no longer matches your current notification email.",
+        {
+          ctaHref: walletSettingsUrl(verification.walletId),
+          ctaLabel: "Go to wallet",
+        },
+      );
+    }
+
+    await db.$transaction(async (tx) => {
+      await tx.walletSignerNotificationSetting.update({
+        where: { id: setting.id },
+        data: { emailVerifiedAt: new Date() },
+      });
+      await tx.emailVerificationToken.update({
+        where: { id: verification.id },
+        data: { consumedAt: new Date() },
+      });
+    });
+
+    return sendHtml(
+      res,
+      200,
+      "Email verified",
+      "You can now receive email notifications for this wallet.",
+      walletReturnOptions(verification.walletId),
+    );
+  } catch (error) {
+    console.error("Email verification failed", error);
+    return sendHtml(
+      res,
+      500,
+      "Verification failed",
+      "Something went wrong while verifying your email. Please try again or request a new verification email.",
+    );
+  }
+}
diff --git a/src/pages/api/v1/submitDatum.ts b/src/pages/api/v1/submitDatum.ts
index 2e620918..ef4259e2 100644
--- a/src/pages/api/v1/submitDatum.ts
+++ b/src/pages/api/v1/submitDatum.ts
@@ -6,6 +6,7 @@ import { DataSignature } from "@meshsdk/core";
 import { checkSignature } from "@meshsdk/core-cst";
 import { applyRateLimit, applyBotRateLimit, enforceBodySize } from "@/lib/security/requestGuards";
 import { assertBotWalletAccess } from "@/lib/auth/botAccess";
+import { enqueueSignatureRequiredNotifications } from "@/lib/notifications/center";
 
 export default async function handler(
   req: NextApiRequest,
@@ -126,6 +127,32 @@ export default async function handler(
       },
     });
 
+    try {
+      const walletRow = await db.wallet.findUnique({
+        where: { id: walletId },
+        select: {
+          id: true,
+          name: true,
+          signersAddresses: true,
+          numRequiredSigners: true,
+          type: true,
+        },
+      });
+      if (walletRow) {
+        await enqueueSignatureRequiredNotifications(db, {
+          wallet: walletRow,
+          resourceType: "signable",
+          resourceId: newSignable.id,
+          signedAddresses: newSignable.signedAddresses,
+          rejectedAddresses: newSignable.rejectedAddresses,
+          creatorAddress: address,
+          description: newSignable.description,
+        });
+      }
+    } catch (notificationError) {
+      console.error("Failed to enqueue signable notifications", notificationError);
+    }
+
     res.status(201).json(newSignable);
   } catch (error) {
     console.error("Error creating signable:", error);
diff --git a/src/server/api/root.ts b/src/server/api/root.ts
index 36c6d78c..4edc90dc 100644
--- a/src/server/api/root.ts
+++ b/src/server/api/root.ts
@@ -10,6 +10,7 @@ import { authRouter } from "./routers/auth";
 import { contactRouter } from "./routers/contacts";
 import { botRouter } from "./routers/bot";
 import { governanceRouter } from "./routers/governance";
+import { notificationRouter } from "./routers/notifications";
 
 /**
  * This is the primary router for your server.
@@ -28,6 +29,7 @@ export const appRouter = createTRPCRouter({
   contact: contactRouter,
   bot: botRouter,
   governance: governanceRouter,
+  notification: notificationRouter,
 });
 
 // export type definition of API
diff --git a/src/server/api/routers/notifications.ts b/src/server/api/routers/notifications.ts
new file mode 100644
index 00000000..35c7aa09
--- /dev/null
+++ b/src/server/api/routers/notifications.ts
@@ -0,0 +1,412 @@
+import { createHash, randomBytes } from "crypto";
+
+import { TRPCError } from "@trpc/server";
+import { z } from "zod";
+
+import { env } from "@/env";
+import { createTRPCRouter, protectedProcedure } from "@/server/api/trpc";
+import type { AuthCtx } from "@/server/api/trpc";
+import { assertWalletAccess } from "@/server/api/auth";
+import { normalizeAddressToBech32 } from "@/utils/addressCompatibility";
+import {
+  getSiteUrl,
+  enqueueSignatureRequiredNotifications,
+  notificationsEmailEnabled,
+} from "@/lib/notifications/center";
+import {
+  NOTIFICATION_EVENT_EMAIL_VERIFY,
+  NOTIFICATION_EVENT_SIGNATURE_REMINDER,
+} from "@/lib/notifications/events";
+import { createNotificationDelivery } from "@/lib/notifications/outbox";
+import { normalizeEmail } from "@/lib/notifications/recipients";
+import { renderVerifyEmail } from "@/lib/notifications/templates/verifyEmail";
+import { drainNotificationOutbox } from "@/lib/notifications/worker";
+
+const VERIFY_TOKEN_BYTES = 32;
+const VERIFY_TOKEN_TTL_HOURS = 24;
+
+function addressesEqual(a: string, b: string): boolean {
+  return normalizeAddressToBech32(a) === normalizeAddressToBech32(b);
+}
+
+function isAddressAuthorizedInSession(ctx: AuthCtx, address: string): boolean {
+  const normalized = normalizeAddressToBech32(address);
+  const sessionWallets = Array.isArray(ctx.sessionWallets)
+    ? ctx.sessionWallets
+    : [];
+  if (sessionWallets.some((candidate) => addressesEqual(candidate, normalized))) {
+    return true;
+  }
+  const primary = ctx.primaryWallet ?? ctx.sessionAddress;
+  if (primary && addressesEqual(primary, normalized)) {
+    return true;
+  }
+  const sessionUserId = ctx.session?.user?.id;
+  return Boolean(sessionUserId && addressesEqual(sessionUserId, normalized));
+}
+
+function requireAuthorizedSignerAddress(
+  ctx: AuthCtx,
+  requesterAddress: string,
+): string {
+  const normalized = normalizeAddressToBech32(requesterAddress.trim());
+  if (!normalized) {
+    throw new TRPCError({
+      code: "BAD_REQUEST",
+      message: "Missing signer address",
+    });
+  }
+  if (!isAddressAuthorizedInSession(ctx, normalized)) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message:
+        "Address mismatch. Please authorize your currently connected wallet.",
+    });
+  }
+  return normalized;
+}
+
+function resolveWalletSignerAddress(
+  signersAddresses: string[],
+  requesterAddress: string,
+): string {
+  const normalized = normalizeAddressToBech32(requesterAddress);
+  return (
+    signersAddresses.find((candidate) => addressesEqual(candidate, normalized)) ??
+    normalized
+  );
+}
+
+function isWalletSigner(signersAddresses: string[], address: string): boolean {
+  return signersAddresses.some((candidate) => addressesEqual(candidate, address));
+}
+
+function hashToken(token: string): string {
+  return createHash("sha256").update(token, "utf8").digest("hex");
+}
+
+async function assertCurrentSigner(
+  ctx: AuthCtx,
+  walletId: string,
+  requesterAddress: string,
+) {
+  requireAuthorizedSignerAddress(ctx, requesterAddress);
+  const wallet = await assertWalletAccess(ctx, walletId, requesterAddress);
+  const signerAddress = resolveWalletSignerAddress(
+    wallet.signersAddresses,
+    requesterAddress,
+  );
+  if (!isWalletSigner(wallet.signersAddresses, signerAddress)) {
+    throw new TRPCError({
+      code: "FORBIDDEN",
+      message: "Only a wallet signer can manage their notification settings",
+    });
+  }
+  return { wallet, signerAddress };
+}
+
+function verificationUrl(token: string): string {
+  return `${getSiteUrl()}/api/notifications/email/verify?token=${encodeURIComponent(token)}`;
+}
+
+export const notificationRouter = createTRPCRouter({
+  getWalletSignerSetting: protectedProcedure
+    .input(
+      z.object({
+        walletId: z.string().min(1),
+        signerAddress: z.string().min(1),
+      }),
+    )
+    .query(async ({ ctx, input }) => {
+      const { signerAddress } = await assertCurrentSigner(
+        ctx,
+        input.walletId,
+        input.signerAddress,
+      );
+      const setting = await ctx.db.walletSignerNotificationSetting.findUnique({
+        where: {
+          walletId_signerAddress: {
+            walletId: input.walletId,
+            signerAddress,
+          },
+        },
+      });
+
+      return (
+        setting ?? {
+          id: null,
+          walletId: input.walletId,
+          signerAddress,
+          email: null,
+          emailNormalized: null,
+          emailVerifiedAt: null,
+          emailOptIn: true,
+          notifyTransactionSignatures: true,
+          notifySignableSignatures: true,
+          createdAt: null,
+          updatedAt: null,
+        }
+      );
+    }),
+
+  upsertWalletSignerSetting: protectedProcedure
+    .input(
+      z.object({
+        walletId: z.string().min(1),
+        signerAddress: z.string().min(1),
+        email: z.string().email().or(z.literal("")).optional(),
+        emailOptIn: z.boolean().optional(),
+        notifyTransactionSignatures: z.boolean().optional(),
+        notifySignableSignatures: z.boolean().optional(),
+      }),
+    )
+    .mutation(async ({ ctx, input }) => {
+      const { signerAddress } = await assertCurrentSigner(
+        ctx,
+        input.walletId,
+        input.signerAddress,
+      );
+      const existing = await ctx.db.walletSignerNotificationSetting.findUnique({
+        where: {
+          walletId_signerAddress: {
+            walletId: input.walletId,
+            signerAddress,
+          },
+        },
+      });
+
+      const emailProvided = Object.prototype.hasOwnProperty.call(input, "email");
+      const email = emailProvided && input.email ? input.email.trim() : null;
+      const emailNormalized = email ? normalizeEmail(email) : null;
+      const emailChanged =
+        emailProvided && existing?.emailNormalized !== emailNormalized;
+
+      const data = {
+        ...(emailProvided
+          ? {
+              email,
+              emailNormalized,
+              emailVerifiedAt: emailChanged ? null : existing?.emailVerifiedAt,
+            }
+          : {}),
+        ...(typeof input.emailOptIn === "boolean"
+          ? { emailOptIn: input.emailOptIn }
+          : {}),
+        ...(typeof input.notifyTransactionSignatures === "boolean"
+          ? {
+              notifyTransactionSignatures:
+                input.notifyTransactionSignatures,
+            }
+          : {}),
+        ...(typeof input.notifySignableSignatures === "boolean"
+          ? { notifySignableSignatures: input.notifySignableSignatures }
+          : {}),
+      };
+
+      const setting = await ctx.db.walletSignerNotificationSetting.upsert({
+        where: {
+          walletId_signerAddress: {
+            walletId: input.walletId,
+            signerAddress,
+          },
+        },
+        update: data,
+        create: {
+          walletId: input.walletId,
+          signerAddress,
+          email,
+          emailNormalized,
+          emailVerifiedAt: null,
+          emailOptIn: input.emailOptIn ?? true,
+          notifyTransactionSignatures:
+            input.notifyTransactionSignatures ?? true,
+          notifySignableSignatures: input.notifySignableSignatures ?? true,
+        },
+      });
+
+      if (emailChanged) {
+        await ctx.db.emailVerificationToken.updateMany({
+          where: {
+            walletId: input.walletId,
+            signerAddress,
+            consumedAt: null,
+          },
+          data: { consumedAt: new Date() },
+        });
+      }
+
+      return setting;
+    }),
+
+  sendVerificationEmail: protectedProcedure
+    .input(
+      z.object({
+        walletId: z.string().min(1),
+        signerAddress: z.string().min(1),
+      }),
+    )
+    .mutation(async ({ ctx, input }) => {
+      const { wallet, signerAddress } = await assertCurrentSigner(
+        ctx,
+        input.walletId,
+        input.signerAddress,
+      );
+      const setting = await ctx.db.walletSignerNotificationSetting.findUnique({
+        where: {
+          walletId_signerAddress: {
+            walletId: input.walletId,
+            signerAddress,
+          },
+        },
+      });
+
+      if (!setting?.email || !setting.emailNormalized) {
+        throw new TRPCError({
+          code: "BAD_REQUEST",
+          message: "Add an email address before sending verification",
+        });
+      }
+
+      const token = randomBytes(VERIFY_TOKEN_BYTES).toString("base64url");
+      const tokenHash = hashToken(token);
+      const expiresAt = new Date(
+        Date.now() + VERIFY_TOKEN_TTL_HOURS * 60 * 60 * 1000,
+      );
+
+      await ctx.db.emailVerificationToken.create({
+        data: {
+          walletId: input.walletId,
+          signerAddress,
+          emailNormalized: setting.emailNormalized,
+          tokenHash,
+          expiresAt,
+        },
+      });
+
+      const preferencesUrl = `${getSiteUrl()}/wallets/${input.walletId}/info`;
+      const template = renderVerifyEmail({
+        walletName: wallet.name,
+        verifyUrl: verificationUrl(token),
+        preferencesUrl,
+        expiresHours: VERIFY_TOKEN_TTL_HOURS,
+      });
+
+      const delivery = await createNotificationDelivery(ctx.db, {
+        eventType: NOTIFICATION_EVENT_EMAIL_VERIFY,
+        recipientAddress: signerAddress,
+        recipientEmail: setting.email,
+        resourceType: "wallet",
+        resourceId: input.walletId,
+        walletId: input.walletId,
+        idempotencyKey: [
+          NOTIFICATION_EVENT_EMAIL_VERIFY,
+          "email",
+          input.walletId,
+          signerAddress,
+          tokenHash,
+        ].join(":"),
+        subject: template.subject,
+        payload: {
+          walletId: input.walletId,
+          walletName: wallet.name,
+          signerAddress,
+          html: template.html,
+          text: template.text,
+        },
+      });
+
+      if (notificationsEmailEnabled()) {
+        try {
+          await drainNotificationOutbox(ctx.db, { limit: 10 });
+        } catch (error) {
+          console.error("Verification email drain failed", error);
+        }
+      }
+
+      return {
+        deliveryId: delivery.id,
+        emailEnabled: env.NOTIFICATIONS_EMAIL_ENABLED === "true",
+      };
+    }),
+
+  sendSignatureReminder: protectedProcedure
+    .input(
+      z.object({
+        walletId: z.string().min(1),
+        resourceType: z.enum(["transaction", "signable"]),
+        resourceId: z.string().min(1),
+        recipientAddress: z.string().min(1),
+      }),
+    )
+    .mutation(async ({ ctx, input }) => {
+      const wallet = await assertWalletAccess(ctx, input.walletId);
+      if (!wallet.signersAddresses.includes(input.recipientAddress)) {
+        throw new TRPCError({
+          code: "BAD_REQUEST",
+          message: "Recipient is not a wallet signer",
+        });
+      }
+
+      if (input.resourceType === "transaction") {
+        const transaction = await ctx.db.transaction.findUnique({
+          where: { id: input.resourceId },
+        });
+        if (!transaction || transaction.walletId !== input.walletId) {
+          throw new TRPCError({
+            code: "NOT_FOUND",
+            message: "Transaction not found",
+          });
+        }
+        if (
+          transaction.state !== 0 ||
+          transaction.signedAddresses.includes(input.recipientAddress) ||
+          transaction.rejectedAddresses.includes(input.recipientAddress)
+        ) {
+          throw new TRPCError({
+            code: "BAD_REQUEST",
+            message: "Recipient does not need to sign this transaction",
+          });
+        }
+        return enqueueSignatureRequiredNotifications(ctx.db, {
+          wallet,
+          resourceType: "transaction",
+          resourceId: transaction.id,
+          signedAddresses: transaction.signedAddresses,
+          rejectedAddresses: transaction.rejectedAddresses,
+          description: transaction.description,
+          onlyRecipientAddress: input.recipientAddress,
+          eventType: NOTIFICATION_EVENT_SIGNATURE_REMINDER,
+        });
+      }
+
+      const signable = await ctx.db.signable.findUnique({
+        where: { id: input.resourceId },
+      });
+      if (!signable || signable.walletId !== input.walletId) {
+        throw new TRPCError({
+          code: "NOT_FOUND",
+          message: "Signable not found",
+        });
+      }
+      if (
+        signable.state !== 0 ||
+        signable.signedAddresses.includes(input.recipientAddress) ||
+        signable.rejectedAddresses.includes(input.recipientAddress)
+      ) {
+        throw new TRPCError({
+          code: "BAD_REQUEST",
+          message: "Recipient does not need to sign this payload",
+        });
+      }
+      return enqueueSignatureRequiredNotifications(ctx.db, {
+        wallet,
+        resourceType: "signable",
+        resourceId: signable.id,
+        signedAddresses: signable.signedAddresses,
+        rejectedAddresses: signable.rejectedAddresses,
+        description: signable.description,
+        onlyRecipientAddress: input.recipientAddress,
+        eventType: NOTIFICATION_EVENT_SIGNATURE_REMINDER,
+      });
+    }),
+});
diff --git a/src/server/api/routers/signable.ts b/src/server/api/routers/signable.ts
index 8b5bd21a..3a8b4f9f 100644
--- a/src/server/api/routers/signable.ts
+++ b/src/server/api/routers/signable.ts
@@ -4,6 +4,7 @@ import { z } from "zod";
 import { createTRPCRouter, protectedProcedure } from "@/server/api/trpc";
 import { audit } from "@/lib/observability/audit";
 import { requireSessionAddress, assertWalletAccess } from "@/server/api/auth";
+import { enqueueSignatureRequiredNotifications } from "@/lib/notifications/center";
 
 export const signableRouter = createTRPCRouter({
   createSignable: protectedProcedure
@@ -20,8 +21,8 @@ export const signableRouter = createTRPCRouter({
     )
     .mutation(async ({ ctx, input }) => {
       const sessionAddress = requireSessionAddress(ctx);
-      await assertWalletAccess(ctx, input.walletId, sessionAddress);
-      return ctx.db.signable.create({
+      const wallet = await assertWalletAccess(ctx, input.walletId, sessionAddress);
+      const signable = await ctx.db.signable.create({
         data: {
           walletId: input.walletId,
           payload: input.payload,
@@ -32,6 +33,22 @@ export const signableRouter = createTRPCRouter({
           description: input.description,
         },
       });
+      if (signable.state === 0) {
+        try {
+          await enqueueSignatureRequiredNotifications(ctx.db, {
+            wallet,
+            resourceType: "signable",
+            resourceId: signable.id,
+            signedAddresses: signable.signedAddresses,
+            rejectedAddresses: signable.rejectedAddresses,
+            creatorAddress: sessionAddress,
+            description: signable.description,
+          });
+        } catch (error) {
+          console.error("Failed to enqueue signable notifications", error);
+        }
+      }
+      return signable;
     }),
 
   updateSignable: protectedProcedure
diff --git a/src/server/api/routers/transactions.ts b/src/server/api/routers/transactions.ts
index bf85643c..8705f95d 100644
--- a/src/server/api/routers/transactions.ts
+++ b/src/server/api/routers/transactions.ts
@@ -10,6 +10,7 @@ import { addressToNetwork } from "@/utils/multisigSDK";
 import { createTRPCRouter, protectedProcedure } from "@/server/api/trpc";
 import { audit } from "@/lib/observability/audit";
 import { assertWalletAccess } from "@/server/api/auth";
+import { enqueueSignatureRequiredNotifications } from "@/lib/notifications/center";
 
 function toHex(bytes: Uint8Array): string {
   return Buffer.from(bytes).toString("hex");
@@ -37,7 +38,7 @@ export const transactionRouter = createTRPCRouter({
       }),
     )
     .mutation(async ({ ctx, input }) => {
-      await assertWalletAccess(ctx, input.walletId);
+      const wallet = await assertWalletAccess(ctx, input.walletId);
       const sessionAddress = ctx.session?.user?.id ?? ctx.sessionAddress ?? null;
       const tx = await ctx.db.transaction.create({
         data: {
@@ -66,6 +67,21 @@ export const transactionRouter = createTRPCRouter({
           initialSigners: input.signedAddresses.length,
         },
       });
+      if (tx.state === 0) {
+        try {
+          await enqueueSignatureRequiredNotifications(ctx.db, {
+            wallet,
+            resourceType: "transaction",
+            resourceId: tx.id,
+            signedAddresses: tx.signedAddresses,
+            rejectedAddresses: tx.rejectedAddresses,
+            creatorAddress: sessionAddress,
+            description: tx.description,
+          });
+        } catch (error) {
+          console.error("Failed to enqueue transaction notifications", error);
+        }
+      }
       return tx;
     }),
 
@@ -549,6 +565,19 @@ export const transactionRouter = createTRPCRouter({
           existingSigners: signedAddresses.length,
         },
       });
+      try {
+        await enqueueSignatureRequiredNotifications(ctx.db, {
+          wallet,
+          resourceType: "transaction",
+          resourceId: created.id,
+          signedAddresses: created.signedAddresses,
+          rejectedAddresses: created.rejectedAddresses,
+          creatorAddress: sessionAddress,
+          description: created.description,
+        });
+      } catch (error) {
+        console.error("Failed to enqueue imported transaction notifications", error);
+      }
       return created;
     }),
 });