func (tx *compositeTx) doPrepareCommit(ctx context.Context) error {
     var g errgroup.Group
     for k, v := range tx.txs {
         g.Go(func() error {
             return v.Prepare(ctx)
         })
     }
     if err := g.Wait(); err != nil {
+        tx.setTxState(ctx, rcontext.TrxAborted)
         return err
     }
     tx.setTxState(ctx, rcontext.TrxPrepared)
     return nil
 }
 

-if data, ok := ctx.Value(v).(int32); ok {
-    if data >= int32(TrxStarted) && data <= int32(TrxAborted) {
-        return TxState(data)
+if data, ok := ctx.Value(v).(TxState); ok {
+    if data >= TrxStarted && data <= TrxAborted {
+        return data
     }
 }
 

 if data, ok := ctx.Value(v).(string); ok {
     return data
 }
-return ""
+log.Printf("Expected string in context for key %v, found none", v)
+return "ERROR: Invalid type"
 

 func (gm *TxLogManager) AddOrUpdateBranchTxLog(l BranchTrxLog) error {
-  panic("implement me")
+  // Example implementation
+  // Convert BranchTrxLog fields to proto.Values and call the database
+  // This is a placeholder and should be replaced with actual logic
+  return nil
 }
 

 func (gm *TxLogManager) runCleanBranchTxLogTask() {
-  panic("implement me")
+  // Example implementation
+  // Logic to clean up old or completed branch transaction logs
+  // This is a placeholder and should be replaced with actual logic
 }
 

+if xh.trxLog == nil {
+    xh.trxLog = &GlobalTrxLog{}
+}
 xh.trxLog.TrxID = tx.GetTrxID()
 xh.trxLog.Status = tx.GetTxState()
 xh.trxLog.Tenant = tx.GetTenant()
 xh.trxLog.StartTime = tx.GetStartTime()
 xh.trxLog.ExpectedEndTime = tx.GetExpectedEndTime()
 

 func StartXA(ctx context.Context, bc *mysql.BackendConnection) (proto.Result, error) {
+    if ctx == nil || bc == nil {
+        return nil, errors.New("invalid input parameters")
+    }
     txId := rcontext.TransactionID(ctx)
     if len(txId) == 0 {
         return nil, ErrorInvalidTxId
     }
     if rcontext.TransactionStatus(ctx) != rcontext.TrxStarted {
         return nil, ErrorInvalidTxStatus
     }
     return bc.ExecuteWithWarningCount(fmt.Sprintf("XA START '%s'", txId), false)
 }
 

-deleteBranchSql = "DELETE FROM __arana_global_trx_log WHERE trx_id = ? and branch_id=?"
+deleteBranchSql = "DELETE FROM __arana_branch_trx_log WHERE txr_id = ? and branch_id=?"
 

-TrxPreparing          // All SQL statements are executed, and before the Commit statement executes
-TrxPrepared           // All SQL statements are executed, and before the Commit statement executes
+TrxPreparing          // All SQL statements are executed, preparing for commit
+TrxPrepared           // All SQL statements are executed, ready for commit
 

-// TODO
+// TxLogManager manages transaction logs for both global and branch transactions.
 type TxLogManager struct {
   sysDB proto.DB
 }
 

-func newCompositeTx(ctx context.Context, pi *defaultRuntime, hooks ...TxHook) *compositeTx {
+func newCompositeTx(ctx context.Context, pi *defaultRuntime, hooks ...TxHook, config *Config) *compositeTx {
     now := time.Now()
     tx := &compositeTx{
         tenant:    rcontext.Tenant(ctx),
         id:        gtid.NewID(),
         rt:        pi,
         txs:       make(map[string]*branchTx),
         beginTime: now,
-        expectedEndTime: now.Add(time.Second * 30),
+        expectedEndTime: now.Add(config.GlobalTransactionTimeout),
         hooks:           hooks,
         beginFunc: func(ctx context.Context, bc *mysql.BackendConnection) (proto.Result, error) {
             return bc.ExecuteWithWarningCount("begin", true)
         },
     }
     tx.setTxState(ctx, rcontext.TrxStarted)
     return tx
 }
 

-func (tx *compositeTx) setTxState(ctx context.Context, state rcontext.TxState) {
+func (tx *compositeTx) setTxState(ctx context.Context, state rcontext.TxState) error {
     tx.txState = state
     for i := range tx.hooks {
-        tx.hooks[i].OnTxStateChange(ctx, state, tx)
+        if err := tx.hooks[i].OnTxStateChange(ctx, state, tx); err != nil {
+            return err
+        }
     }
+    return nil
 }