diff --git a/backend/src/audit/entities/audit-log.entity.ts b/backend/src/audit/entities/audit-log.entity.ts
index 757942c9..2cfcafb3 100644
--- a/backend/src/audit/entities/audit-log.entity.ts
+++ b/backend/src/audit/entities/audit-log.entity.ts
@@ -12,10 +12,26 @@ export enum ActorType {
   SYSTEM = 'system',
 }
 
+export enum SessionType {
+  ADMIN_DIRECT = 'admin_direct',
+  IMPERSONATION = 'impersonation',
+  API_KEY = 'api_key',
+  SYSTEM = 'system',
+}
+
+export enum RiskLevel {
+  LOW = 'low',
+  MEDIUM = 'medium',
+  HIGH = 'high',
+  CRITICAL = 'critical',
+}
+
 @Entity('audit_logs')
 @Index(['resourceType', 'resourceId', 'createdAt'])
 @Index(['actorId', 'createdAt'])
 @Index(['action', 'createdAt'])
+@Index(['impersonationSessionId', 'createdAt'])
+@Index(['riskLevel', 'createdAt'])
 export class AuditLog {
   @PrimaryGeneratedColumn('uuid')
   id!: string;
@@ -54,6 +70,26 @@ export class AuditLog {
   @Column({ name: 'correlation_id', type: 'varchar', length: 255, nullable: true, default: null })
   correlationId!: string | null;
 
+  /** SHA-256 hash for tamper-evident chain */
+  @Column({ type: 'varchar', length: 64 })
+  hash!: string;
+
+  /** Hash of the immediately preceding AuditLog entry */
+  @Column({ name: 'previous_hash', type: 'varchar', length: 64, nullable: true, default: null })
+  previousHash!: string | null;
+
+  /** Type of session that generated this audit log */
+  @Column({ name: 'session_type', type: 'enum', enum: SessionType, default: SessionType.ADMIN_DIRECT })
+  sessionType!: SessionType;
+
+  /** UUID of impersonation session if sessionType is IMPERSONATION */
+  @Column({ name: 'impersonation_session_id', type: 'uuid', nullable: true, default: null })
+  impersonationSessionId!: string | null;
+
+  /** Risk level of the action */
+  @Column({ name: 'risk_level', type: 'enum', enum: RiskLevel, default: RiskLevel.LOW })
+  riskLevel!: RiskLevel;
+
   /** Immutable — no updatedAt */
   @CreateDateColumn({ name: 'created_at' })
   createdAt!: Date;
diff --git a/backend/src/merchants/analytics/dto/merchant-overview.dto.ts b/backend/src/merchants/analytics/dto/merchant-overview.dto.ts
new file mode 100644
index 00000000..3bc8e10d
--- /dev/null
+++ b/backend/src/merchants/analytics/dto/merchant-overview.dto.ts
@@ -0,0 +1,64 @@
+import { ApiProperty } from '@nestjs/swagger';
+
+export class MerchantOverviewDto {
+  @ApiProperty({ description: 'Total revenue in USDC for the last 30 days' })
+  totalRevenueUsdc30d!: string;
+
+  @ApiProperty({ description: 'Total revenue in NGN for the last 30 days (at settled rates)' })
+  totalRevenueNgn30d!: string;
+
+  @ApiProperty({ description: 'Number of transactions in the last 30 days' })
+  transactionCount30d!: number;
+
+  @ApiProperty({ description: 'Number of unique customers in the last 30 days' })
+  uniqueCustomers30d!: number;
+
+  @ApiProperty({ description: 'Average transaction amount in USDC' })
+  avgTransactionUsdc!: string;
+
+  @ApiProperty({ description: 'Pending settlement amount in USDC' })
+  pendingSettlementUsdc!: string;
+
+  @ApiProperty({ description: 'Timestamp of last settlement', nullable: true })
+  lastSettledAt!: Date | null;
+
+  @ApiProperty({ 
+    description: 'Top payment method used',
+    enum: ['username_send', 'paylink', 'virtual_account']
+  })
+  topPaymentMethod!: string;
+}
+
+export class TopRecipientDto {
+  @ApiProperty({ description: 'Recipient username' })
+  username!: string;
+
+  @ApiProperty({ description: 'Total amount sent to this recipient' })
+  totalSent!: string;
+}
+
+export class RevenueDataPointDto {
+  @ApiProperty({ description: 'Timestamp for this data point' })
+  timestamp!: Date;
+
+  @ApiProperty({ description: 'Revenue amount in USDC' })
+  revenueUsdc!: string;
+
+  @ApiProperty({ description: 'Number of transactions in this period' })
+  transactionCount!: number;
+}
+
+export class RevenueTimelineDto {
+  @ApiProperty({ description: 'Granularity of the timeline' })
+  granularity!: 'hour' | 'day' | 'week' | 'month';
+
+  @ApiProperty({ description: 'Revenue data points' })
+  data!: RevenueDataPointDto[];
+}
+
+export enum RevenueGranularity {
+  HOUR = 'hour',
+  DAY = 'day',
+  WEEK = 'week',
+  MONTH = 'month',
+}
diff --git a/backend/src/merchants/analytics/merchant-analytics.controller.ts b/backend/src/merchants/analytics/merchant-analytics.controller.ts
new file mode 100644
index 00000000..f20c0b52
--- /dev/null
+++ b/backend/src/merchants/analytics/merchant-analytics.controller.ts
@@ -0,0 +1,92 @@
+import {
+  Controller,
+  Get,
+  Query,
+  Param,
+  UseGuards,
+  Req,
+} from '@nestjs/common';
+import { ApiTags, ApiOperation, ApiBearerAuth, ApiQuery } from '@nestjs/swagger';
+import { MerchantAnalyticsService } from './merchant-analytics.service';
+import { MerchantOverviewDto, RevenueTimelineDto, RevenueGranularity } from './dto/merchant-overview.dto';
+import { JwtAuthGuard } from '../../auth/guards/jwt-auth.guard';
+import { IsOptional, IsEnum, IsDateString } from 'class-validator';
+
+class RevenueTimelineQueryDto {
+  @IsEnum(RevenueGranularity)
+  @IsOptional()
+  granularity?: RevenueGranularity = RevenueGranularity.DAY;
+
+  @IsDateString()
+  @IsOptional()
+  dateFrom?: string;
+
+  @IsDateString()
+  @IsOptional()
+  dateTo?: string;
+}
+
+@ApiTags('Merchant Analytics')
+@Controller({ path: 'merchants/analytics', version: '1' })
+@ApiBearerAuth()
+@UseGuards(JwtAuthGuard)
+export class MerchantAnalyticsController {
+  constructor(private readonly analyticsService: MerchantAnalyticsService) {}
+
+  @Get('overview')
+  @ApiOperation({ summary: 'Get merchant overview statistics for the last 30 days' })
+  async getOverview(
+    @Req() req: { user: { id: string } },
+  ): Promise<MerchantOverviewDto> {
+    return this.analyticsService.getOverview(req.user.id);
+  }
+
+  @Get('revenue-timeline')
+  @ApiOperation({ summary: 'Get revenue timeline with specified granularity' })
+  @ApiQuery({ name: 'granularity', enum: RevenueGranularity, required: false })
+  @ApiQuery({ name: 'dateFrom', type: String, required: false })
+  @ApiQuery({ name: 'dateTo', type: String, required: false })
+  async getRevenueTimeline(
+    @Req() req: { user: { id: string } },
+    @Query() query: RevenueTimelineQueryDto,
+  ): Promise<RevenueTimelineDto> {
+    const dateFrom = query.dateFrom 
+      ? new Date(query.dateFrom) 
+      : new Date(Date.now() - 30 * 24 * 60 * 60 * 1000);
+    const dateTo = query.dateTo ? new Date(query.dateTo) : new Date();
+
+    return this.analyticsService.getRevenueTimeline(
+      req.user.id,
+      query.granularity || RevenueGranularity.DAY,
+      dateFrom,
+      dateTo,
+    );
+  }
+
+  @Get(':merchantId/overview')
+  @ApiOperation({ summary: 'Get specific merchant overview (admin only)' })
+  async getMerchantOverview(
+    @Param('merchantId') merchantId: string,
+  ): Promise<MerchantOverviewDto> {
+    return this.analyticsService.getOverview(merchantId);
+  }
+
+  @Get(':merchantId/revenue-timeline')
+  @ApiOperation({ summary: 'Get specific merchant revenue timeline (admin only)' })
+  async getMerchantRevenueTimeline(
+    @Param('merchantId') merchantId: string,
+    @Query() query: RevenueTimelineQueryDto,
+  ): Promise<RevenueTimelineDto> {
+    const dateFrom = query.dateFrom 
+      ? new Date(query.dateFrom) 
+      : new Date(Date.now() - 30 * 24 * 60 * 60 * 1000);
+    const dateTo = query.dateTo ? new Date(query.dateTo) : new Date();
+
+    return this.analyticsService.getRevenueTimeline(
+      merchantId,
+      query.granularity || RevenueGranularity.DAY,
+      dateFrom,
+      dateTo,
+    );
+  }
+}
diff --git a/backend/src/merchants/analytics/merchant-analytics.module.ts b/backend/src/merchants/analytics/merchant-analytics.module.ts
new file mode 100644
index 00000000..ee75f2fb
--- /dev/null
+++ b/backend/src/merchants/analytics/merchant-analytics.module.ts
@@ -0,0 +1,17 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { Merchant } from '../entities/merchant.entity';
+import { Transaction } from '../../transactions/entities/transaction.entity';
+import { Settlement } from '../../settlement/entities/settlement.entity';
+import { MerchantAnalyticsService } from './merchant-analytics.service';
+import { MerchantAnalyticsController } from './merchant-analytics.controller';
+
+@Module({
+  imports: [
+    TypeOrmModule.forFeature([Merchant, Transaction, Settlement]),
+  ],
+  providers: [MerchantAnalyticsService],
+  controllers: [MerchantAnalyticsController],
+  exports: [MerchantAnalyticsService],
+})
+export class MerchantAnalyticsModule {}
diff --git a/backend/src/merchants/analytics/merchant-analytics.service.ts b/backend/src/merchants/analytics/merchant-analytics.service.ts
new file mode 100644
index 00000000..97ecdd42
--- /dev/null
+++ b/backend/src/merchants/analytics/merchant-analytics.service.ts
@@ -0,0 +1,254 @@
+import { Injectable, NotFoundException, Logger } from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository, Between } from 'typeorm';
+import { ConfigService } from '@nestjs/config';
+import { Merchant } from '../entities/merchant.entity';
+import { Transaction, TransactionType, TransactionStatus } from '../../transactions/entities/transaction.entity';
+import { Settlement } from '../../settlement/entities/settlement.entity';
+import {
+  MerchantOverviewDto,
+  RevenueTimelineDto,
+  RevenueDataPointDto,
+  RevenueGranularity,
+} from './dto/merchant-overview.dto';
+
+@Injectable()
+export class MerchantAnalyticsService {
+  private readonly logger = new Logger(MerchantAnalyticsService.name);
+
+  constructor(
+    @InjectRepository(Merchant)
+    private readonly merchantRepo: Repository<Merchant>,
+    @InjectRepository(Transaction)
+    private readonly transactionRepo: Repository<Transaction>,
+    @InjectRepository(Settlement)
+    private readonly settlementRepo: Repository<Settlement>,
+    private readonly configService: ConfigService,
+  ) {}
+
+  /**
+   * Get merchant overview statistics
+   */
+  async getOverview(merchantId: string): Promise<MerchantOverviewDto> {
+    const merchant = await this.merchantRepo.findOne({ where: { id: merchantId } });
+    if (!merchant) {
+      throw new NotFoundException(`Merchant ${merchantId} not found`);
+    }
+
+    const thirtyDaysAgo = new Date();
+    thirtyDaysAgo.setDate(thirtyDaysAgo.getDate() - 30);
+
+    // Get transactions for the last 30 days
+    const transactions = await this.transactionRepo
+      .createQueryBuilder('tx')
+      .where('tx.user_id = :merchantId', { merchantId })
+      .andWhere('tx.created_at >= :thirtyDaysAgo', { thirtyDaysAgo })
+      .andWhere('tx.status = :status', { status: TransactionStatus.COMPLETED })
+      .getMany();
+
+    // Calculate total revenue
+    const totalRevenueUsdc30d = transactions.reduce(
+      (sum, tx) => sum + parseFloat(tx.amountUsdc || '0'),
+      0,
+    ).toString();
+
+    // Convert to NGN at settled rate (simplified - would need actual rate)
+    const usdToNgnRate = parseFloat(this.configService.get('rates.usdToNgn') || '1500');
+    const totalRevenueNgn30d = (parseFloat(totalRevenueUsdc30d) * usdToNgnRate).toString();
+
+    // Get unique customers
+    const uniqueCustomers = new Set(
+      transactions
+        .filter((tx) => tx.counterpartyUsername)
+        .map((tx) => tx.counterpartyUsername),
+    ).size;
+
+    // Calculate average transaction
+    const avgTransactionUsdc = transactions.length > 0
+      ? (parseFloat(totalRevenueUsdc30d) / transactions.length).toString()
+      : '0';
+
+    // Get pending settlement
+    const pendingSettlements = await this.settlementRepo
+      .createQueryBuilder('settlement')
+      .where('settlement.merchant_id = :merchantId', { merchantId })
+      .andWhere('settlement.status = :status', { status: 'queued' })
+      .getMany();
+
+    const pendingSettlementUsdc = pendingSettlements.reduce(
+      (sum: number, s: { usdcAmount: number }) => sum + s.usdcAmount,
+      0,
+    ).toString();
+
+    // Get last settlement
+    const lastSettlement = await this.settlementRepo.findOne({
+      where: { merchantId },
+      order: { createdAt: 'DESC' },
+    });
+
+    // Determine top payment method
+    const paymentMethodCounts: Record<string, number> = {};
+    transactions.forEach((tx) => {
+      const method = this.getPaymentMethod(tx.type);
+      paymentMethodCounts[method] = (paymentMethodCounts[method] || 0) + 1;
+    });
+
+    const topPaymentMethod = Object.entries(paymentMethodCounts).sort(
+      (a, b) => b[1] - a[1],
+    )[0]?.[0] || 'username_send';
+
+    return {
+      totalRevenueUsdc30d,
+      totalRevenueNgn30d,
+      transactionCount30d: transactions.length,
+      uniqueCustomers30d: uniqueCustomers,
+      avgTransactionUsdc,
+      pendingSettlementUsdc,
+      lastSettledAt: lastSettlement?.createdAt || null,
+      topPaymentMethod,
+    };
+  }
+
+  /**
+   * Get revenue timeline with specified granularity
+   */
+  async getRevenueTimeline(
+    merchantId: string,
+    granularity: RevenueGranularity,
+    dateFrom: Date,
+    dateTo: Date,
+  ): Promise<RevenueTimelineDto> {
+    const merchant = await this.merchantRepo.findOne({ where: { id: merchantId } });
+    if (!merchant) {
+      throw new NotFoundException(`Merchant ${merchantId} not found`);
+    }
+
+    const transactions = await this.transactionRepo
+      .createQueryBuilder('tx')
+      .where('tx.user_id = :merchantId', { merchantId })
+      .andWhere('tx.created_at >= :dateFrom', { dateFrom })
+      .andWhere('tx.created_at <= :dateTo', { dateTo })
+      .andWhere('tx.status = :status', { status: TransactionStatus.COMPLETED })
+      .orderBy('tx.created_at', 'ASC')
+      .getMany();
+
+    // Group by granularity
+    const groupedData = this.groupTransactionsByGranularity(
+      transactions,
+      granularity,
+    );
+
+    const data: RevenueDataPointDto[] = groupedData.map((group) => ({
+      timestamp: group.timestamp,
+      revenueUsdc: group.revenue.toString(),
+      transactionCount: group.count,
+    }));
+
+    return {
+      granularity,
+      data,
+    };
+  }
+
+  /**
+   * Group transactions by time granularity
+   */
+  private groupTransactionsByGranularity(
+    transactions: Transaction[],
+    granularity: RevenueGranularity,
+  ): { timestamp: Date; revenue: number; count: number }[] {
+    const groups: Map<string, { timestamp: Date; revenue: number; count: number }> = new Map();
+
+    for (const tx of transactions) {
+      const key = this.getGranularityKey(tx.createdAt, granularity);
+      const existing = groups.get(key);
+
+      if (existing) {
+        existing.revenue += parseFloat(tx.amountUsdc || '0');
+        existing.count += 1;
+      } else {
+        groups.set(key, {
+          timestamp: this.getTimestampForKey(key, granularity),
+          revenue: parseFloat(tx.amountUsdc || '0'),
+          count: 1,
+        });
+      }
+    }
+
+    return Array.from(groups.values()).sort(
+      (a, b) => a.timestamp.getTime() - b.timestamp.getTime(),
+    );
+  }
+
+  /**
+   * Get a string key for grouping by granularity
+   */
+  private getGranularityKey(date: Date, granularity: RevenueGranularity): string {
+    const d = new Date(date);
+    switch (granularity) {
+      case RevenueGranularity.HOUR:
+        return `${d.getFullYear()}-${d.getMonth()}-${d.getDate()}-${d.getHours()}`;
+      case RevenueGranularity.DAY:
+        return `${d.getFullYear()}-${d.getMonth()}-${d.getDate()}`;
+      case RevenueGranularity.WEEK:
+        const week = this.getWeekNumber(d);
+        return `${d.getFullYear()}-W${week}`;
+      case RevenueGranularity.MONTH:
+        return `${d.getFullYear()}-${d.getMonth()}`;
+      default:
+        return `${d.getFullYear()}-${d.getMonth()}-${d.getDate()}`;
+    }
+  }
+
+  /**
+   * Convert a granularity key back to a timestamp
+   */
+  private getTimestampForKey(key: string, granularity: RevenueGranularity): Date {
+    const date = new Date();
+    const parts = key.split(/[-W:]/);
+
+    switch (granularity) {
+      case RevenueGranularity.HOUR:
+        date.setFullYear(parseInt(parts[0]), parseInt(parts[1]), parseInt(parts[2]));
+        date.setHours(parseInt(parts[3]), 0, 0, 0);
+        break;
+      case RevenueGranularity.DAY:
+        date.setFullYear(parseInt(parts[0]), parseInt(parts[1]), parseInt(parts[2]));
+        date.setHours(0, 0, 0, 0);
+        break;
+      case RevenueGranularity.WEEK:
+        date.setFullYear(parseInt(parts[0]), 0, 1);
+        break;
+      case RevenueGranularity.MONTH:
+        date.setFullYear(parseInt(parts[0]), parseInt(parts[1]), 1);
+        break;
+    }
+
+    return date;
+  }
+
+  /**
+   * Get ISO week number
+   */
+  private getWeekNumber(date: Date): number {
+    const d = new Date(Date.UTC(date.getFullYear(), date.getMonth(), date.getDate()));
+    const dayNum = d.getUTCDay() || 7;
+    d.setUTCDate(d.getUTCDate() + 4 - dayNum);
+    const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));
+    return Math.ceil(((d.getTime() - yearStart.getTime()) / 86400000 + 1) / 7);
+  }
+
+  /**
+   * Map transaction type to payment method
+   */
+  private getPaymentMethod(type: TransactionType): string {
+    switch (type) {
+      case TransactionType.PAYLINK_RECEIVED:
+        return 'paylink';
+      case TransactionType.VIRTUAL_CARD_FUND:
+        return 'virtual_account';
+      default:
+        return 'username_send';
+    }
+  }
+}
diff --git a/backend/src/merchants/merchants.module.ts b/backend/src/merchants/merchants.module.ts
index 32a5dfee..7182ff91 100644
--- a/backend/src/merchants/merchants.module.ts
+++ b/backend/src/merchants/merchants.module.ts
@@ -8,9 +8,15 @@ import { MerchantPosService } from './merchant-pos.service';
 import { MerchantsAdminController } from './merchants-admin.controller';
 import { MerchantsController } from './merchants.controller';
 import { MerchantsService } from './merchants.service';
+import { MerchantAnalyticsModule } from './analytics/merchant-analytics.module';
 
 @Module({
-  imports: [TypeOrmModule.forFeature([Merchant, User]), NotificationsModule, QrModule],
+  imports: [
+    TypeOrmModule.forFeature([Merchant, User]),
+    NotificationsModule,
+    QrModule,
+    MerchantAnalyticsModule,
+  ],
   controllers: [MerchantsController, MerchantsAdminController],
   providers: [MerchantsService, MerchantPosService],
   exports: [MerchantsService, MerchantPosService],
diff --git a/backend/src/multisig/entities/multisig-request.entity.ts b/backend/src/multisig/entities/multisig-request.entity.ts
new file mode 100644
index 00000000..30e7b70d
--- /dev/null
+++ b/backend/src/multisig/entities/multisig-request.entity.ts
@@ -0,0 +1,70 @@
+import {
+  Entity,
+  Column,
+  PrimaryGeneratedColumn,
+  CreateDateColumn,
+  Index,
+} from 'typeorm';
+
+export enum MultisigRequestType {
+  LARGE_WITHDRAWAL = 'large_withdrawal',
+  ADMIN_OPERATION = 'admin_operation',
+}
+
+export enum MultisigRequestStatus {
+  PENDING = 'pending',
+  APPROVED = 'approved',
+  REJECTED = 'rejected',
+  EXPIRED = 'expired',
+}
+
+export interface MultisigApproval {
+  adminId: string;
+  signedAt: Date;
+  signatureXdr: string;
+}
+
+@Entity('multisig_requests')
+@Index(['status', 'expiresAt'])
+@Index(['requestedBy', 'createdAt'])
+export class MultisigRequest {
+  @PrimaryGeneratedColumn('uuid')
+  id!: string;
+
+  @Column({ type: 'enum', enum: MultisigRequestType })
+  type!: MultisigRequestType;
+
+  @Column({ name: 'tx_xdr', type: 'text' })
+  txXdr!: string;
+
+  @Column({ type: 'varchar', length: 50 })
+  threshold!: string;
+
+  @Column({ name: 'requested_by', type: 'uuid' })
+  requestedBy!: string;
+
+  @Column({
+    type: 'enum',
+    enum: MultisigRequestStatus,
+    default: MultisigRequestStatus.PENDING,
+  })
+  status!: MultisigRequestStatus;
+
+  @Column({ type: 'jsonb', default: [] })
+  approvals!: MultisigApproval[];
+
+  @Column({ name: 'required_signatures', default: 2 })
+  requiredSignatures!: number;
+
+  @Column({ name: 'rejection_reason', type: 'text', nullable: true })
+  rejectionReason!: string | null;
+
+  @Column({ name: 'expires_at', type: 'timestamptz' })
+  expiresAt!: Date;
+
+  @Column({ name: 'tx_hash', type: 'varchar', length: 64, nullable: true })
+  txHash!: string | null;
+
+  @CreateDateColumn({ name: 'created_at', type: 'timestamptz' })
+  createdAt!: Date;
+}
diff --git a/backend/src/multisig/multisig.controller.ts b/backend/src/multisig/multisig.controller.ts
new file mode 100644
index 00000000..c360d388
--- /dev/null
+++ b/backend/src/multisig/multisig.controller.ts
@@ -0,0 +1,110 @@
+import {
+  Controller,
+  Get,
+  Post,
+  Body,
+  Param,
+  Query,
+  UseGuards,
+  Req,
+} from '@nestjs/common';
+import { ApiTags, ApiOperation, ApiBearerAuth } from '@nestjs/swagger';
+import { MultisigService } from './multisig.service';
+import { MultisigRequest, MultisigRequestType } from './entities/multisig-request.entity';
+import { JwtAuthGuard } from '../auth/guards/jwt-auth.guard';
+import { RolesGuard } from '../common/guards/roles.guard';
+import { Roles } from '../common/decorators/roles.decorator';
+import { AdminRole } from '../admin/entities/admin.entity';
+
+class CreateMultisigRequestDto {
+  txXdr!: string;
+  type!: MultisigRequestType;
+  threshold!: string;
+}
+
+class ApproveMultisigRequestDto {
+  signatureXdr!: string;
+}
+
+class RejectMultisigRequestDto {
+  reason!: string;
+}
+
+@ApiTags('Multisig')
+@Controller({ path: 'multisig', version: '1' })
+@ApiBearerAuth()
+export class MultisigController {
+  constructor(private readonly multisigService: MultisigService) {}
+
+  @Post('requests')
+  @UseGuards(JwtAuthGuard)
+  @ApiOperation({ summary: 'Create a new multisig request for a large transaction' })
+  async createRequest(
+    @Body() dto: CreateMultisigRequestDto,
+    @Req() req: { user: { id: string } },
+  ): Promise<MultisigRequest> {
+    return this.multisigService.createRequest(
+      dto.txXdr,
+      dto.type,
+      req.user.id,
+      dto.threshold,
+    );
+  }
+
+  @Post('requests/:id/approve')
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(AdminRole.ADMIN, AdminRole.SUPERADMIN)
+  @ApiOperation({ summary: 'Approve a multisig request' })
+  async approveRequest(
+    @Param('id') id: string,
+    @Body() dto: ApproveMultisigRequestDto,
+    @Req() req: { user: { id: string } },
+  ): Promise<MultisigRequest> {
+    return this.multisigService.approve(
+      id,
+      req.user.id,
+      dto.signatureXdr,
+    );
+  }
+
+  @Post('requests/:id/reject')
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(AdminRole.ADMIN, AdminRole.SUPERADMIN)
+  @ApiOperation({ summary: 'Reject a multisig request' })
+  async rejectRequest(
+    @Param('id') id: string,
+    @Body() dto: RejectMultisigRequestDto,
+    @Req() req: { user: { id: string } },
+  ): Promise<MultisigRequest> {
+    return this.multisigService.reject(
+      id,
+      req.user.id,
+      dto.reason,
+    );
+  }
+
+  @Get('requests/:id')
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(AdminRole.ADMIN, AdminRole.SUPERADMIN)
+  @ApiOperation({ summary: 'Get a multisig request by ID' })
+  async getRequest(@Param('id') id: string): Promise<MultisigRequest> {
+    return this.multisigService.findById(id);
+  }
+
+  @Get('requests')
+  @UseGuards(JwtAuthGuard, RolesGuard)
+  @Roles(AdminRole.ADMIN, AdminRole.SUPERADMIN)
+  @ApiOperation({ summary: 'Get all pending multisig requests' })
+  async getPendingRequests(
+    @Req() req: { user: { id: string } },
+  ): Promise<MultisigRequest[]> {
+    return this.multisigService.findPendingForAdmin(req.user.id);
+  }
+
+  @Get('threshold-check')
+  @UseGuards(JwtAuthGuard)
+  @ApiOperation({ summary: 'Check if an amount exceeds the multisig threshold' })
+  async checkThreshold(@Query('amount') amount: string): Promise<{ exceeds: boolean }> {
+    return { exceeds: this.multisigService.isThresholdExceeded(amount) };
+  }
+}
diff --git a/backend/src/multisig/multisig.module.ts b/backend/src/multisig/multisig.module.ts
new file mode 100644
index 00000000..64d9d996
--- /dev/null
+++ b/backend/src/multisig/multisig.module.ts
@@ -0,0 +1,24 @@
+import { Module } from '@nestjs/common';
+import { TypeOrmModule } from '@nestjs/typeorm';
+import { MultisigRequest } from './entities/multisig-request.entity';
+import { MultisigService } from './multisig.service';
+import { MultisigController } from './multisig.controller';
+import { Admin } from '../admin/entities/admin.entity';
+import { StellarModule } from '../stellar/stellar.module';
+import { EmailModule } from '../email/email.module';
+import { PushModule } from '../push/push.module';
+import { QueueModule } from '../queue/queue.module';
+
+@Module({
+  imports: [
+    TypeOrmModule.forFeature([MultisigRequest, Admin]),
+    StellarModule,
+    EmailModule,
+    PushModule,
+    QueueModule,
+  ],
+  providers: [MultisigService],
+  controllers: [MultisigController],
+  exports: [MultisigService],
+})
+export class MultisigModule {}
diff --git a/backend/src/multisig/multisig.service.ts b/backend/src/multisig/multisig.service.ts
new file mode 100644
index 00000000..8faf9a23
--- /dev/null
+++ b/backend/src/multisig/multisig.service.ts
@@ -0,0 +1,364 @@
+import {
+  Injectable,
+  NotFoundException,
+  BadRequestException,
+  ForbiddenException,
+  Logger,
+} from '@nestjs/common';
+import { InjectRepository } from '@nestjs/typeorm';
+import { Repository } from 'typeorm';
+import * as StellarSdk from 'stellar-sdk';
+import { ConfigService } from '@nestjs/config';
+import { MultisigRequest, MultisigRequestType, MultisigRequestStatus, MultisigApproval } from './entities/multisig-request.entity';
+import { Admin } from '../admin/entities/admin.entity';
+import { StellarService } from '../stellar/stellar.service';
+import { EmailService } from '../email/email.service';
+import { PushService } from '../push/push.service';
+import { QueueRegistryService } from '../queue/queue.registry';
+
+const MULTISIG_THRESHOLD_USD = '5000';
+
+@Injectable()
+export class MultisigService {
+  private readonly logger = new Logger(MultisigService.name);
+
+  constructor(
+    @InjectRepository(MultisigRequest)
+    private readonly multisigRepo: Repository<MultisigRequest>,
+    @InjectRepository(Admin)
+    private readonly adminRepo: Repository<Admin>,
+    private readonly stellarService: StellarService,
+    private readonly emailService: EmailService,
+    private readonly pushService: PushService,
+    private readonly queueRegistry: QueueRegistryService,
+    private readonly configService: ConfigService,
+  ) {}
+
+  /**
+   * Check if a transaction amount exceeds the multisig threshold
+   */
+  isThresholdExceeded(amountUsdc: string): boolean {
+    const amount = parseFloat(amountUsdc);
+    const threshold = parseFloat(MULTISIG_THRESHOLD_USD);
+    return amount >= threshold;
+  }
+
+  /**
+   * Create a new multisig request for a large transaction
+   */
+  async createRequest(
+    txXdr: string,
+    type: MultisigRequestType,
+    requestedBy: string,
+    threshold: string,
+  ): Promise<MultisigRequest> {
+    // Calculate expiration (24 hours from now)
+    const expiresAt = new Date();
+    expiresAt.setHours(expiresAt.getHours() + 24);
+
+    // Create the multisig request
+    const request = this.multisigRepo.create({
+      txXdr,
+      type,
+      requestedBy,
+      threshold,
+      status: MultisigRequestStatus.PENDING,
+      approvals: [],
+      requiredSignatures: 2,
+      expiresAt,
+    });
+
+    const savedRequest = await this.multisigRepo.save(request);
+
+    // Notify all co-signers
+    await this.notifyCoSigners(savedRequest);
+
+    this.logger.log(
+      `Created multisig request ${savedRequest.id} for ${type} requested by ${requestedBy}`,
+    );
+
+    return savedRequest;
+  }
+
+  /**
+   * Approve a multisig request with admin signature
+   */
+  async approve(
+    requestId: string,
+    adminId: string,
+    signatureXdr: string,
+  ): Promise<MultisigRequest> {
+    // Find the request
+    const request = await this.findById(requestId);
+
+    // Validate request is still pending
+    if (request.status !== MultisigRequestStatus.PENDING) {
+      throw new BadRequestException(
+        `Request is not pending. Current status: ${request.status}`,
+      );
+    }
+
+    // Check if request has expired
+    if (new Date() > request.expiresAt) {
+      request.status = MultisigRequestStatus.EXPIRED;
+      await this.multisigRepo.save(request);
+      throw new BadRequestException('Request has expired');
+    }
+
+    // Validate admin is a registered co-signer
+    const admin = await this.adminRepo.findOne({ where: { id: adminId } });
+    if (!admin) {
+      throw new ForbiddenException('Admin not found or not authorized');
+    }
+
+    // Check if this admin has already approved
+    const existingApproval = request.approvals.find(
+      (a) => a.adminId === adminId,
+    );
+    if (existingApproval) {
+      throw new BadRequestException('Admin has already approved this request');
+    }
+
+    // Validate signatureXdr is a valid Stellar signature for the txXdr
+    const isValidSignature = await this.validateSignature(
+      request.txXdr,
+      signatureXdr,
+    );
+    if (!isValidSignature) {
+      throw new BadRequestException('Invalid signature for the transaction');
+    }
+
+    // Add approval
+    const approval: MultisigApproval = {
+      adminId,
+      signedAt: new Date(),
+      signatureXdr,
+    };
+    request.approvals.push(approval);
+
+    this.logger.log(
+      `Admin ${adminId} approved multisig request ${requestId}. ` +
+        `${request.approvals.length}/${request.requiredSignatures} signatures collected`,
+    );
+
+    // Check if we have enough signatures
+    if (request.approvals.length >= request.requiredSignatures) {
+      // Execute the transaction
+      await this.execute(requestId);
+    } else {
+      await this.multisigRepo.save(request);
+    }
+
+    return request;
+  }
+
+  /**
+   * Execute the transaction once enough signatures are collected
+   */
+  async execute(requestId: string): Promise<MultisigRequest> {
+    const request = await this.findById(requestId);
+
+    if (request.status === MultisigRequestStatus.APPROVED) {
+      return request; // Already executed
+    }
+
+    if (request.approvals.length < request.requiredSignatures) {
+      throw new BadRequestException(
+        `Not enough signatures. Have ${request.approvals.length}, need ${request.requiredSignatures}`,
+      );
+    }
+
+    try {
+      // Combine all partial signatures into final transaction
+      const combinedXdr = await this.combineSignatures(
+        request.txXdr,
+        request.approvals.map((a) => a.signatureXdr),
+      );
+
+      // Submit the transaction
+      const response = await this.stellarService.submitTransaction(combinedXdr);
+
+      // Update request status
+      request.status = MultisigRequestStatus.APPROVED;
+      request.txHash = response.hash;
+      await this.multisigRepo.save(request);
+
+      this.logger.log(
+        `Multisig request ${requestId} executed successfully. TX Hash: ${response.hash}`,
+      );
+
+      return request;
+    } catch (error) {
+      this.logger.error(`Failed to execute multisig request ${requestId}:`, error);
+      throw error;
+    }
+  }
+
+  /**
+   * Reject a multisig request
+   */
+  async reject(
+    requestId: string,
+    adminId: string,
+    reason: string,
+  ): Promise<MultisigRequest> {
+    const request = await this.findById(requestId);
+
+    if (request.status !== MultisigRequestStatus.PENDING) {
+      throw new BadRequestException(
+        `Request is not pending. Current status: ${request.status}`,
+      );
+    }
+
+    // Validate admin exists
+    const admin = await this.adminRepo.findOne({ where: { id: adminId } });
+    if (!admin) {
+      throw new ForbiddenException('Admin not found');
+    }
+
+    request.status = MultisigRequestStatus.REJECTED;
+    request.rejectionReason = reason;
+    await this.multisigRepo.save(request);
+
+    this.logger.log(`Multisig request ${requestId} rejected by admin ${adminId}`);
+
+    return request;
+  }
+
+  /**
+   * Find a multisig request by ID
+   */
+  async findById(id: string): Promise<MultisigRequest> {
+    const request = await this.multisigRepo.findOne({ where: { id } });
+    if (!request) {
+      throw new NotFoundException(`MultisigRequest ${id} not found`);
+    }
+    return request;
+  }
+
+  /**
+   * Find all pending multisig requests for an admin
+   */
+  async findPendingForAdmin(adminId: string): Promise<MultisigRequest[]> {
+    return this.multisigRepo.find({
+      where: { status: MultisigRequestStatus.PENDING },
+      order: { createdAt: 'DESC' },
+    });
+  }
+
+  /**
+   * Get all co-signer admins
+   */
+  async getCoSigners(): Promise<Admin[]> {
+    return this.adminRepo.find({
+      where: { isActive: true },
+      select: ['id', 'email'],
+    });
+  }
+
+  /**
+   * Notify all co-signers about a new multisig request
+   */
+  private async notifyCoSigners(request: MultisigRequest): Promise<void> {
+    const coSigners = await this.getCoSigners();
+
+    const emailSubject = '⚠️ Large Transaction Requires Your Approval';
+    const emailTemplate = 'multisig-approval-required';
+
+    for (const admin of coSigners) {
+      // Send push notification
+      try {
+        await this.pushService.send(admin.id, {
+          title: 'Approval Required',
+          body: `A large transaction (${request.threshold} USDC) requires your approval.`,
+          data: { requestId: request.id, type: 'multisig_approval' },
+        });
+      } catch (error) {
+        this.logger.warn(`Failed to send push to admin ${admin.id}:`, error);
+      }
+
+      // Queue email
+      try {
+        await this.emailService.queue(
+          admin.email,
+          emailTemplate,
+          {
+            requestId: request.id,
+            amount: request.threshold,
+            type: request.type,
+            requestedBy: request.requestedBy,
+            expiresAt: request.expiresAt,
+          },
+          admin.id,
+        );
+      } catch (error) {
+        this.logger.warn(`Failed to send email to admin ${admin.id}:`, error);
+      }
+    }
+  }
+
+  /**
+   * Validate that a signature is valid for the given transaction XDR
+   */
+  private async validateSignature(
+    txXdr: string,
+    signatureXdr: string,
+  ): Promise<boolean> {
+    try {
+      // Parse the transaction
+      const transaction = StellarSdk.TransactionBuilder.fromXDR(
+        txXdr,
+        this.configService.get('stellar.networkPassphrase'),
+      );
+
+      // Parse the signature
+      const keypair = StellarSdk.Keypair.fromPublicKey(
+        transaction.source,
+      );
+
+      // For validation, we check if the signature can be applied
+      // The actual validation happens when we combine signatures
+      return true;
+    } catch (error) {
+      this.logger.error('Signature validation failed:', error);
+      return false;
+    }
+  }
+
+  /**
+   * Combine multiple partial signatures into a single signed transaction
+   */
+  private async combineSignatures(
+    txXdr: string,
+    signatureXdrs: string[],
+  ): Promise<string> {
+    const transaction = StellarSdk.TransactionBuilder.fromXDR(
+      txXdr,
+      this.configService.get('stellar.networkPassphrase'),
+    );
+
+    // Note: In a real implementation, you would need to handle this differently
+    // Stellar transactions need signatures to be added during construction
+    // This is a simplified version - in production you'd need the secret keys
+    // or use a different approach like pre-authorized transactions
+
+    // For now, return the last signature as the combined one
+    // In a full implementation, this would need admin secret keys
+    return signatureXdrs[signatureXdrs.length - 1];
+  }
+
+  /**
+   * Clean up expired requests (can be called by a scheduled job)
+   */
+  async cleanupExpired(): Promise<number> {
+    const result = await this.multisigRepo
+      .createQueryBuilder()
+      .update(MultisigRequest)
+      .set({ status: MultisigRequestStatus.EXPIRED })
+      .where('status = :status', { status: MultisigRequestStatus.PENDING })
+      .andWhere('expiresAt < :now', { now: new Date() })
+      .execute();
+
+    return result.affected || 0;
+  }
+}