一个跨链事件的旅程：3 个子事件，恰好 1 次 Commit

// 场景2：多子事件全成功 → 汇聚后仅一次 Commit
func TestE2E_MultiSubEvent_CommitOnce(t *testing.T) {
    gw := newE2EGateway(t, nil)
    defer gw.Stop()

    crossID := fmt.Sprintf("e2e-multi-%d", time.Now().UnixNano())
    // 3 个子事件全部目标 chain1
    gw.emitCrossEvent(crossID, []string{"chain1", "chain1", "chain1"})

    waitFor(t, 10*time.Second, func() bool { return gw.commitCount() >= 1 },
        "all sub events done should trigger exactly one commit")

    // 子事件执行次数：先等一拍让流程收敛，再校验 Commit 不会重复触发
    time.Sleep(500 * time.Millisecond)
    assert.Equal(t, 1, gw.commitCount(), "commit should fire exactly once for all sub events")
}

// 注入 mock 链工厂：AddChain → ChainResStartOpEvent → createChainAdapter 走 mock
mockAda := injectMockAdapter(t)
rm, err := resource.NewResourceManager(storeHandle)
eventBus := bus.NewHookEventBus()  // 独立事件总线
rt := runtime.NewRuntime(eventBus, storeHandle)
rt.RM = rm                         // 独立资源管理器

gw := newGateway(rt)
require.NoError(t, gw.Start(hooks...))                    // 启动全部 handler
require.NoError(t, gw.AddChain(testChainConfig("chain1"))) // 触发 mock 工厂创建适配器

func (h *ChainAdapterHandler) handleListenData(e *types.CrossEvent) {
    err := h.save(e) // ① 落库：主事件 + 3 个子事件，状态 Init，ExecIdx = 0/1/2
    if err != nil {
        h.log.Errorf("save cross[%s] event error : %v", e.CttListenData.CrossID, err)
    } else {
        if err = e.CheckAvailability(h.rm); err != nil { // ② 校验 CommitIdentity
            h.svc.UpdateMajorEventStatusAndMessage(e.CttListenData.CrossID,
                schema.NewEventStatus(schema.CrossEventStatusFailure, err.Error()))
            return // 不可用 → Failure，不进 Execute
        }
        for _, subEvent := range e.CttListenData.SubEvents {
            h.handleSubEvent(e, subEvent) // ③ 逐个发布"转发请求"事件
        }
        h.svc.UpdateMajorEventStatusAndMessage(e.CttListenData.CrossID,
            schema.NewEventStatus(schema.CrossEventStatusProcessing, "")) // ④ 主事件置 Processing
    }
}

func (m *mockChainAdapter) Invoke(e event.Event) (*adapter_types.InvokeContext, error) {
    m.mu.Lock()
    m.invokes = append(m.invokes, fmt.Sprintf("%d", e.Type())) // ① 记录"链被调了什么"
    m.mu.Unlock()
    if m.invokeFn != nil {
        return m.invokeFn(e)
    }
    return adapter_types.NewInvokeContext( // ② 返回成功
        fmt.Sprintf("mock-tx-%d", time.Now().UnixNano()),
        "mock invoke ok", schema.ContractStatusSuccess), nil
}

// 更新这个子事件的证明状态（落库）
err = r.svc.UpdateSubEventStxProveData(ctre.CrossID, ctre.ExecIdx, stxProveCtx)
// 从库里重新捞出全部 3 个子事件
dbCrossSubEvents, err := r.svc.GetCrossSubEventsByCrossID(ctre.CrossID)
// ...
for _, subEvent := range dbCrossSubEvents {
    if subEvent.ExecuteIdx == ctre.ExecIdx {
        // 当前处理的子事件：证明用内存里的值，不依赖库（源码注释标了 [IMPORTANT]）
        if txProveCtx.VerifyStatus > schema.ProveStatusUnknown {
            chainTxContexts.Append(/* ... */)
        }
    } else if subEvent.StxProveStatus > schema.ProveStatusUnknown {
        // 其他子事件：从库里数——判断是否处理完，不关心是否成功
        chainTxContexts.Append(/* ... */)
    }
}
if chainTxContexts.Len() == len(dbCrossSubEvents) {
    // 全齐 → 触发 Commit（有防重，见下）
}

// commitGuard 防止并发应答同时满足汇聚条件导致重复发布 Commit
// （多个子事件应答并发处理时，各自把自己计入内存中的证明上下文，
//   可能同时通过"全部完成"判断——LoadOrStore 保证只发布一次）
commitGuard sync.Map // crossID -> struct{}{}

// handleResponse 末尾：
if chainTxContexts.Len() == len(dbCrossSubEvents) {
    // 并发应答防重：原子占位，已发布过 Commit 的事件直接返回
    if _, loaded := r.commitGuard.LoadOrStore(ctre.CrossID, struct{}{}); loaded {
        r.log.Infof("commit for cross[%s] has already been published, skip duplicated trigger", ctre.CrossID)
        return nil
    }
    // 构造 CrossCommitEvent，发布到总线
}