feat(email): add Resend as primary email provider, keep Mailgun as fallback

Resend is used when RESEND_API_KEY is configured; falls back to Mailgun
if only MAILGUN vars are set. Adds email router index module with tests.
Also fixes @noble/curves v2 import path in SDK wallet module.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: ralyodio

.env.example

@@ -77,9 +77,8 @@ CRON_SECRET=your-cron-secret-here
 NODE_ENV=development
 PORT=8080
 
-# Mailgun for Email
-MAILGUN_API_KEY=your-mailgun-api-key
-MAILGUN_DOMAIN=mg.example.com
+# Resend for Email
+RESEND_API_KEY=your-resend-api-key
 REPLY_TO_EMAIL=support@example.com
 
 # WalletConnect / Reown AppKit

PROGRESS.md

@@ -109,7 +109,7 @@
 - Forwarding Service: 23 tests
 
 #### 11. **Email Notifications** (Complete)
-- [x] Mailgun integration
+- [x] Resend integration
 - [x] Email templates for payment events
 
 **Test Coverage:**
@@ -208,7 +208,7 @@ Test Duration: ~9 seconds
 - `src/lib/business/service.ts` + tests (19 tests)
 - `src/lib/wallets/service.ts` + tests (20 tests)
 - `src/lib/webhooks/service.ts` + tests (21 tests)
-- `src/lib/email/mailgun.ts` + tests (10 tests)
+- `src/lib/email/resend.ts` + tests (9 tests)
 - `src/lib/settings/service.ts` + tests (8 tests)
 - `src/lib/analytics.ts` + tests (11 tests)
 - `src/lib/blockchain/providers.ts`
@@ -303,9 +303,8 @@ ETHEREUM_RPC_URL=https://eth.llamarpc.com
 POLYGON_RPC_URL=https://polygon-rpc.com
 SOLANA_RPC_URL=https://api.mainnet-beta.solana.com
 
-# Email (Mailgun)
-MAILGUN_API_KEY=your_mailgun_api_key
-MAILGUN_DOMAIN=your_mailgun_domain
+# Email (Resend)
+RESEND_API_KEY=your_resend_api_key
 ```
 
 ---

packages/sdk/src/wallet.js

@@ -9,7 +9,7 @@
 import * as bip39 from '@scure/bip39';
 import { wordlist } from '@scure/bip39/wordlists/english';
 import { HDKey } from '@scure/bip32';
-import { secp256k1 } from '@noble/curves/secp256k1';
+import { secp256k1 } from '@noble/curves/secp256k1.js';
 import { sha256 } from '@noble/hashes/sha2.js';
 import { ripemd160 } from '@noble/hashes/ripemd160.js';
 import { keccak_256 } from '@noble/hashes/sha3.js';

src/app/settings/page.tsx

@@ -377,7 +377,7 @@ export default function SettingsPage() {
         {/* Additional Info */}
         <div className="mt-6 text-center text-sm text-gray-500">
           <p>
-            Email notifications are powered by Mailgun and sent to your
+            Email notifications are sent to your
             registered email address.
           </p>
         </div>

src/lib/email/index.test.ts

@@ -0,0 +1,85 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+
+// Mock the provider modules
+vi.mock('./resend', () => ({
+  sendEmail: vi.fn().mockResolvedValue({ success: true, messageId: 'resend_123' }),
+  sendBulkEmails: vi.fn().mockResolvedValue([{ success: true, messageId: 'resend_123' }]),
+}));
+
+vi.mock('./mailgun', () => ({
+  sendEmail: vi.fn().mockResolvedValue({ success: true, messageId: 'mailgun_123' }),
+  sendBulkEmails: vi.fn().mockResolvedValue([{ success: true, messageId: 'mailgun_123' }]),
+}));
+
+import { sendEmail, sendBulkEmails } from './index';
+import { sendEmail as resendSendEmail, sendBulkEmails as resendSendBulkEmails } from './resend';
+import { sendEmail as mailgunSendEmail, sendBulkEmails as mailgunSendBulkEmails } from './mailgun';
+
+const testEmail = {
+  to: 'merchant@example.com',
+  subject: 'Test Email',
+  html: '<p>Test content</p>',
+};
+
+describe('Email Service Router', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    delete process.env.RESEND_API_KEY;
+    delete process.env.MAILGUN_API_KEY;
+  });
+
+  describe('sendEmail', () => {
+    it('should use Resend when RESEND_API_KEY is set', async () => {
+      process.env.RESEND_API_KEY = 'test-resend-key';
+
+      const result = await sendEmail(testEmail);
+
+      expect(resendSendEmail).toHaveBeenCalledWith(testEmail);
+      expect(mailgunSendEmail).not.toHaveBeenCalled();
+      expect(result.messageId).toBe('resend_123');
+    });
+
+    it('should fall back to Mailgun when RESEND_API_KEY is not set', async () => {
+      process.env.MAILGUN_API_KEY = 'test-mailgun-key';
+
+      const result = await sendEmail(testEmail);
+
+      expect(mailgunSendEmail).toHaveBeenCalledWith(testEmail);
+      expect(resendSendEmail).not.toHaveBeenCalled();
+      expect(result.messageId).toBe('mailgun_123');
+    });
+
+    it('should prefer Resend when both are configured', async () => {
+      process.env.RESEND_API_KEY = 'test-resend-key';
+      process.env.MAILGUN_API_KEY = 'test-mailgun-key';
+
+      const result = await sendEmail(testEmail);
+
+      expect(resendSendEmail).toHaveBeenCalledWith(testEmail);
+      expect(mailgunSendEmail).not.toHaveBeenCalled();
+      expect(result.messageId).toBe('resend_123');
+    });
+  });
+
+  describe('sendBulkEmails', () => {
+    const emails = [testEmail, { ...testEmail, to: 'other@example.com' }];
+
+    it('should use Resend for bulk when RESEND_API_KEY is set', async () => {
+      process.env.RESEND_API_KEY = 'test-resend-key';
+
+      await sendBulkEmails(emails);
+
+      expect(resendSendBulkEmails).toHaveBeenCalledWith(emails);
+      expect(mailgunSendBulkEmails).not.toHaveBeenCalled();
+    });
+
+    it('should fall back to Mailgun for bulk when RESEND_API_KEY is not set', async () => {
+      process.env.MAILGUN_API_KEY = 'test-mailgun-key';
+
+      await sendBulkEmails(emails);
+
+      expect(mailgunSendBulkEmails).toHaveBeenCalledWith(emails);
+      expect(resendSendBulkEmails).not.toHaveBeenCalled();
+    });
+  });
+});

src/lib/email/index.ts

@@ -0,0 +1,31 @@
+/**
+ * Email Service
+ *
+ * Routes to Resend (preferred) or Mailgun based on which env vars are set.
+ * Resend is used when RESEND_API_KEY is configured.
+ * Mailgun is used as a fallback when only MAILGUN_API_KEY + MAILGUN_DOMAIN are configured.
+ */
+
+import { sendEmail as resendSendEmail, sendBulkEmails as resendSendBulkEmails } from './resend';
+import { sendEmail as mailgunSendEmail, sendBulkEmails as mailgunSendBulkEmails } from './mailgun';
+import type { SendEmailInput, SendEmailResult } from './resend';
+
+export type { SendEmailInput, SendEmailResult };
+
+function useResend(): boolean {
+  return !!process.env.RESEND_API_KEY;
+}
+
+export async function sendEmail(input: SendEmailInput): Promise<SendEmailResult> {
+  if (useResend()) {
+    return resendSendEmail(input);
+  }
+  return mailgunSendEmail(input);
+}
+
+export async function sendBulkEmails(emails: SendEmailInput[]): Promise<SendEmailResult[]> {
+  if (useResend()) {
+    return resendSendBulkEmails(emails);
+  }
+  return mailgunSendBulkEmails(emails);
+}

src/lib/email/resend.test.ts

@@ -0,0 +1,162 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { sendEmail } from './resend';
+
+// Mock fetch globally
+global.fetch = vi.fn();
+
+describe('Resend Email Service', () => {
+  beforeEach(() => {
+    vi.clearAllMocks();
+    // Set required environment variables
+    process.env.RESEND_API_KEY = 'test-api-key';
+    process.env.REPLY_TO_EMAIL = 'support@example.com';
+  });
+
+  describe('sendEmail', () => {
+    it('should send email successfully', async () => {
+      const mockResponse = {
+        ok: true,
+        json: async () => ({ id: 'msg_123' }),
+      };
+      (global.fetch as any).mockResolvedValue(mockResponse);
+
+      const result = await sendEmail({
+        to: 'merchant@example.com',
+        subject: 'Test Email',
+        html: '<p>Test content</p>',
+      });
+
+      expect(result.success).toBe(true);
+      expect(result.messageId).toBe('msg_123');
+      expect(global.fetch).toHaveBeenCalledTimes(1);
+
+      const fetchCall = (global.fetch as any).mock.calls[0];
+      expect(fetchCall[0]).toBe('https://api.resend.com/emails');
+      expect(fetchCall[1].method).toBe('POST');
+      expect(fetchCall[1].headers['Content-Type']).toBe('application/json');
+      expect(fetchCall[1].headers['Authorization']).toBe('Bearer test-api-key');
+    });
+
+    it('should handle missing API key', async () => {
+      delete process.env.RESEND_API_KEY;
+
+      const result = await sendEmail({
+        to: 'merchant@example.com',
+        subject: 'Test Email',
+        html: '<p>Test content</p>',
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('Resend API key');
+      expect(global.fetch).not.toHaveBeenCalled();
+    });
+
+    it('should validate email address', async () => {
+      const result = await sendEmail({
+        to: 'invalid-email',
+        subject: 'Test Email',
+        html: '<p>Test content</p>',
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('Invalid email address');
+      expect(global.fetch).not.toHaveBeenCalled();
+    });
+
+    it('should validate subject is not empty', async () => {
+      const result = await sendEmail({
+        to: 'merchant@example.com',
+        subject: '',
+        html: '<p>Test content</p>',
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('Subject is required');
+      expect(global.fetch).not.toHaveBeenCalled();
+    });
+
+    it('should validate HTML content is not empty', async () => {
+      const result = await sendEmail({
+        to: 'merchant@example.com',
+        subject: 'Test Email',
+        html: '',
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('HTML content is required');
+      expect(global.fetch).not.toHaveBeenCalled();
+    });
+
+    it('should handle Resend API errors', async () => {
+      const mockResponse = {
+        ok: false,
+        status: 400,
+        json: async () => ({ message: 'Invalid request' }),
+      };
+      (global.fetch as any).mockResolvedValue(mockResponse);
+
+      const result = await sendEmail({
+        to: 'merchant@example.com',
+        subject: 'Test Email',
+        html: '<p>Test content</p>',
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('Invalid request');
+    });
+
+    it('should handle network errors', async () => {
+      (global.fetch as any).mockRejectedValue(new Error('Network error'));
+
+      const result = await sendEmail({
+        to: 'merchant@example.com',
+        subject: 'Test Email',
+        html: '<p>Test content</p>',
+      });
+
+      expect(result.success).toBe(false);
+      expect(result.error).toContain('Network error');
+    });
+
+    it('should send correct JSON body', async () => {
+      const mockResponse = {
+        ok: true,
+        json: async () => ({ id: 'msg_123' }),
+      };
+      (global.fetch as any).mockResolvedValue(mockResponse);
+
+      await sendEmail({
+        to: 'merchant@example.com',
+        subject: 'Test Email',
+        html: '<p>Test content</p>',
+      });
+
+      const fetchCall = (global.fetch as any).mock.calls[0];
+      const body = JSON.parse(fetchCall[1].body);
+      expect(body.to).toEqual(['merchant@example.com']);
+      expect(body.subject).toBe('Test Email');
+      expect(body.html).toBe('<p>Test content</p>');
+      expect(body.reply_to).toBe('support@example.com');
+      expect(body.from).toContain('CoinPay');
+    });
+
+    it('should use custom from address when provided', async () => {
+      const mockResponse = {
+        ok: true,
+        json: async () => ({ id: 'msg_123' }),
+      };
+      (global.fetch as any).mockResolvedValue(mockResponse);
+
+      await sendEmail({
+        to: 'merchant@example.com',
+        subject: 'Test Email',
+        html: '<p>Test content</p>',
+        from: 'Custom <custom@example.com>',
+      });
+
+      const fetchCall = (global.fetch as any).mock.calls[0];
+      const body = JSON.parse(fetchCall[1].body);
+      expect(body.from).toBe('Custom <custom@example.com>');
+    });
+  });
+});