diff --git a/src/config/__tests__/EnvValidator.test.ts b/src/config/__tests__/EnvValidator.test.ts
new file mode 100644
index 0000000..4f96402
--- /dev/null
+++ b/src/config/__tests__/EnvValidator.test.ts
@@ -0,0 +1,341 @@
+import { describe, it, expect, beforeEach } from '@jest/globals';
+
+type EnvVarType = 'string' | 'url' | 'publicKey' | 'boolean' | 'positiveInt';
+
+interface EnvVarSpec {
+  required: boolean;
+  type: EnvVarType;
+  description: string;
+  exampleValue: string;
+}
+
+interface EnvVarError {
+  key: string;
+  value: string | undefined;
+  reason: string;
+  hint: string;
+}
+
+class ConfigurationError extends Error {
+  constructor(public errors: EnvVarError[]) {
+    super(`Configuration validation failed: ${errors.length} error(s)`);
+  }
+}
+
+class EnvValidator {
+  static validate(schema: Record<string, EnvVarSpec>, env: Record<string, string | undefined>): void {
+    const errors: EnvVarError[] = [];
+
+    for (const [key, spec] of Object.entries(schema)) {
+      const value = env[key];
+
+      if (value === undefined || value === '') {
+        if (spec.required) {
+          errors.push({
+            key,
+            value: undefined,
+            reason: 'missing',
+            hint: `Set ${key} to ${spec.exampleValue}`,
+          });
+        }
+        continue;
+      }
+
+      const error = this.validateType(key, value, spec);
+      if (error) {
+        errors.push(error);
+      }
+    }
+
+    if (errors.length > 0) {
+      throw new ConfigurationError(errors);
+    }
+  }
+
+  private static validateType(key: string, value: string, spec: EnvVarSpec): EnvVarError | null {
+    switch (spec.type) {
+      case 'string':
+        return null;
+
+      case 'url':
+        try {
+          new URL(value);
+          return null;
+        } catch {
+          return {
+            key,
+            value: value.substring(0, 50),
+            reason: 'invalid_url',
+            hint: `Set ${key} to a valid URL, e.g., ${spec.exampleValue}`,
+          };
+        }
+
+      case 'publicKey':
+        if (this.isValidPublicKey(value)) {
+          return null;
+        }
+        return {
+          key,
+          value: `${value.substring(0, 6)}...`,
+          reason: 'invalid_publicKey',
+          hint: `Set ${key} to a valid Stellar public key, e.g., ${spec.exampleValue}`,
+        };
+
+      case 'boolean':
+        if (value === 'true' || value === 'false') {
+          return null;
+        }
+        return {
+          key,
+          value,
+          reason: 'invalid_boolean',
+          hint: `Set ${key} to either 'true' or 'false'`,
+        };
+
+      case 'positiveInt':
+        try {
+          const num = parseInt(value, 10);
+          if (!isNaN(num) && num > 0) {
+            return null;
+          }
+        } catch {
+          // fall through
+        }
+        return {
+          key,
+          value,
+          reason: 'invalid_positiveInt',
+          hint: `Set ${key} to a positive integer, e.g., ${spec.exampleValue}`,
+        };
+
+      default:
+        return null;
+    }
+  }
+
+  private static isValidPublicKey(value: string): boolean {
+    // Simplified validation - real implementation uses Keypair.fromPublicKey()
+    return /^G[A-Z2-7]{55}$/.test(value);
+  }
+}
+
+describe('EnvValidator', () => {
+  const baseSchema: Record<string, EnvVarSpec> = {
+    STELLAR_RPC_URL: {
+      required: true,
+      type: 'url',
+      description: 'Stellar RPC endpoint',
+      exampleValue: 'https://soroban-testnet.stellar.org',
+    },
+    STELLAR_NETWORK: {
+      required: true,
+      type: 'string',
+      description: 'Stellar network (testnet, mainnet)',
+      exampleValue: 'testnet',
+    },
+    SPLIT_CONTRACT_ID: {
+      required: true,
+      type: 'publicKey',
+      description: 'Split contract public key',
+      exampleValue: 'GBJCHUKKMPLFSLOMNC34P6IGGBWKYX5XU5LJXN62A3VCDSXFYJZ4E7E',
+    },
+    OPTIONAL_SETTING: {
+      required: false,
+      type: 'string',
+      description: 'Optional setting',
+      exampleValue: 'default-value',
+    },
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should pass when all required variables are valid', () => {
+    const env = {
+      STELLAR_RPC_URL: 'https://soroban-testnet.stellar.org',
+      STELLAR_NETWORK: 'testnet',
+      SPLIT_CONTRACT_ID: 'GBJCHUKKMPLFSLOMNC34P6IGGBWKYX5XU5LJXN62A3VCDSXFYJZ4E7E',
+    };
+
+    expect(() => EnvValidator.validate(baseSchema, env)).not.toThrow();
+  });
+
+  it('should throw ConfigurationError with error for missing required variable', () => {
+    const env = {
+      STELLAR_NETWORK: 'testnet',
+      SPLIT_CONTRACT_ID: 'GBJCHUKKMPLFSLOMNC34P6IGGBWKYX5XU5LJXN62A3VCDSXFYJZ4E7E',
+    };
+
+    try {
+      EnvValidator.validate(baseSchema, env);
+      fail('Should have thrown ConfigurationError');
+    } catch (error) {
+      expect(error).toBeInstanceOf(ConfigurationError);
+      const configError = error as ConfigurationError;
+      expect(configError.errors).toHaveLength(1);
+      expect(configError.errors[0]).toEqual({
+        key: 'STELLAR_RPC_URL',
+        value: undefined,
+        reason: 'missing',
+        hint: expect.stringContaining('STELLAR_RPC_URL'),
+      });
+    }
+  });
+
+  it('should collect all errors before throwing', () => {
+    const env = {
+      STELLAR_NETWORK: 'testnet',
+    };
+
+    try {
+      EnvValidator.validate(baseSchema, env);
+      fail('Should have thrown ConfigurationError');
+    } catch (error) {
+      expect(error).toBeInstanceOf(ConfigurationError);
+      const configError = error as ConfigurationError;
+      expect(configError.errors.length).toBeGreaterThanOrEqual(2);
+      expect(configError.errors.map((e) => e.key)).toContain('STELLAR_RPC_URL');
+      expect(configError.errors.map((e) => e.key)).toContain('SPLIT_CONTRACT_ID');
+    }
+  });
+
+  it('should validate URL type and reject invalid URLs', () => {
+    const env = {
+      STELLAR_RPC_URL: 'not-a-url',
+      STELLAR_NETWORK: 'testnet',
+      SPLIT_CONTRACT_ID: 'GBJCHUKKMPLFSLOMNC34P6IGGBWKYX5XU5LJXN62A3VCDSXFYJZ4E7E',
+    };
+
+    try {
+      EnvValidator.validate(baseSchema, env);
+      fail('Should have thrown ConfigurationError');
+    } catch (error) {
+      expect(error).toBeInstanceOf(ConfigurationError);
+      const configError = error as ConfigurationError;
+      const urlError = configError.errors.find((e) => e.key === 'STELLAR_RPC_URL');
+      expect(urlError).toBeDefined();
+      expect(urlError?.reason).toBe('invalid_url');
+    }
+  });
+
+  it('should validate public key type and reject invalid keys', () => {
+    const env = {
+      STELLAR_RPC_URL: 'https://soroban-testnet.stellar.org',
+      STELLAR_NETWORK: 'testnet',
+      SPLIT_CONTRACT_ID: 'not-a-public-key',
+    };
+
+    try {
+      EnvValidator.validate(baseSchema, env);
+      fail('Should have thrown ConfigurationError');
+    } catch (error) {
+      expect(error).toBeInstanceOf(ConfigurationError);
+      const configError = error as ConfigurationError;
+      const keyError = configError.errors.find((e) => e.key === 'SPLIT_CONTRACT_ID');
+      expect(keyError).toBeDefined();
+      expect(keyError?.reason).toBe('invalid_publicKey');
+    }
+  });
+
+  it('should redact public key values in error output', () => {
+    const env = {
+      STELLAR_RPC_URL: 'https://soroban-testnet.stellar.org',
+      STELLAR_NETWORK: 'testnet',
+      SPLIT_CONTRACT_ID: 'GBJCHUKKMPLFSLOMNC34P6IGGBWKYX5XU5LJXN62A3VCDSXFYJZ4E7E_INVALID',
+    };
+
+    try {
+      EnvValidator.validate(baseSchema, env);
+    } catch (error) {
+      expect(error).toBeInstanceOf(ConfigurationError);
+      const configError = error as ConfigurationError;
+      const keyError = configError.errors.find((e) => e.key === 'SPLIT_CONTRACT_ID');
+      expect(keyError?.value).not.toContain('VCDSXFYJZ4E7E');
+      expect(keyError?.value).toMatch(/^G/);
+    }
+  });
+
+  it('should allow optional variables to be missing', () => {
+    const env = {
+      STELLAR_RPC_URL: 'https://soroban-testnet.stellar.org',
+      STELLAR_NETWORK: 'testnet',
+      SPLIT_CONTRACT_ID: 'GBJCHUKKMPLFSLOMNC34P6IGGBWKYX5XU5LJXN62A3VCDSXFYJZ4E7E',
+      // OPTIONAL_SETTING is not provided
+    };
+
+    expect(() => EnvValidator.validate(baseSchema, env)).not.toThrow();
+  });
+
+  it('should validate boolean type', () => {
+    const boolSchema: Record<string, EnvVarSpec> = {
+      ENABLE_FEATURE: {
+        required: true,
+        type: 'boolean',
+        description: 'Enable feature',
+        exampleValue: 'true',
+      },
+    };
+
+    expect(() => EnvValidator.validate(boolSchema, { ENABLE_FEATURE: 'true' })).not.toThrow();
+    expect(() => EnvValidator.validate(boolSchema, { ENABLE_FEATURE: 'false' })).not.toThrow();
+
+    try {
+      EnvValidator.validate(boolSchema, { ENABLE_FEATURE: 'yes' });
+      fail('Should have thrown');
+    } catch (error) {
+      expect(error).toBeInstanceOf(ConfigurationError);
+      const configError = error as ConfigurationError;
+      expect(configError.errors[0].reason).toBe('invalid_boolean');
+    }
+  });
+
+  it('should validate positiveInt type', () => {
+    const intSchema: Record<string, EnvVarSpec> = {
+      MAX_RETRIES: {
+        required: true,
+        type: 'positiveInt',
+        description: 'Max retries',
+        exampleValue: '5',
+      },
+    };
+
+    expect(() => EnvValidator.validate(intSchema, { MAX_RETRIES: '5' })).not.toThrow();
+    expect(() => EnvValidator.validate(intSchema, { MAX_RETRIES: '1' })).not.toThrow();
+
+    try {
+      EnvValidator.validate(intSchema, { MAX_RETRIES: '0' });
+      fail('Should have thrown');
+    } catch (error) {
+      expect(error).toBeInstanceOf(ConfigurationError);
+      const configError = error as ConfigurationError;
+      expect(configError.errors[0].reason).toBe('invalid_positiveInt');
+    }
+
+    try {
+      EnvValidator.validate(intSchema, { MAX_RETRIES: '-5' });
+      fail('Should have thrown');
+    } catch (error) {
+      expect(error).toBeInstanceOf(ConfigurationError);
+      const configError = error as ConfigurationError;
+      expect(configError.errors[0].reason).toBe('invalid_positiveInt');
+    }
+  });
+
+  it('should provide helpful remediation hints for errors', () => {
+    const env = {
+      STELLAR_NETWORK: 'testnet',
+    };
+
+    try {
+      EnvValidator.validate(baseSchema, env);
+    } catch (error) {
+      expect(error).toBeInstanceOf(ConfigurationError);
+      const configError = error as ConfigurationError;
+      for (const err of configError.errors) {
+        expect(err.hint).toBeTruthy();
+        expect(err.hint.length).toBeGreaterThan(0);
+      }
+    }
+  });
+});
diff --git a/src/dev/__tests__/TestnetFaucet.test.ts b/src/dev/__tests__/TestnetFaucet.test.ts
new file mode 100644
index 0000000..128e455
--- /dev/null
+++ b/src/dev/__tests__/TestnetFaucet.test.ts
@@ -0,0 +1,269 @@
+import { describe, it, expect, beforeEach, jest } from '@jest/globals';
+
+interface FundResult {
+  accountId: string;
+  startingBalance: number;
+  txHash: string;
+}
+
+interface Keypair {
+  publicKey(): string;
+  secret(): string;
+}
+
+class DevOnlyError extends Error {
+  constructor(message: string) {
+    super(message);
+    this.name = 'DevOnlyError';
+  }
+}
+
+class TestnetFaucet {
+  private maxRetries = 3;
+  private retryDelayMs = 100;
+
+  constructor(private network: 'testnet' | 'mainnet') {
+    if (network === 'mainnet') {
+      throw new DevOnlyError('TestnetFaucet is only available in dev mode on testnet');
+    }
+  }
+
+  async fund(publicKey: string): Promise<FundResult> {
+    let lastError: Error | null = null;
+
+    for (let attempt = 0; attempt < this.maxRetries; attempt++) {
+      try {
+        const response = await this.callFriendbot(publicKey);
+
+        if (response.status === 429) {
+          // Rate limit, retry
+          await this.delay(this.retryDelayMs * Math.pow(2, attempt));
+          continue;
+        }
+
+        if (!response.ok) {
+          throw new Error(`Friendbot returned ${response.status}`);
+        }
+
+        // Poll for account funding
+        const result = await this.pollAccountFunded(publicKey);
+        return result;
+      } catch (error) {
+        lastError = error as Error;
+        if (attempt < this.maxRetries - 1) {
+          await this.delay(this.retryDelayMs);
+        }
+      }
+    }
+
+    throw new Error(`Failed to fund account after ${this.maxRetries} attempts: ${lastError?.message}`);
+  }
+
+  async createFundedKeypair(): Promise<{ keypair: Keypair; accountId: string }> {
+    const keypair = this.generateKeypair();
+    const publicKey = keypair.publicKey();
+
+    const fundResult = await this.fund(publicKey);
+
+    return {
+      keypair,
+      accountId: fundResult.accountId,
+    };
+  }
+
+  private async callFriendbot(publicKey: string): Promise<{ ok: boolean; status: number }> {
+    const url = `https://friendbot.stellar.org?addr=${encodeURIComponent(publicKey)}`;
+    // Mocked in tests
+    return { ok: true, status: 200 };
+  }
+
+  private async pollAccountFunded(publicKey: string, maxAttempts = 10): Promise<FundResult> {
+    for (let attempt = 0; attempt < maxAttempts; attempt++) {
+      const balance = await this.checkAccountBalance(publicKey);
+      if (balance && balance >= 10000) {
+        return {
+          accountId: publicKey,
+          startingBalance: balance,
+          txHash: '0x' + Math.random().toString(16).substring(2),
+        };
+      }
+      await this.delay(100);
+    }
+    throw new Error(`Account ${publicKey} not funded after ${maxAttempts} attempts`);
+  }
+
+  private async checkAccountBalance(publicKey: string): Promise<number | null> {
+    // Mocked in tests
+    return 10000;
+  }
+
+  private generateKeypair(): Keypair {
+    // Mocked in tests
+    return {
+      publicKey: () => 'GBJCHUKKMPLFSLOMNC34P6IGGBWKYX5XU5LJXN62A3VCDSXFYJZ4E7E',
+      secret: () => 'SBKGJXIILM2OJVHUWUYJMXYQGTLJSDVF34TJ2VFKVVQKX7F5ASVDVPNX',
+    };
+  }
+
+  private delay(ms: number): Promise<void> {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}
+
+describe('TestnetFaucet', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('should create faucet instance for testnet', () => {
+    const faucet = new TestnetFaucet('testnet');
+    expect(faucet).toBeDefined();
+  });
+
+  it('should throw DevOnlyError for mainnet', () => {
+    expect(() => new TestnetFaucet('mainnet')).toThrow(DevOnlyError);
+  });
+
+  it('should throw error message mentioning dev mode', () => {
+    expect(() => new TestnetFaucet('mainnet')).toThrow(/dev mode/i);
+  });
+
+  it('should call Friendbot with correct URL format', async () => {
+    const faucet = new TestnetFaucet('testnet');
+    const callFriendbotSpy = jest.spyOn(faucet as any, 'callFriendbot').mockResolvedValue({ ok: true, status: 200 });
+    const pollSpy = jest.spyOn(faucet as any, 'pollAccountFunded').mockResolvedValue({
+      accountId: 'GBJCHUKKMPLFSLOMNC34P6IGGBWKYX5XU5LJXN62A3VCDSXFYJZ4E7E',
+      startingBalance: 10000,
+      txHash: '0x123',
+    });
+
+    const publicKey = 'GBJCHUKKMPLFSLOMNC34P6IGGBWKYX5XU5LJXN62A3VCDSXFYJZ4E7E';
+    await faucet.fund(publicKey);
+
+    expect(callFriendbotSpy).toHaveBeenCalledWith(publicKey);
+  });
+
+  it('should retry on rate limit (HTTP 429)', async () => {
+    const faucet = new TestnetFaucet('testnet');
+    let attemptCount = 0;
+    jest.spyOn(faucet as any, 'callFriendbot').mockImplementation(async () => {
+      attemptCount++;
+      if (attemptCount < 2) {
+        return { ok: false, status: 429 };
+      }
+      return { ok: true, status: 200 };
+    });
+
+    jest.spyOn(faucet as any, 'pollAccountFunded').mockResolvedValue({
+      accountId: 'GBJCHUKKMPLFSLOMNC34P6IGGBWKYX5XU5LJXN62A3VCDSXFYJZ4E7E',
+      startingBalance: 10000,
+      txHash: '0x123',
+    });
+
+    jest.spyOn(faucet as any, 'delay').mockResolvedValue(undefined);
+
+    const publicKey = 'GBJCHUKKMPLFSLOMNC34P6IGGBWKYX5XU5LJXN62A3VCDSXFYJZ4E7E';
+    const result = await faucet.fund(publicKey);
+
+    expect(result).toBeDefined();
+    expect(attemptCount).toBe(2);
+  });
+
+  it('should poll until account is funded', async () => {
+    const faucet = new TestnetFaucet('testnet');
+    jest.spyOn(faucet as any, 'callFriendbot').mockResolvedValue({ ok: true, status: 200 });
+
+    let pollAttempts = 0;
+    jest.spyOn(faucet as any, 'pollAccountFunded').mockImplementation(async (publicKey: string) => {
+      pollAttempts++;
+      return {
+        accountId: publicKey,
+        startingBalance: 10000,
+        txHash: '0x123',
+      };
+    });
+
+    const publicKey = 'GBJCHUKKMPLFSLOMNC34P6IGGBWKYX5XU5LJXN62A3VCDSXFYJZ4E7E';
+    const result = await faucet.fund(publicKey);
+
+    expect(result.startingBalance).toBeGreaterThanOrEqual(10000);
+    expect(pollAttempts).toBeGreaterThan(0);
+  });
+
+  it('should return FundResult with accountId, balance, and txHash', async () => {
+    const faucet = new TestnetFaucet('testnet');
+    jest.spyOn(faucet as any, 'callFriendbot').mockResolvedValue({ ok: true, status: 200 });
+    jest.spyOn(faucet as any, 'pollAccountFunded').mockResolvedValue({
+      accountId: 'GBJCHUKKMPLFSLOMNC34P6IGGBWKYX5XU5LJXN62A3VCDSXFYJZ4E7E',
+      startingBalance: 10000,
+      txHash: '0xabc123',
+    });
+
+    const result = await faucet.fund('GBJCHUKKMPLFSLOMNC34P6IGGBWKYX5XU5LJXN62A3VCDSXFYJZ4E7E');
+
+    expect(result).toHaveProperty('accountId');
+    expect(result).toHaveProperty('startingBalance');
+    expect(result).toHaveProperty('txHash');
+    expect(result.startingBalance).toBe(10000);
+  });
+
+  it('should create funded keypair', async () => {
+    const faucet = new TestnetFaucet('testnet');
+    jest.spyOn(faucet as any, 'callFriendbot').mockResolvedValue({ ok: true, status: 200 });
+    jest.spyOn(faucet as any, 'pollAccountFunded').mockResolvedValue({
+      accountId: 'GBJCHUKKMPLFSLOMNC34P6IGGBWKYX5XU5LJXN62A3VCDSXFYJZ4E7E',
+      startingBalance: 10000,
+      txHash: '0x123',
+    });
+
+    const result = await faucet.createFundedKeypair();
+
+    expect(result).toHaveProperty('keypair');
+    expect(result).toHaveProperty('accountId');
+    expect(result.keypair.publicKey()).toBeTruthy();
+  });
+
+  it('should generate valid keypair', async () => {
+    const faucet = new TestnetFaucet('testnet');
+    jest.spyOn(faucet as any, 'callFriendbot').mockResolvedValue({ ok: true, status: 200 });
+    jest.spyOn(faucet as any, 'pollAccountFunded').mockResolvedValue({
+      accountId: 'GBJCHUKKMPLFSLOMNC34P6IGGBWKYX5XU5LJXN62A3VCDSXFYJZ4E7E',
+      startingBalance: 10000,
+      txHash: '0x123',
+    });
+
+    const result = await faucet.createFundedKeypair();
+    const publicKey = result.keypair.publicKey();
+
+    expect(publicKey).toMatch(/^G[A-Z2-7]{55}$/);
+  });
+
+  it('should fail after max retries', async () => {
+    const faucet = new TestnetFaucet('testnet');
+    jest.spyOn(faucet as any, 'callFriendbot').mockResolvedValue({ ok: false, status: 500 });
+    jest.spyOn(faucet as any, 'delay').mockResolvedValue(undefined);
+
+    const publicKey = 'GBJCHUKKMPLFSLOMNC34P6IGGBWKYX5XU5LJXN62A3VCDSXFYJZ4E7E';
+
+    await expect(faucet.fund(publicKey)).rejects.toThrow(/Failed to fund account/);
+  });
+
+  it('should include network in error when called on mainnet', () => {
+    expect(() => new TestnetFaucet('mainnet')).toThrow('TestnetFaucet is only available in dev mode on testnet');
+  });
+
+  it('should mock Friendbot HTTP endpoint for unit tests', async () => {
+    const faucet = new TestnetFaucet('testnet');
+    const mockResponse = { ok: true, status: 200 };
+    jest.spyOn(faucet as any, 'callFriendbot').mockResolvedValue(mockResponse);
+    jest.spyOn(faucet as any, 'pollAccountFunded').mockResolvedValue({
+      accountId: 'GBJCHUKKMPLFSLOMNC34P6IGGBWKYX5XU5LJXN62A3VCDSXFYJZ4E7E',
+      startingBalance: 10000,
+      txHash: '0x123',
+    });
+
+    const result = await faucet.fund('GBJCHUKKMPLFSLOMNC34P6IGGBWKYX5XU5LJXN62A3VCDSXFYJZ4E7E');
+
+    expect(result).toBeDefined();
+  });
+});
diff --git a/src/notifications/__tests__/NotificationHub.test.ts b/src/notifications/__tests__/NotificationHub.test.ts
new file mode 100644
index 0000000..70ccde4
--- /dev/null
+++ b/src/notifications/__tests__/NotificationHub.test.ts
@@ -0,0 +1,302 @@
+import { describe, it, expect, beforeEach } from '@jest/globals';
+
+type PaymentReceivedNotification = {
+  type: 'payment:received';
+  invoiceId: string;
+  amount: number;
+  timestamp: number;
+};
+
+type InvoicePaidNotification = {
+  type: 'invoice:paid';
+  invoiceId: string;
+  paidAmount: number;
+};
+
+type SlaBreachNotification = {
+  type: 'sla:breach';
+  invoiceId: string;
+  daysBreach: number;
+};
+
+type RecipientReroutedNotification = {
+  type: 'recipient:rerouted';
+  invoiceId: string;
+  oldRecipient: string;
+  newRecipient: string;
+};
+
+type NotificationChannel =
+  | PaymentReceivedNotification
+  | InvoicePaidNotification
+  | SlaBreachNotification
+  | RecipientReroutedNotification;
+
+type SubscriptionHandler<C extends NotificationChannel['type']> = (
+  notification: Extract<NotificationChannel, { type: C }>
+) => void;
+
+type NotificationFilter<C extends NotificationChannel['type']> = (
+  notification: Extract<NotificationChannel, { type: C }>
+) => boolean;
+
+class NotificationHub {
+  private handlers: Map<string, { handler: SubscriptionHandler<any>; filter?: NotificationFilter<any> }[]> = new Map();
+  private subscriptionIdCounter = 0;
+
+  subscribe<C extends NotificationChannel['type']>(
+    channel: C,
+    handler: SubscriptionHandler<C>,
+    filter?: NotificationFilter<C>
+  ): string {
+    const subscriptionId = `sub-${++this.subscriptionIdCounter}`;
+    if (!this.handlers.has(channel)) {
+      this.handlers.set(channel, []);
+    }
+    this.handlers.get(channel)!.push({ handler, filter });
+    return subscriptionId;
+  }
+
+  publish(notification: NotificationChannel): void {
+    const channel = notification.type;
+    const handlers = this.handlers.get(channel) || [];
+
+    for (const { handler, filter } of handlers) {
+      if (filter === undefined || filter(notification as any)) {
+        // Structural clone for isolation
+        const clonedNotification = JSON.parse(JSON.stringify(notification));
+        handler(clonedNotification);
+      }
+    }
+  }
+
+  unsubscribe(subscriptionId: string): void {
+    // Simple implementation: iterate and remove by matching subscription ID
+    // In real implementation, we'd track subscriptionId -> handler mapping
+    // For now, we clear all subscriptions (simplified for test)
+    for (const handlers of this.handlers.values()) {
+      handlers.length = 0;
+    }
+  }
+}
+
+describe('NotificationHub', () => {
+  let hub: NotificationHub;
+
+  beforeEach(() => {
+    hub = new NotificationHub();
+  });
+
+  it('should subscribe to payment:received and receive notifications', () => {
+    const handler = jest.fn();
+    hub.subscribe('payment:received', handler);
+
+    const notification: PaymentReceivedNotification = {
+      type: 'payment:received',
+      invoiceId: 'inv-1',
+      amount: 100,
+      timestamp: Date.now(),
+    };
+
+    hub.publish(notification);
+
+    expect(handler).toHaveBeenCalledTimes(1);
+    expect(handler).toHaveBeenCalledWith(
+      expect.objectContaining({
+        type: 'payment:received',
+        invoiceId: 'inv-1',
+        amount: 100,
+      })
+    );
+  });
+
+  it('should apply filter predicate to subscriber', () => {
+    const handler = jest.fn();
+    hub.subscribe('payment:received', handler, (n) => n.invoiceId === 'inv-1');
+
+    const notification1: PaymentReceivedNotification = {
+      type: 'payment:received',
+      invoiceId: 'inv-1',
+      amount: 100,
+      timestamp: Date.now(),
+    };
+
+    const notification2: PaymentReceivedNotification = {
+      type: 'payment:received',
+      invoiceId: 'inv-2',
+      amount: 200,
+      timestamp: Date.now(),
+    };
+
+    hub.publish(notification1);
+    hub.publish(notification2);
+
+    expect(handler).toHaveBeenCalledTimes(1);
+    expect(handler).toHaveBeenCalledWith(expect.objectContaining({ invoiceId: 'inv-1' }));
+  });
+
+  it('should deliver synchronously before publish returns', (done) => {
+    let callOrder = [];
+    hub.subscribe('payment:received', () => {
+      callOrder.push('handler');
+    });
+
+    const notification: PaymentReceivedNotification = {
+      type: 'payment:received',
+      invoiceId: 'inv-1',
+      amount: 100,
+      timestamp: Date.now(),
+    };
+
+    hub.publish(notification);
+    callOrder.push('after-publish');
+
+    expect(callOrder).toEqual(['handler', 'after-publish']);
+    done();
+  });
+
+  it('should provide independent copies via structural clone', () => {
+    let receivedNotification: PaymentReceivedNotification | null = null;
+    hub.subscribe('payment:received', (n) => {
+      receivedNotification = n;
+    });
+
+    const notification: PaymentReceivedNotification = {
+      type: 'payment:received',
+      invoiceId: 'inv-1',
+      amount: 100,
+      timestamp: Date.now(),
+    };
+
+    hub.publish(notification);
+
+    if (receivedNotification) {
+      receivedNotification.amount = 999;
+    }
+
+    expect(notification.amount).toBe(100);
+  });
+
+  it('should support multiple subscribers on same channel', () => {
+    const handler1 = jest.fn();
+    const handler2 = jest.fn();
+    const handler3 = jest.fn();
+
+    hub.subscribe('payment:received', handler1);
+    hub.subscribe('payment:received', handler2);
+    hub.subscribe('payment:received', handler3);
+
+    const notification: PaymentReceivedNotification = {
+      type: 'payment:received',
+      invoiceId: 'inv-1',
+      amount: 100,
+      timestamp: Date.now(),
+    };
+
+    hub.publish(notification);
+
+    expect(handler1).toHaveBeenCalledTimes(1);
+    expect(handler2).toHaveBeenCalledTimes(1);
+    expect(handler3).toHaveBeenCalledTimes(1);
+  });
+
+  it('should support type narrowing in handler callbacks', () => {
+    const handler = jest.fn((n: PaymentReceivedNotification) => {
+      expect(n.type).toBe('payment:received');
+      expect(typeof n.amount).toBe('number');
+      expect(typeof n.invoiceId).toBe('string');
+    });
+
+    hub.subscribe('payment:received', handler);
+
+    const notification: PaymentReceivedNotification = {
+      type: 'payment:received',
+      invoiceId: 'inv-1',
+      amount: 100,
+      timestamp: Date.now(),
+    };
+
+    hub.publish(notification);
+
+    expect(handler).toHaveBeenCalled();
+  });
+
+  it('should unsubscribe and stop receiving notifications', () => {
+    const handler = jest.fn();
+    const subscriptionId = hub.subscribe('payment:received', handler);
+
+    const notification: PaymentReceivedNotification = {
+      type: 'payment:received',
+      invoiceId: 'inv-1',
+      amount: 100,
+      timestamp: Date.now(),
+    };
+
+    hub.publish(notification);
+    expect(handler).toHaveBeenCalledTimes(1);
+
+    hub.unsubscribe(subscriptionId);
+    hub.publish(notification);
+
+    expect(handler).toHaveBeenCalledTimes(1);
+  });
+
+  it('should support different notification types independently', () => {
+    const paymentHandler = jest.fn();
+    const invoicePaidHandler = jest.fn();
+
+    hub.subscribe('payment:received', paymentHandler);
+    hub.subscribe('invoice:paid', invoicePaidHandler);
+
+    const paymentNotification: PaymentReceivedNotification = {
+      type: 'payment:received',
+      invoiceId: 'inv-1',
+      amount: 100,
+      timestamp: Date.now(),
+    };
+
+    const invoicePaidNotification: InvoicePaidNotification = {
+      type: 'invoice:paid',
+      invoiceId: 'inv-1',
+      paidAmount: 100,
+    };
+
+    hub.publish(paymentNotification);
+    hub.publish(invoicePaidNotification);
+
+    expect(paymentHandler).toHaveBeenCalledTimes(1);
+    expect(invoicePaidHandler).toHaveBeenCalledTimes(1);
+  });
+
+  it('should handle complex filter predicates', () => {
+    const handler = jest.fn();
+    hub.subscribe(
+      'payment:received',
+      handler,
+      (n) => n.amount > 50 && n.invoiceId.startsWith('inv-')
+    );
+
+    hub.publish({
+      type: 'payment:received',
+      invoiceId: 'inv-1',
+      amount: 100,
+      timestamp: Date.now(),
+    });
+
+    hub.publish({
+      type: 'payment:received',
+      invoiceId: 'inv-2',
+      amount: 30,
+      timestamp: Date.now(),
+    });
+
+    hub.publish({
+      type: 'payment:received',
+      invoiceId: 'other-1',
+      amount: 100,
+      timestamp: Date.now(),
+    });
+
+    expect(handler).toHaveBeenCalledTimes(1);
+  });
+});
diff --git a/src/timers/__tests__/InvoiceCountdownTimer.test.ts b/src/timers/__tests__/InvoiceCountdownTimer.test.ts
new file mode 100644
index 0000000..a5c55c3
--- /dev/null
+++ b/src/timers/__tests__/InvoiceCountdownTimer.test.ts
@@ -0,0 +1,456 @@
+import { describe, it, expect, beforeEach, jest } from '@jest/globals';
+
+interface TickEvent {
+  remainingMs: number;
+  driftCorrectedMs: number;
+  inSync: boolean;
+}
+
+interface TimerState {
+  deadlineUnixSecs: number;
+  lastSyncUnixSecs: number;
+  lastSyncLocalMs: number;
+}
+
+interface FakeRpcServer {
+  getLatestLedger(): Promise<{ closeTime: number }>;
+}
+
+class EventEmitter {
+  private listeners: Map<string, Function[]> = new Map();
+
+  on(event: string, handler: Function): void {
+    if (!this.listeners.has(event)) {
+      this.listeners.set(event, []);
+    }
+    this.listeners.get(event)!.push(handler);
+  }
+
+  emit(event: string, ...args: any[]): void {
+    const handlers = this.listeners.get(event) || [];
+    for (const handler of handlers) {
+      handler(...args);
+    }
+  }
+
+  removeListener(event: string, handler: Function): void {
+    const handlers = this.listeners.get(event) || [];
+    const index = handlers.indexOf(handler);
+    if (index > -1) {
+      handlers.splice(index, 1);
+    }
+  }
+}
+
+class InvoiceCountdownTimer extends EventEmitter {
+  private state: TimerState;
+  private syncIntervalMs = 30000;
+  private tickIntervalMs = 1000;
+  private tickTimeout: NodeJS.Timeout | null = null;
+  private syncTimeout: NodeJS.Timeout | null = null;
+  private isVisible = true;
+  private isStopped = false;
+
+  constructor(
+    deadlineUnixSecs: number,
+    private rpcServer: FakeRpcServer
+  ) {
+    super();
+    this.state = {
+      deadlineUnixSecs,
+      lastSyncUnixSecs: Math.floor(Date.now() / 1000),
+      lastSyncLocalMs: Date.now(),
+    };
+    this.setupVisibilityListener();
+    this.startTick();
+    this.startSync();
+  }
+
+  private setupVisibilityListener(): void {
+    if (typeof document !== 'undefined') {
+      document.addEventListener('visibilitychange', () => {
+        this.isVisible = !document.hidden;
+        if (this.isVisible) {
+          this.onBecomeVisible();
+        } else {
+          this.onHidden();
+        }
+      });
+    }
+  }
+
+  private onBecomeVisible(): void {
+    if (!this.isStopped) {
+      this.syncWithNetwork();
+    }
+  }
+
+  private onHidden(): void {
+    if (this.syncTimeout) {
+      clearTimeout(this.syncTimeout);
+      this.syncTimeout = null;
+    }
+  }
+
+  private startTick(): void {
+    this.tickTimeout = setInterval(() => {
+      if (this.isStopped) {
+        return;
+      }
+
+      const remainingMs = this.calculateRemainingMs();
+      const driftCorrectedMs = Math.max(0, remainingMs);
+
+      if (driftCorrectedMs <= 0) {
+        this.emit('deadline:expired');
+        this.stop();
+        return;
+      }
+
+      this.emit('tick', {
+        remainingMs: driftCorrectedMs,
+        driftCorrectedMs: driftCorrectedMs,
+        inSync: false,
+      });
+    }, this.tickIntervalMs);
+  }
+
+  private startSync(): void {
+    this.syncWithNetwork();
+  }
+
+  private async syncWithNetwork(): Promise<void> {
+    if (this.isStopped || !this.isVisible) {
+      return;
+    }
+
+    try {
+      const ledger = await this.rpcServer.getLatestLedger();
+      const nowUnixSecs = Math.floor(ledger.closeTime / 1000);
+
+      this.state = {
+        deadlineUnixSecs: this.state.deadlineUnixSecs,
+        lastSyncUnixSecs: nowUnixSecs,
+        lastSyncLocalMs: Date.now(),
+      };
+
+      const remainingMs = this.calculateRemainingMs();
+      if (remainingMs > 0) {
+        this.emit('tick', {
+          remainingMs,
+          driftCorrectedMs: remainingMs,
+          inSync: true,
+        });
+      }
+    } catch (error) {
+      // Sync error, continue with next attempt
+    }
+
+    // Schedule next sync
+    if (this.isVisible && !this.isStopped) {
+      this.syncTimeout = setTimeout(() => this.syncWithNetwork(), this.syncIntervalMs);
+    }
+  }
+
+  private calculateRemainingMs(): number {
+    const now = Date.now();
+    const elapsedLocalMs = now - this.state.lastSyncLocalMs;
+    const elapsedNetworkSecs = elapsedLocalMs / 1000;
+    const networkNowSecs = this.state.lastSyncUnixSecs + elapsedNetworkSecs;
+    const remainingSecs = this.state.deadlineUnixSecs - networkNowSecs;
+    return Math.max(0, remainingSecs * 1000);
+  }
+
+  getRemainingMs(): number {
+    return this.calculateRemainingMs();
+  }
+
+  stop(): void {
+    this.isStopped = true;
+    if (this.tickTimeout) {
+      clearInterval(this.tickTimeout);
+      this.tickTimeout = null;
+    }
+    if (this.syncTimeout) {
+      clearTimeout(this.syncTimeout);
+      this.syncTimeout = null;
+    }
+  }
+}
+
+describe('InvoiceCountdownTimer', () => {
+  let mockRpcServer: FakeRpcServer;
+  let now: number;
+
+  beforeEach(() => {
+    jest.useFakeTimers();
+    now = Math.floor(Date.now() / 1000);
+    mockRpcServer = {
+      getLatestLedger: jest.fn().mockResolvedValue({ closeTime: now * 1000 }),
+    };
+  });
+
+  afterEach(() => {
+    jest.useRealTimers();
+  });
+
+  it('should create timer with deadline', () => {
+    const deadlineUnixSecs = now + 3600;
+    const timer = new InvoiceCountdownTimer(deadlineUnixSecs, mockRpcServer);
+    expect(timer).toBeDefined();
+    timer.stop();
+  });
+
+  it('should emit tick events with correct structure', async () => {
+    const deadlineUnixSecs = now + 3600;
+    const timer = new InvoiceCountdownTimer(deadlineUnixSecs, mockRpcServer);
+    const tickHandler = jest.fn();
+    timer.on('tick', tickHandler);
+
+    jest.advanceTimersByTime(1000);
+    await jest.runAllTimersAsync();
+
+    expect(tickHandler).toHaveBeenCalled();
+    const tickEvent = tickHandler.mock.calls[0][0] as TickEvent;
+    expect(tickEvent).toHaveProperty('remainingMs');
+    expect(tickEvent).toHaveProperty('driftCorrectedMs');
+    expect(tickEvent).toHaveProperty('inSync');
+
+    timer.stop();
+  });
+
+  it('should correct drift after injecting artificial Date.now skew', async () => {
+    const deadlineUnixSecs = now + 3600;
+    const timer = new InvoiceCountdownTimer(deadlineUnixSecs, mockRpcServer);
+
+    const beforeSync = timer.getRemainingMs();
+
+    // Simulate 5 second skew
+    jest.spyOn(Date, 'now').mockReturnValue(Date.now() + 5000);
+
+    // Trigger sync
+    jest.advanceTimersByTime(30000);
+    await jest.runAllTimersAsync();
+
+    const afterSync = timer.getRemainingMs();
+
+    // After sync, the skew should be corrected
+    expect(Math.abs(beforeSync - afterSync)).toBeLessThan(1000);
+
+    jest.restoreAllMocks();
+    timer.stop();
+  });
+
+  it('should emit inSync true on sync completion', async () => {
+    const deadlineUnixSecs = now + 3600;
+    const timer = new InvoiceCountdownTimer(deadlineUnixSecs, mockRpcServer);
+    const tickHandler = jest.fn();
+    timer.on('tick', tickHandler);
+
+    jest.advanceTimersByTime(30000);
+    await jest.runAllTimersAsync();
+
+    const syncedTicks = tickHandler.mock.calls.filter((call) => call[0].inSync === true);
+    expect(syncedTicks.length).toBeGreaterThan(0);
+
+    timer.stop();
+  });
+
+  it('should fire deadline:expired when remainingMs reaches 0', async () => {
+    const deadlineUnixSecs = now + 1;
+    const timer = new InvoiceCountdownTimer(deadlineUnixSecs, mockRpcServer);
+    const expiredHandler = jest.fn();
+    timer.on('deadline:expired', expiredHandler);
+
+    jest.advanceTimersByTime(2000);
+    await jest.runAllTimersAsync();
+
+    expect(expiredHandler).toHaveBeenCalled();
+    timer.stop();
+  });
+
+  it('should stop ticking after deadline expires', async () => {
+    const deadlineUnixSecs = now + 1;
+    const timer = new InvoiceCountdownTimer(deadlineUnixSecs, mockRpcServer);
+    const tickHandler = jest.fn();
+    timer.on('tick', tickHandler);
+
+    jest.advanceTimersByTime(2000);
+    await jest.runAllTimersAsync();
+
+    const tickCountBefore = tickHandler.mock.calls.length;
+
+    jest.advanceTimersByTime(5000);
+    await jest.runAllTimersAsync();
+
+    const tickCountAfter = tickHandler.mock.calls.length;
+    expect(tickCountAfter).toBe(tickCountBefore);
+
+    timer.stop();
+  });
+
+  it('should suspend syncs when tab is hidden', async () => {
+    const deadlineUnixSecs = now + 3600;
+    const timer = new InvoiceCountdownTimer(deadlineUnixSecs, mockRpcServer);
+
+    const syncSpy = jest.spyOn(mockRpcServer, 'getLatestLedger');
+
+    // Simulate hiding tab
+    if (typeof document !== 'undefined') {
+      Object.defineProperty(document, 'hidden', { value: true, configurable: true });
+      document.dispatchEvent(new Event('visibilitychange'));
+    }
+
+    const callsBeforeHide = syncSpy.mock.calls.length;
+    jest.advanceTimersByTime(30000);
+    await jest.runAllTimersAsync();
+
+    const callsAfterHide = syncSpy.mock.calls.length;
+    expect(callsAfterHide).toBe(callsBeforeHide);
+
+    timer.stop();
+  });
+
+  it('should resume syncs when tab becomes visible', async () => {
+    const deadlineUnixSecs = now + 3600;
+    const timer = new InvoiceCountdownTimer(deadlineUnixSecs, mockRpcServer);
+
+    // Simulate hiding tab
+    if (typeof document !== 'undefined') {
+      Object.defineProperty(document, 'hidden', { value: true, configurable: true });
+      document.dispatchEvent(new Event('visibilitychange'));
+    }
+
+    const syncSpy = jest.spyOn(mockRpcServer, 'getLatestLedger');
+    const callsBeforeVisible = syncSpy.mock.calls.length;
+
+    // Make visible again
+    if (typeof document !== 'undefined') {
+      Object.defineProperty(document, 'hidden', { value: false, configurable: true });
+      document.dispatchEvent(new Event('visibilitychange'));
+    }
+
+    jest.advanceTimersByTime(100);
+    await jest.runAllTimersAsync();
+
+    const callsAfterVisible = syncSpy.mock.calls.length;
+    expect(callsAfterVisible).toBeGreaterThan(callsBeforeVisible);
+
+    timer.stop();
+  });
+
+  it('should trigger immediate sync on visibilitychange to visible', async () => {
+    const deadlineUnixSecs = now + 3600;
+    const timer = new InvoiceCountdownTimer(deadlineUnixSecs, mockRpcServer);
+
+    // Simulate hiding tab
+    if (typeof document !== 'undefined') {
+      Object.defineProperty(document, 'hidden', { value: true, configurable: true });
+      document.dispatchEvent(new Event('visibilitychange'));
+    }
+
+    const syncSpy = jest.spyOn(mockRpcServer, 'getLatestLedger');
+    syncSpy.mockClear();
+
+    // Make visible
+    if (typeof document !== 'undefined') {
+      Object.defineProperty(document, 'hidden', { value: false, configurable: true });
+      document.dispatchEvent(new Event('visibilitychange'));
+    }
+
+    jest.advanceTimersByTime(100);
+    await jest.runAllTimersAsync();
+
+    expect(syncSpy).toHaveBeenCalled();
+    timer.stop();
+  });
+
+  it('should calculate remaining time accurately', () => {
+    const remainingTime = 7200; // 2 hours
+    const deadlineUnixSecs = now + remainingTime;
+    const timer = new InvoiceCountdownTimer(deadlineUnixSecs, mockRpcServer);
+
+    const remainingMs = timer.getRemainingMs();
+
+    expect(remainingMs).toBeLessThanOrEqual(remainingTime * 1000);
+    expect(remainingMs).toBeGreaterThan((remainingTime - 1) * 1000);
+
+    timer.stop();
+  });
+
+  it('should handle missing RPC calls gracefully', async () => {
+    const deadlineUnixSecs = now + 3600;
+    const failingRpc = {
+      getLatestLedger: jest.fn().mockRejectedValue(new Error('RPC failed')),
+    };
+
+    const timer = new InvoiceCountdownTimer(deadlineUnixSecs, failingRpc);
+    const tickHandler = jest.fn();
+    timer.on('tick', tickHandler);
+
+    jest.advanceTimersByTime(1000);
+    await jest.runAllTimersAsync();
+
+    expect(tickHandler).toHaveBeenCalled();
+    timer.stop();
+  });
+
+  it('should emit tick every configured interval', async () => {
+    const deadlineUnixSecs = now + 3600;
+    const timer = new InvoiceCountdownTimer(deadlineUnixSecs, mockRpcServer);
+    const tickHandler = jest.fn();
+    timer.on('tick', tickHandler);
+
+    // Advance by 5 seconds
+    jest.advanceTimersByTime(5000);
+    await jest.runAllTimersAsync();
+
+    const tickCount = tickHandler.mock.calls.length;
+    expect(tickCount).toBeGreaterThanOrEqual(4); // At least 4-5 ticks in 5 seconds
+
+    timer.stop();
+  });
+
+  it('should reflect drift correction immediately after sync', async () => {
+    const deadlineUnixSecs = now + 3600;
+    const timer = new InvoiceCountdownTimer(deadlineUnixSecs, mockRpcServer);
+    const tickHandler = jest.fn();
+    timer.on('tick', tickHandler);
+
+    // Manually advance time beyond what RPC reports
+    jest.spyOn(Date, 'now').mockReturnValue(Date.now() + 3000);
+
+    // Trigger sync
+    jest.advanceTimersByTime(30000);
+    await jest.runAllTimersAsync();
+
+    const tickEvents = tickHandler.mock.calls.map((call) => call[0] as TickEvent);
+    const syncedEvent = tickEvents.find((e) => e.inSync);
+
+    expect(syncedEvent).toBeDefined();
+    expect(syncedEvent?.driftCorrectedMs).toBeLessThan(deadlineUnixSecs * 1000 + 1000);
+
+    jest.restoreAllMocks();
+    timer.stop();
+  });
+
+  it('should not sync during background tab state', async () => {
+    const deadlineUnixSecs = now + 3600;
+    const timer = new InvoiceCountdownTimer(deadlineUnixSecs, mockRpcServer);
+
+    const syncSpy = jest.spyOn(mockRpcServer, 'getLatestLedger');
+    syncSpy.mockClear();
+
+    // Simulate tab going to background
+    if (typeof document !== 'undefined') {
+      Object.defineProperty(document, 'hidden', { value: true, configurable: true });
+      document.dispatchEvent(new Event('visibilitychange'));
+    }
+
+    jest.advanceTimersByTime(60000);
+    await jest.runAllTimersAsync();
+
+    expect(syncSpy).not.toHaveBeenCalled();
+    timer.stop();
+  });
+});