IBシステムアーキテクチャ — ディールパイプラインからシンジケーションまで

+---------------------------------------------------------------+
|                     Investment Banking Division                |
|                                                               |
|  +-----------+  +-----------+  +-----------+                  |
|  |   ECM     |  |   DCM     |  |   M&A     |                  |
|  | 株式資本   |  | 負債資本   |  | 買収合併   |                  |
|  | 市場      |  | 市場      |  | アドバイザリ|                  |
|  | IPO/増資  |  | 社債/ABS  |  | 売手/買手  |                  |
|  | /CB      |  | /MTN     |  | フェアネス  |                  |
|  +-----------+  +-----------+  +-----------+                  |
|                                                               |
|  +------------------+  +---------------------------+          |
|  | Acquisition      |  | Loan Syndication          |          |
|  | Finance (買収金融)|  | (シンジケートローン組成)     |          |
|  | LBO/ブリッジローン|  | アレンジャー/エージェント銀行 |          |
|  +------------------+  +---------------------------+          |
|                                                               |
|  共通基盤: ディールパイプライン / コンフリクトチェック /          |
|           チャイニーズウォール / ドキュメント管理 /              |
|           インサイダーリスト / 規制報告 / CRM                   |
+---------------------------------------------------------------+

[Origination]      [Execution]                    [Closing]      [Post-Close]
     |                  |                             |               |
 アイデア/ピッチ --> マンデート獲得 --> デューデリ --> マーケティング/ --> プライシング
     |             |                |           ブックビルディング      |
     v             v                v              |                  v
 コンフリクト    エンゲージメント   ディールルーム  インサイダー       配分・決済・
 チェック       レター締結        開設(VDR)    リスト拡大          手数料精算
 (事前審査)                                                          |
                                                                    v
                                                          事後管理/リーグテーブル

-- コンフリクトチェックの中核クエリ: 同一・関連対象企業について
-- アクティブなディールが存在するかを検出
SELECT d.deal_id,
       d.deal_type,
       d.stage,
       c.company_name,
       r.relation_type        -- TARGET / ACQUIRER / ISSUER / SPONSOR
FROM   deal d
JOIN   deal_company_rel r ON r.deal_id = d.deal_id
JOIN   company c          ON c.company_id = r.company_id
WHERE  d.stage NOT IN ('CLOSED', 'DEAD')
AND    c.company_group_id IN (
         -- 新規ディール対象企業と同じ企業グループまで拡張
         SELECT company_group_id FROM company
         WHERE  company_id = :new_deal_target_id
       );

# ディール単位アクセスポリシーの例(ポリシーエンジン入力)
policy:
  resource: deal/PRJ-FALCON
  default: deny
  rules:
    - effect: allow
      subjects:
        - group: deal-team/PRJ-FALCON        # ディールチームメンバー
        - group: compliance-surveillance      # コンプライアンス(常時閲覧権)
      actions: [read, write]
    - effect: allow
      subjects:
        - group: ib-management                # 部門経営陣
      actions: [read-summary]                 # 要約のみ、文書アクセス不可
    - effect: deny
      subjects:
        - group: research                     # リサーチ部門は明示的に遮断
        - group: sales-trading
      actions: [read, write, read-summary]
      override: true                          # allowより優先

# 文書閲覧時の動的ウォーターマーク適用(概念例)
from pypdf import PdfReader, PdfWriter
from reportlab.pdfgen import canvas
from io import BytesIO
import datetime

def apply_watermark(src_pdf: bytes, user_id: str, deal_code: str) -> bytes:
    stamp_buf = BytesIO()
    c = canvas.Canvas(stamp_buf)
    text = f"{deal_code} / {user_id} / {datetime.datetime.utcnow().isoformat()}"
    c.setFont("Helvetica", 7)
    c.setFillColorRGB(0.6, 0.6, 0.6, alpha=0.4)
    # 斜め方向の繰り返しウォーターマーク
    c.saveState()
    c.translate(300, 400)
    c.rotate(45)
    for y in range(-400, 400, 60):
        c.drawString(-250, y, text)
    c.restoreState()
    c.save()
    stamp_buf.seek(0)

    stamp = PdfReader(stamp_buf).pages[0]
    reader = PdfReader(BytesIO(src_pdf))
    writer = PdfWriter()
    for page in reader.pages:
        page.merge_page(stamp)
        writer.add_page(page)
    out = BytesIO()
    writer.write(out)
    return out.getvalue()

CREATE TABLE insider_list_entry (
    entry_id        BIGINT PRIMARY KEY,
    deal_id         BIGINT NOT NULL REFERENCES deal(deal_id),
    person_id       BIGINT NOT NULL REFERENCES person(person_id),
    reason          VARCHAR(200) NOT NULL,   -- 登録事由(チーム、ウォールクロス、外部アドバイザー等)
    obtained_at     TIMESTAMP NOT NULL,      -- MNPIアクセス開始時刻
    notified_at     TIMESTAMP,               -- 本人への通知時刻(義務的告知)
    removed_at      TIMESTAMP,               -- リスト除外時刻
    removed_reason  VARCHAR(200),
    created_by      VARCHAR(50) NOT NULL,
    created_at      TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP
);

-- インサイダーリストは訂正履歴まで保存する必要があるためUPDATE禁止、
-- 変更は新規row + 旧rowの無効化で処理(バイテンポラルパターン)
CREATE INDEX idx_insider_deal ON insider_list_entry (deal_id, obtained_at);
CREATE INDEX idx_insider_person ON insider_list_entry (person_id, obtained_at);

# 単純化した配分エンジンの概念例
# 実際の配分は定性評価(アンカー投資家、長期保有性向)が組み合わさる
# 審査プロセスであり、以下は比例配分の骨格のみを示す。
from dataclasses import dataclass

@dataclass
class Order:
    investor_id: str
    quantity: int          # 申込数量
    limit_price: int       # 希望価格、成行はレンジ上限として処理
    investor_grade: str    # 内部格付: ANCHOR / LONG_ONLY / HEDGE / RETAIL_INST

GRADE_WEIGHT = {"ANCHOR": 1.5, "LONG_ONLY": 1.2, "HEDGE": 0.8, "RETAIL_INST": 1.0}

def build_demand_curve(orders, price_grid):
    """価格帯別の累積需要曲線: その価格以上を提示した注文の合計"""
    return {
        p: sum(o.quantity for o in orders if o.limit_price >= p)
        for p in price_grid
    }

def allocate(orders, final_price, total_shares):
    eligible = [o for o in orders if o.limit_price >= final_price]
    weighted = sum(o.quantity * GRADE_WEIGHT[o.investor_grade] for o in eligible)
    allocations = {}
    remaining = total_shares
    for o in sorted(eligible, key=lambda x: GRADE_WEIGHT[x.investor_grade], reverse=True):
        share = int(total_shares * o.quantity * GRADE_WEIGHT[o.investor_grade] / weighted)
        share = min(share, o.quantity, remaining)
        allocations[o.investor_id] = share
        remaining -= share
    # 残余物量は端数補正ルールで再配分(省略)
    return allocations, remaining

# 利息期間終了時の参加機関別配分計算(概念例)
from decimal import Decimal, ROUND_HALF_UP

def distribute_interest(total_interest: Decimal, participations: dict) -> dict:
    """participations: {institution_id: outstanding_amount}"""
    total_outstanding = sum(participations.values())
    result = {}
    allocated = Decimal("0")
    items = sorted(participations.items())
    for inst, amount in items[:-1]:
        share = (total_interest * amount / total_outstanding).quantize(
            Decimal("0.01"), rounding=ROUND_HALF_UP)
        result[inst] = share
        allocated += share
    # 最後の機関が端数を吸収 — 合計は必ず一致しなければならない
    last_inst = items[-1][0]
    result[last_inst] = total_interest - allocated
    assert sum(result.values()) == total_interest
    return result

エクスポージャー集計の概念:
  総エクスポージャー(企業グループG)
    = Σ 実行残高(グループ内の全借入人)
    + Σ 未引出コミットメント × 信用換算率(CCF)
    + Σ 引受ポジション(セルダウン未完了分)
  限度チェックは新規ディール承認時点 + 日次バッチの両方で実行

+--------------+        +-------------------+        +--------------+
|   COMPANY    |        |       DEAL        |        |    PERSON    |
+--------------+        +-------------------+        +--------------+
| company_id PK|---+    | deal_id PK        |    +---| person_id PK |
| group_id     |   |    | code_name UQ      |    |   | dept         |
| lei          |   +--<-| deal_type         |    |   | side (pub/pr)|
| name         |        | stage             |    |   +--------------+
+--------------+        | expected_fee      |    |
       ^                | probability       |    |
       |                +-------------------+    |
       |                  |       |      |       |
+------+--------+         |       |      +-------+----------+
| DEAL_COMPANY_ |---------+       |              |          |
| REL           |        +--------+-----+  +-----+------+  +-+----------+
| (TARGET/      |        | DEAL_DOCUMENT|  | DEAL_TEAM  |  | INSIDER_   |
|  ACQUIRER/    |        +--------------+  +------------+  | LIST_ENTRY |
|  ISSUER...)   |        | doc_id PK    |  | deal_id FK |  +------------+
+---------------+        | deal_id FK   |  | person_id  |  | deal_id FK |
                         | version      |  | role       |  | person_id  |
+---------------+        | status       |  | granted_at |  | obtained_at|
| ORDER (ブック) |        | sha256       |  | revoked_at |  | removed_at |
+---------------+        +--------------+  +------------+  +------------+
| order_id PK   |
| deal_id FK    |        +-----------------+   +----------------------+
| investor_id   |        | FACILITY (ローン)|   | PARTICIPATION (持分) |
| qty / price   |        +-----------------+   +----------------------+
| superseded_by |        | facility_id PK  |---| facility_id FK       |
+---------------+        | deal_id FK      |   | institution_id       |
                         | tranche_type    |   | commitment_amt       |
+---------------+        | limit_amt       |   | effective_from/to    |
| ALLOCATION    |        | margin_bps      |   +----------------------+
+---------------+        +-----------------+
| order_id FK   |
| alloc_qty     |
| adjusted_by   |
+---------------+

# ディールのステージ遷移を明示的な状態機械で強制する例
from enum import Enum

class Stage(Enum):
    PITCH = "PITCH"
    CONFLICT_CHECK = "CONFLICT_CHECK"
    MANDATED = "MANDATED"
    DUE_DILIGENCE = "DUE_DILIGENCE"
    MARKETING = "MARKETING"
    PRICING = "PRICING"
    CLOSED = "CLOSED"
    DEAD = "DEAD"

TRANSITIONS = {
    Stage.PITCH:          {Stage.CONFLICT_CHECK, Stage.DEAD},
    Stage.CONFLICT_CHECK: {Stage.MANDATED, Stage.DEAD},
    Stage.MANDATED:       {Stage.DUE_DILIGENCE, Stage.DEAD},
    Stage.DUE_DILIGENCE:  {Stage.MARKETING, Stage.DEAD},
    Stage.MARKETING:      {Stage.PRICING, Stage.DEAD},
    Stage.PRICING:        {Stage.CLOSED, Stage.DEAD},
}

REQUIRED_APPROVALS = {
    (Stage.PITCH, Stage.CONFLICT_CHECK): ["team_head"],
    (Stage.CONFLICT_CHECK, Stage.MANDATED): ["compliance", "business_head"],
    (Stage.MARKETING, Stage.PRICING): ["syndicate_head", "compliance"],
}

def transition(deal, target: Stage, approvals: set, actor: str):
    if target not in TRANSITIONS[deal.stage]:
        raise ValueError(f"illegal transition {deal.stage} -> {target}")
    needed = set(REQUIRED_APPROVALS.get((deal.stage, target), []))
    if not needed.issubset(approvals):
        raise PermissionError(f"missing approvals: {needed - approvals}")
    audit_log(deal.deal_id, deal.stage, target, actor, approvals)
    deal.stage = target