fix: prevent nc history race condition when running more than one request at once

[pedroferreira1]

Motivation

The nano contract history list shows duplicate transactions. One possibility is a race condition when loading the before history more than once, and we don't deduplicate the elements.

Deduplicating it is more expensive than having a lock to prevent concurrent calls. Below a better analysis of the scenario from claude.

Acceptance Criteria

• Create lock to prevent concurrent requests.

Example of race condition

The Bug: Race Condition in Saga Guard                                                                                                                                                                                                                                      
                                                                                                                                                                                                                                                                             
  Looking at src/sagas/nanoContract.js:333-343:                                                                                                                                                                                                                              
                                                                                                                                                                                                                                                                             
  export function* requestHistoryNanoContract({ payload }) {                                                                                                                                                                                                                 
    const { ncId, before, after } = payload;                                                                                                                                                                                                                                 
                                                                                                                                                                                                                                                                             
    const historyMeta = yield select((state) => state.nanoContract.historyMeta);                                                                                                                                                                                             
    if (historyMeta[ncId] && historyMeta[ncId].isLoading) {                                                                                                                                                                                                                  
      // Do nothing if nano contract already loading...                                                                                                                                                                                                                      
      return;                                                                                                                                                                                                                                                                
    }                                                                                                                                                                                                                                                                        
    yield put(nanoContractHistoryLoading({ ncId }));  // <-- Race window here!                                                                                                                                                                                               
    // ...                                                                                                                                                                                                                                                                   
  }                                                                                                                                                                                                                                                                          
                                                                                                                                                                                                                                                                             
  There's a race window between yield select() and yield put(). In Redux-Saga, each yield is a suspension point where other sagas can run.                                                                                                                                   
                                                                                                                                                                                                                                                                             
  How Duplicates Occur                                                                                                                                                                                                                                                       
                                                                                                                                                                                                                                                                             
  1. Component mounts with txHistory = [A, B, C]                                                                                                                                                                                                                             
  2. useEffect dispatches nanoContractHistoryRequest({ ncId, before: A.txId })                                                                                                                                                                                               
  3. Saga1 starts, yield select() → isLoading: false                                                                                                                                                                                                                         
  4. User immediately pulls to refresh (or React StrictMode double-mounts)                                                                                                                                                                                                   
  5. handleNewerTransactions dispatches nanoContractHistoryRequest({ ncId, before: A.txId }) — same parameters!                                                                                                                                                              
  6. Saga2 starts, yield select() → isLoading: false (Saga1 hasn't put yet!)                                                                                                                                                                                                 
  7. Both sagas pass the guard and proceed                                                                                                                                                                                                                                   
  8. Both fetch with before: A.txId, both get [D, E]                                                                                                                                                                                                                         
  9. Saga1 dispatches nanoContractHistorySuccess({ ncId, beforeHistory: [D, E] })                                                                                                                                                                                            
  10. Reducer: [D, E] + [A, B, C] = [D, E, A, B, C]                                                                                                                                                                                                                          
  11. Saga2 dispatches nanoContractHistorySuccess({ ncId, beforeHistory: [D, E] })                                                                                                                                                                                           
  12. Reducer: [D, E] + [D, E, A, B, C] = [D, E, D, E, A, B, C] ← DUPLICATES!

[pedroferreira1]

The history of a nano returns also txs of other contracts that execute methods of this contract, so lastTx.ncId was a different of ncId in some of the txs.

[tuliomir]

suggestion(non-blocking): Create a constant or enum for this hardcoded string

[pedroferreira1]

Much better, thanks! c99b622

[tuliomir]

suggestion(non-blocking): Rename to getLoadingLockSet and the variables that fetch from here to loadingLock.

It makes it easier to understand, since most other places with loading in this codebase refer to a component state related to a spinner for user feedback.

[pedroferreira1]

Much better, thanks! c99b622