36 KiB

Raw Blame History

MPC 分布式签名系统 - 架构设计文档

1. 系统概述

本系统是一个基于多方安全计算 (MPC) 的分布式门限签名系统，支持 t-of-n 阈值签名方案。系统采用 DDD (领域驱动设计) + 六边形架构 (Hexagonal Architecture) + 微服务 的架构模式，使用 Go 语言开发，基于 bnb-chain/tss-lib 实现 TSS (Threshold Signature Scheme) 协议。

1.1 核心特性

门限签名: 支持任意 t-of-n 阈值方案 (如 2-of-3, 3-of-5, 4-of-7)
分布式密钥生成 (DKG): 无需可信第三方生成密钥
ECDSA secp256k1: 与以太坊/比特币兼容的签名算法
高安全性: 密钥分片加密存储，单点泄露不影响安全性
微服务架构: 可独立扩展和部署
Clean Architecture: DDD + 六边形架构，领域逻辑与基础设施解耦

1.2 技术栈

层级	技术选型
语言	Go 1.21+
TSS 库	bnb-chain/tss-lib/v2
通信协议	gRPC + HTTP/REST
数据库	PostgreSQL
缓存	Redis
消息队列	RabbitMQ
服务发现	Consul
容器化	Docker + Docker Compose
架构模式	DDD + Hexagonal + Microservices

1.3 架构设计原则

原则	说明
依赖倒置	内层定义接口，外层实现；依赖指向内层
领域隔离	Domain 层零外部依赖，纯业务逻辑
端口适配	通过 Port/Adapter 模式解耦 I/O
服务自治	每个微服务独立部署、独立数据库
单一职责	每个服务只负责一个业务领域

2. 软件架构模式

2.1 DDD + 六边形架构 + 微服务

本系统采用三层架构模式的组合：

┌─────────────────────────────────────────────────────────────────────────────┐
│                           微服务架构 (Microservices)                         │
│  ┌─────────────────┐  ┌─────────────────┐  ┌─────────────────┐             │
│  │ Account Service │  │Session Coordinator│ │ Message Router │  ...        │
│  │   (独立部署)    │  │    (独立部署)     │  │   (独立部署)   │             │
│  └────────┬────────┘  └────────┬────────┘  └────────┬────────┘             │
│           │                    │                    │                       │
│           ▼                    ▼                    ▼                       │
│  ┌─────────────────────────────────────────────────────────────────────┐   │
│  │              六边形架构 (Hexagonal / Ports & Adapters)               │   │
│  │                                                                      │   │
│  │   ┌─────────────────────────────────────────────────────────────┐   │   │
│  │   │                    Adapters (Input)                          │   │   │
│  │   │  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐          │   │   │
│  │   │  │HTTP Handler │  │gRPC Handler │  │  消息消费者  │          │   │   │
│  │   │  └──────┬──────┘  └──────┬──────┘  └──────┬──────┘          │   │   │
│  │   └─────────┼────────────────┼────────────────┼──────────────────┘   │   │
│  │             │                │                │                      │   │
│  │             ▼                ▼                ▼                      │   │
│  │   ┌─────────────────────────────────────────────────────────────┐   │   │
│  │   │                  Application Layer                           │   │   │
│  │   │  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐       │   │   │
│  │   │  │ Input Ports  │  │  Use Cases   │  │ Output Ports │       │   │   │
│  │   │  │  (接口定义)   │  │  (业务编排)   │  │  (接口定义)   │       │   │   │
│  │   │  └──────────────┘  └──────────────┘  └──────────────┘       │   │   │
│  │   └─────────────────────────────────────────────────────────────┘   │   │
│  │             │                │                │                      │   │
│  │             ▼                ▼                ▼                      │   │
│  │   ┌─────────────────────────────────────────────────────────────┐   │   │
│  │   │                    Domain Layer (DDD)                        │   │   │
│  │   │  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐       │   │   │
│  │   │  │   Entities   │  │Value Objects │  │Domain Services│       │   │   │
│  │   │  │   (实体)      │  │  (值对象)     │  │ (领域服务)    │       │   │   │
│  │   │  └──────────────┘  └──────────────┘  └──────────────┘       │   │   │
│  │   │  ┌──────────────┐  ┌──────────────┐                         │   │   │
│  │   │  │ Repositories │  │  Aggregates  │                         │   │   │
│  │   │  │ (仓储接口)    │  │   (聚合根)    │                         │   │   │
│  │   │  └──────────────┘  └──────────────┘                         │   │   │
│  │   └─────────────────────────────────────────────────────────────┘   │   │
│  │             │                │                │                      │   │
│  │             ▼                ▼                ▼                      │   │
│  │   ┌─────────────────────────────────────────────────────────────┐   │   │
│  │   │                   Adapters (Output)                          │   │   │
│  │   │  ┌─────────────┐  ┌─────────────┐  ┌─────────────┐          │   │   │
│  │   │  │ PostgreSQL  │  │    Redis    │  │  RabbitMQ   │          │   │   │
│  │   │  │   Repo      │  │   Cache     │  │  Publisher  │          │   │   │
│  │   │  └─────────────┘  └─────────────┘  └─────────────┘          │   │   │
│  │   └─────────────────────────────────────────────────────────────┘   │   │
│  └─────────────────────────────────────────────────────────────────────┘   │
└─────────────────────────────────────────────────────────────────────────────┘

2.2 单个微服务内部结构

每个微服务采用六边形架构，内部分为三层：

service/
├── domain/                    # 领域层 (最内层，零外部依赖)
│   ├── entities/              # 实体 - 有唯一标识的领域对象
│   ├── value_objects/         # 值对象 - 无标识的不可变对象
│   ├── repositories/          # 仓储接口 - 领域定义，适配器实现
│   └── services/              # 领域服务 - 跨实体的业务逻辑
│
├── application/               # 应用层 (中间层，编排业务用例)
│   ├── ports/                 # 端口定义
│   │   ├── input/             # 入站端口 - 定义用例接口
│   │   └── output/            # 出站端口 - 定义基础设施接口
│   └── use_cases/             # 用例实现 - 业务流程编排
│
├── adapters/                  # 适配器层 (最外层，处理 I/O)
│   ├── input/                 # 入站适配器
│   │   ├── http/              # HTTP/REST 处理器
│   │   └── grpc/              # gRPC 处理器
│   └── output/                # 出站适配器
│       ├── postgres/          # PostgreSQL 仓储实现
│       ├── redis/             # Redis 缓存实现
│       └── rabbitmq/          # RabbitMQ 消息发布
│
└── cmd/server/                # 服务入口 - 依赖注入和启动
    └── main.go

2.3 DDD 战术模式实现

2.3.1 实体 (Entity)

有唯一标识的领域对象，封装业务规则：

// services/account/domain/entities/account.go
type Account struct {
    ID              value_objects.AccountID  // 唯一标识
    Username        string
    Email           string
    PublicKey       []byte
    Status          value_objects.AccountStatus
    ThresholdN      int
    ThresholdT      int
    CreatedAt       time.Time
    UpdatedAt       time.Time
}

// 业务方法封装在实体内
func (a *Account) Suspend() error {
    if a.Status == value_objects.AccountStatusRecovering {
        return ErrAccountInRecovery
    }
    a.Status = value_objects.AccountStatusSuspended
    a.UpdatedAt = time.Now().UTC()
    return nil
}

func (a *Account) CanLogin() bool {
    return a.Status.CanLogin()
}

2.3.2 值对象 (Value Object)

无标识的不可变对象，通过值相等性比较：

// services/account/domain/value_objects/account_id.go
type AccountID struct {
    value uuid.UUID
}

func NewAccountID() AccountID {
    return AccountID{value: uuid.New()}
}

func (id AccountID) String() string {
    return id.value.String()
}

func (id AccountID) Equals(other AccountID) bool {
    return id.value == other.value
}

// services/session-coordinator/domain/value_objects/session_status.go
type SessionStatus string

const (
    SessionStatusCreated    SessionStatus = "created"
    SessionStatusWaiting    SessionStatus = "waiting"
    SessionStatusInProgress SessionStatus = "in_progress"
    SessionStatusCompleted  SessionStatus = "completed"
    SessionStatusFailed     SessionStatus = "failed"
)

func (s SessionStatus) CanTransitionTo(target SessionStatus) bool {
    // 状态转换规则
    transitions := map[SessionStatus][]SessionStatus{
        SessionStatusCreated:    {SessionStatusWaiting, SessionStatusFailed},
        SessionStatusWaiting:    {SessionStatusInProgress, SessionStatusFailed},
        SessionStatusInProgress: {SessionStatusCompleted, SessionStatusFailed},
    }
    for _, allowed := range transitions[s] {
        if allowed == target {
            return true
        }
    }
    return false
}

2.3.3 聚合 (Aggregate)

聚合根管理一组相关实体的一致性边界：

// services/session-coordinator/domain/entities/mpc_session.go
// MPCSession 是聚合根，管理 Participants
type MPCSession struct {
    ID           uuid.UUID
    Type         SessionType
    Status       SessionStatus
    ThresholdT   int
    ThresholdN   int
    Participants []Participant  // 子实体
    CreatedAt    time.Time
}

// 聚合根负责维护内部一致性
func (s *MPCSession) AddParticipant(p Participant) error {
    if len(s.Participants) >= s.ThresholdN {
        return ErrSessionFull
    }
    if s.Status != SessionStatusWaiting {
        return ErrInvalidSessionStatus
    }
    s.Participants = append(s.Participants, p)
    return nil
}

func (s *MPCSession) AllParticipantsReady() bool {
    if len(s.Participants) < s.ThresholdN {
        return false
    }
    for _, p := range s.Participants {
        if p.Status != ParticipantStatusReady {
            return false
        }
    }
    return true
}

2.3.4 仓储接口 (Repository)

领域层定义接口，适配器层实现：

// services/account/domain/repositories/account_repository.go
type AccountRepository interface {
    Save(ctx context.Context, account *entities.Account) error
    FindByID(ctx context.Context, id value_objects.AccountID) (*entities.Account, error)
    FindByUsername(ctx context.Context, username string) (*entities.Account, error)
    FindByEmail(ctx context.Context, email string) (*entities.Account, error)
    Update(ctx context.Context, account *entities.Account) error
    Delete(ctx context.Context, id value_objects.AccountID) error
}

2.3.5 领域服务 (Domain Service)

跨实体的业务逻辑：

// services/session-coordinator/domain/services/session_coordinator.go
type SessionCoordinatorService struct {
    sessionRepo repositories.SessionRepository
}

func (s *SessionCoordinatorService) ValidateThreshold(t, n int) error {
    if t < 1 || t > n {
        return ErrInvalidThreshold
    }
    if n < 2 {
        return ErrInvalidPartyCount
    }
    return nil
}

2.4 六边形架构端口与适配器

2.4.1 入站端口 (Input Port)

定义用例接口：

// services/account/application/ports/input_ports.go
type CreateAccountInput struct {
    Username        string
    Email           string
    PublicKey       []byte
    ThresholdN      int
    ThresholdT      int
}

type CreateAccountOutput struct {
    Account *entities.Account
}

// 用例接口
type CreateAccountPort interface {
    Execute(ctx context.Context, input CreateAccountInput) (*CreateAccountOutput, error)
}

2.4.2 出站端口 (Output Port)

定义基础设施接口：

// services/session-coordinator/application/ports/output/session_storage_port.go
type SessionStoragePort interface {
    Save(ctx context.Context, session *entities.MPCSession) error
    FindByID(ctx context.Context, id uuid.UUID) (*entities.MPCSession, error)
    Update(ctx context.Context, session *entities.MPCSession) error
}

// services/session-coordinator/application/ports/output/message_broker_port.go
type MessageBrokerPort interface {
    PublishSessionEvent(ctx context.Context, event SessionEvent) error
    PublishPartyNotification(ctx context.Context, partyID string, msg []byte) error
}

2.4.3 用例实现 (Use Case)

编排业务流程：

// services/account/application/use_cases/create_account.go
type CreateAccountUseCase struct {
    accountRepo repositories.AccountRepository
    eventPub    ports.EventPublisherPort
}

func (uc *CreateAccountUseCase) Execute(
    ctx context.Context,
    input ports.CreateAccountInput,
) (*ports.CreateAccountOutput, error) {
    // 1. 创建领域实体
    account := entities.NewAccount(
        input.Username,
        input.Email,
        input.PublicKey,
        input.ThresholdN,
        input.ThresholdT,
    )

    // 2. 验证业务规则
    if err := account.Validate(); err != nil {
        return nil, err
    }

    // 3. 持久化
    if err := uc.accountRepo.Save(ctx, account); err != nil {
        return nil, err
    }

    // 4. 发布领域事件
    uc.eventPub.Publish(ctx, events.AccountCreated{AccountID: account.ID})

    return &ports.CreateAccountOutput{Account: account}, nil
}

2.4.4 入站适配器 (Input Adapter)

HTTP/gRPC 处理器：

// services/account/adapters/input/http/account_handler.go
type AccountHandler struct {
    createAccountUC ports.CreateAccountPort
    loginUC         ports.LoginPort
}

func (h *AccountHandler) CreateAccount(c *gin.Context) {
    var req CreateAccountRequest
    if err := c.ShouldBindJSON(&req); err != nil {
        c.JSON(400, gin.H{"error": err.Error()})
        return
    }

    output, err := h.createAccountUC.Execute(c.Request.Context(), ports.CreateAccountInput{
        Username:   req.Username,
        Email:      req.Email,
        PublicKey:  req.PublicKey,
        ThresholdN: req.ThresholdN,
        ThresholdT: req.ThresholdT,
    })
    if err != nil {
        c.JSON(500, gin.H{"error": err.Error()})
        return
    }

    c.JSON(201, output)
}

2.4.5 出站适配器 (Output Adapter)

数据库/缓存实现：

// services/account/adapters/output/postgres/account_repo.go
type PostgresAccountRepository struct {
    db *sql.DB
}

func (r *PostgresAccountRepository) Save(ctx context.Context, account *entities.Account) error {
    query := `INSERT INTO accounts (id, username, email, public_key, status, threshold_n, threshold_t, created_at)
              VALUES ($1, $2, $3, $4, $5, $6, $7, $8)`
    _, err := r.db.ExecContext(ctx, query,
        account.ID.String(),
        account.Username,
        account.Email,
        account.PublicKey,
        account.Status,
        account.ThresholdN,
        account.ThresholdT,
        account.CreatedAt,
    )
    return err
}

func (r *PostgresAccountRepository) FindByID(ctx context.Context, id value_objects.AccountID) (*entities.Account, error) {
    query := `SELECT id, username, email, public_key, status, threshold_n, threshold_t, created_at, updated_at
              FROM accounts WHERE id = $1`
    row := r.db.QueryRowContext(ctx, query, id.String())
    // ... scan and return
}

2.5 依赖注入 (Dependency Injection)

在 main.go 中组装依赖：

// services/account/cmd/server/main.go
func main() {
    // 基础设施
    db := connectDatabase()
    redisClient := connectRedis()
    rabbitConn := connectRabbitMQ()

    // 出站适配器 (实现端口)
    accountRepo := postgres.NewAccountRepository(db)
    cacheAdapter := redis.NewCacheAdapter(redisClient)
    eventPublisher := rabbitmq.NewEventPublisher(rabbitConn)

    // 用例 (注入依赖)
    createAccountUC := use_cases.NewCreateAccountUseCase(accountRepo, eventPublisher)
    loginUC := use_cases.NewLoginUseCase(accountRepo, cacheAdapter)

    // 入站适配器 (使用用例)
    handler := http.NewAccountHandler(createAccountUC, loginUC)

    // 启动服务器
    router := gin.Default()
    handler.RegisterRoutes(router)
    router.Run(":8080")
}

2.6 DDD 战术模式总览

DDD 概念	本系统实现	位置
Entity	Account, MPCSession, Participant	`domain/entities/`
Value Object	AccountID, SessionStatus, Threshold	`domain/value_objects/`
Aggregate	Account (含 AccountShare), MPCSession (含 Participant)	`domain/entities/`
Repository	AccountRepository, SessionRepository (接口)	`domain/repositories/`
Domain Service	SessionCoordinatorService, AccountService	`domain/services/`
Application Service	CreateAccountUseCase, JoinSessionUseCase	`application/use_cases/`
Input Port	CreateAccountPort, LoginPort	`application/ports/input/`
Output Port	SessionStoragePort, MessageBrokerPort	`application/ports/output/`
Input Adapter	AccountHandler (HTTP), SessionGrpcHandler	`adapters/input/`
Output Adapter	PostgresRepo, RedisCache, RabbitMQPublisher	`adapters/output/`

3. 系统部署架构

3.1 整体架构图

┌─────────────────────────────────────────────────────────────────────┐
│                           Client Layer                               │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐               │
│  │  iOS App     │  │  Android App │  │  Web Client  │               │
│  │  (MPC SDK)   │  │  (MPC SDK)   │  │              │               │
│  └──────┬───────┘  └──────┬───────┘  └──────┬───────┘               │
└─────────┼─────────────────┼─────────────────┼───────────────────────┘
          │                 │                 │
          ▼                 ▼                 ▼
┌─────────────────────────────────────────────────────────────────────┐
│                         API Gateway (HTTP/gRPC)                      │
└─────────────────────────────┬───────────────────────────────────────┘
                              │
          ┌───────────────────┼───────────────────┐
          ▼                   ▼                   ▼
┌─────────────────┐  ┌─────────────────┐  ┌─────────────────┐
│  Account        │  │  Session        │  │  Message        │
│  Service        │  │  Coordinator    │  │  Router         │
│  (用户/账户管理) │  │  (会话协调)     │  │  (消息路由)     │
│                 │  │                 │  │                 │
│  Port: 50054    │  │  Port: 50051    │  │  Port: 50052    │
│  HTTP: 8083     │  │  HTTP: 8080     │  │  HTTP: 8081     │
└────────┬────────┘  └────────┬────────┘  └────────┬────────┘
         │                    │                    │
         │                    ▼                    │
         │           ┌─────────────────┐           │
         │           │  Server Party   │           │
         │           │  Service x N    │◄──────────┘
         │           │  (MPC 计算节点)  │
         │           │                 │
         │           │  Party 1: 50053 │
         │           │  Party 2: 50055 │
         │           │  Party 3: 50056 │
         │           └────────┬────────┘
         │                    │
         ▼                    ▼
┌─────────────────────────────────────────────────────────────────────┐
│                        Data Layer                                    │
│  ┌──────────────┐  ┌──────────────┐  ┌──────────────┐               │
│  │  PostgreSQL  │  │    Redis     │  │  RabbitMQ    │               │
│  │  (持久化)    │  │  (缓存/会话) │  │  (消息队列)  │               │
│  └──────────────┘  └──────────────┘  └──────────────┘               │
└─────────────────────────────────────────────────────────────────────┘

3.2 服务职责

3.2.1 Session Coordinator (会话协调器)

创建和管理 MPC 会话
协调参与方加入会话
跟踪会话状态和进度
管理参与方就绪状态

3.2.2 Message Router (消息路由器)

路由 TSS 协议消息
支持点对点和广播消息
消息缓存和重传
WebSocket 实时通信

3.2.3 Server Party (服务端参与方)

作为 MPC 协议的服务端参与方
执行 DKG 和签名协议
安全存储加密的密钥分片
支持多实例部署

3.2.4 Account Service (账户服务)

用户注册和认证
账户管理
MPC 会话入口 API
账户恢复流程

4. 核心流程

4.1 密钥生成流程 (Keygen)

┌─────────┐     ┌─────────┐     ┌─────────┐     ┌─────────┐
│ Client  │     │Coordinator│   │ Router  │     │ Parties │
└────┬────┘     └────┬────┘     └────┬────┘     └────┬────┘
     │               │               │               │
     │ CreateSession │               │               │
     │──────────────>│               │               │
     │               │               │               │
     │  SessionID +  │               │               │
     │  JoinTokens   │               │               │
     │<──────────────│               │               │
     │               │               │               │
     │           JoinSession (各参与方)               │
     │──────────────────────────────────────────────>│
     │               │               │               │
     │           MarkReady (各参与方)                 │
     │──────────────────────────────────────────────>│
     │               │               │               │
     │          StartSession         │               │
     │──────────────>│               │               │
     │               │  Notify Start │               │
     │               │──────────────────────────────>│
     │               │               │               │
     │               │     TSS Messages (多轮)       │
     │               │               │<─────────────>│
     │               │               │               │
     │               │  ReportCompletion             │
     │               │<──────────────────────────────│
     │               │               │               │
     │  Session Completed            │               │
     │<──────────────│               │               │
     │               │               │               │

4.2 签名流程 (Signing)

┌─────────┐     ┌─────────┐     ┌─────────┐     ┌─────────┐
│ Client  │     │Coordinator│   │ Router  │     │ Parties │
└────┬────┘     └────┬────┘     └────┬────┘     └────┬────┘
     │               │               │               │
     │ CreateSignSession             │               │
     │ (messageHash) │               │               │
     │──────────────>│               │               │
     │               │               │               │
     │  SessionID    │               │               │
     │<──────────────│               │               │
     │               │               │               │
     │    JoinSession (t+1 参与方)   │               │
     │──────────────────────────────────────────────>│
     │               │               │               │
     │          StartSession         │               │
     │──────────────>│               │               │
     │               │               │               │
     │               │     TSS Messages (多轮)       │
     │               │               │<─────────────>│
     │               │               │               │
     │               │  Signature    │               │
     │               │<──────────────────────────────│
     │               │               │               │
     │  Signature (R, S, V)          │               │
     │<──────────────│               │               │
     │               │               │               │

5. 数据模型

5.1 Session (会话)

type Session struct {
    ID           uuid.UUID     // 会话唯一标识
    Type         SessionType   // keygen | sign
    Status       SessionStatus // created | waiting | in_progress | completed | failed
    ThresholdT   int           // 签名阈值 (t+1 签名者)
    ThresholdN   int           // 总参与方数
    MessageHash  []byte        // 待签名消息哈希 (签名会话)
    Participants []Participant // 参与方列表
    CreatedAt    time.Time
    ExpiresAt    time.Time
}

5.2 Participant (参与方)

type Participant struct {
    PartyID    string          // 参与方标识
    PartyIndex int             // 协议中的索引
    DeviceInfo DeviceInfo      // 设备信息
    Status     ParticipantStatus // joined | ready | computing | completed
    JoinToken  string          // 加入令牌
}

5.3 KeyShare (密钥分片)

type KeyShare struct {
    ID                uuid.UUID
    AccountID         uuid.UUID
    PartyID           string
    EncryptedShareData []byte   // AES-GCM 加密的分片数据
    PublicKey         []byte    // 组公钥
    CreatedAt         time.Time
}

6. 安全设计

6.1 密钥安全

密钥分片存储: 使用 AES-256-GCM 加密存储
主密钥管理: 从环境变量或 KMS 加载
无单点故障: 任意 t 个节点被攻破不影响安全性

6.2 通信安全

TLS 加密: 所有 gRPC/HTTP 通信使用 TLS
消息认证: TSS 消息包含参与方签名
会话令牌: 使用 UUID v4 生成一次性令牌

6.3 安全属性

属性	描述
门限安全	需要至少 t+1 方参与才能签名
密钥不可恢复	少于 t+1 个分片无法恢复私钥
前向安全	会话密钥独立，历史泄露不影响未来
抗合谋	t 个恶意方无法伪造签名

7. 部署架构

7.1 最小部署 (2-of-3)

┌─────────────────────────────────────────────────────────┐
│                    Server 1 (Coordinator)               │
│  ┌─────────────────┐  ┌─────────────────┐              │
│  │ Session Coord.  │  │ Message Router  │              │
│  │ Port: 50051     │  │ Port: 50052     │              │
│  └─────────────────┘  └─────────────────┘              │
│  ┌─────────────────┐  ┌─────────────────┐              │
│  │ Account Service │  │  PostgreSQL     │              │
│  │ Port: 50054     │  │  Redis/RabbitMQ │              │
│  └─────────────────┘  └─────────────────┘              │
└─────────────────────────────────────────────────────────┘

┌──────────────────┐  ┌──────────────────┐  ┌──────────────────┐
│   Server Party 1 │  │   Server Party 2 │  │   Server Party 3 │
│   Port: 50053    │  │   Port: 50055    │  │   Port: 50056    │
└──────────────────┘  └──────────────────┘  └──────────────────┘

7.2 生产环境部署

高可用: 每个服务至少 2 副本
负载均衡: Nginx/Traefik 反向代理
服务发现: Consul 集群
监控: Prometheus + Grafana

8. 目录结构

mpc-system/
├── api/                          # API 定义
│   ├── grpc/                     # gRPC 生成代码
│   └── proto/                    # Protobuf 定义
├── docs/                         # 文档
├── migrations/                   # 数据库迁移
├── pkg/                          # 公共包
│   ├── crypto/                   # 加密工具
│   └── tss/                      # TSS 封装
├── services/                     # 微服务
│   ├── account/                  # 账户服务
│   ├── message-router/           # 消息路由
│   ├── server-party/             # 服务端参与方
│   └── session-coordinator/      # 会话协调
├── tests/                        # 测试
│   ├── e2e/                      # 端到端测试
│   ├── integration/              # 集成测试
│   └── unit/                     # 单元测试
├── docker-compose.yml            # Docker 编排
├── Makefile                      # 构建脚本
└── go.mod                        # Go 模块

36 KiB Raw Blame History