Topic: [ANN][COMB] Haircomb - Quantum proof, anonymity and more - page 3. (Read 7091 times)

	for combbase := range bases {
		segments_transaction_mutex.RLock()
		segments_merkle_mutex.RLock()
		
		segments_coinbase_backgraph(backgraph, make(map[[32]byte]struct{}), target, combbase)
		
		segments_merkle_mutex.RUnlock()
		segments_transaction_mutex.RUnlock()

	}

func loopdetect(norecursion, loopkiller map[[32]byte]struct{}, to [32]byte) (b bool) {
	segments_transaction_mutex.RLock()
	segments_merkle_mutex.RLock()
	
	var type3 = segments_stack_type(to)
	if type3 == SEGMENT_STACK_TRICKLED {
		b = segments_stack_loopdetect(norecursion, loopkiller, to)
	}
	var type2 = segments_merkle_type(to)
	if type2 == SEGMENT_MERKLE_TRICKLED {
		b = segments_merkle_loopdetect(norecursion, loopkiller, to)
	}
	var type1 = segments_transaction_type(to)
	if type1 == SEGMENT_TX_TRICKLED {
		b = segments_transaction_loopdetect(norecursion, loopkiller, to)
	} else if type1 == SEGMENT_ANY_UNTRICKLED {
	} else if type1 == SEGMENT_UNKNOWN {
	}
	segments_merkle_mutex.RUnlock()
	segments_transaction_mutex.RUnlock()
	return b
}

	commits_mutex.RLock()
	var allright1 = merkle_scan_one_leg_activity(q1)
	var allright2 = merkle_scan_one_leg_activity(q2)

	if allright1 && allright2 {
		reactivate_txid(false, true, tx)
	}
	
	commits_mutex.RUnlock()
	return true, e[0]
	

if newactivity {
			segments_transaction_mutex.Lock()
			segments_merkle_mutex.Lock()
			if old, ok1 := e0_to_e1[e[0]]; ok1 && old != e[1] {

				fmt.Println("Panic: e0 to e1 already have live path")
				panic("")
			}

			e0_to_e1[e[0]] = e[1]
			segments_merkle_mutex.Unlock()
			segments_transaction_mutex.Unlock()
			
			segments_transaction_mutex.RLock()
			segments_merkle_mutex.RLock()
			
			var maybecoinbase = commit(e[0][0:])
			if _, ok1 := combbases[maybecoinbase]; ok1 {
				segments_coinbase_trickle_auto(maybecoinbase, e[0])
			}

			segments_merkle_trickle(make(map[[32]byte]struct{}), e[0])
			
			segments_merkle_mutex.RUnlock()
			segments_transaction_mutex.RUnlock()

		}

        if *tx == (*txidto)[0] {
                segments_transaction_mutex.Lock()
                segments_transaction_next[actuallyfrom] = *txidto
                segments_transaction_mutex.Unlock()
                return false
        }

	segments_transaction_mutex.RLock()
	segments_merkle_mutex.RLock()

	var maybecoinbase = commit(actuallyfrom[0:])
	if _, ok1 := combbases[maybecoinbase]; ok1 {
		segments_coinbase_trickle_auto(maybecoinbase, actuallyfrom)
	}

	segments_transaction_trickle(make(map[[32]byte]struct{}), actuallyfrom)

	segments_merkle_mutex.RUnlock()
	segments_transaction_mutex.RUnlock()

	segments_transaction_mutex.RLock()

	var val = segments_transaction_data[*tx][i]

	segments_transaction_mutex.RUnlock()

	if oldactivity == 2097151 {
		segments_transaction_mutex.Lock()
			       
		var actuallyfrom = segments_transaction_data[*tx][21]

		segments_transaction_untrickle(nil, actuallyfrom, 0xffffffffffffffff)

		delete(segments_transaction_next, actuallyfrom)

		segments_transaction_mutex.Unlock()
	}

	segments_transaction_mutex.RLock()
	segments_merkle_mutex.RLock()

	segments_stack_trickle(make(map[[32]byte]struct{}), hash)

	segments_merkle_mutex.RUnlock()
	segments_transaction_mutex.RUnlock()

	segments_transaction_mutex.Lock()
	segments_merkle_mutex.Lock()

	segments_merkle_mutex.Unlock()
	segments_transaction_mutex.Unlock()

segments_transaction_loopdetect()
segments_transaction_backgraph()
segments_merkle_loopdetect()
segments_merkle_backgraph()

if newactivity == 2097151 {

	Lock(segments_transaction_mutex)

	segments_transaction_next[actuallyfrom] = txidandto

	Unlock(segments_transaction_mutex)

	RLock(segments_transaction_mutex)
	RLock(segments_merkle_mutex)

	var maybecoinbase = commit(actuallyfrom[0:])
	if _, ok1 := combbases[maybecoinbase]; ok1 {
		// ...invoke coinbase trickling in case the haircomb was a coinbase
		segments_coinbase_trickle_auto(maybecoinbase, actuallyfrom)
	}

	//..invoke cash trickling here:
	segments_transaction_trickle(make(map[[32]byte]struct{}), actuallyfrom)

	RUnlock(segments_merkle_mutex)
	RUnlock(segments_transaction_mutex)

}

l := len(v) - 1

l := len(used_height_commits[min_height]) - 1

l := len(used_commit_keys[min_commit]) - 1

iter := commitsdb.NewIterator(&util.Range{Start: new_height_tag(uint64(target_height)+1), Limit: new_height_tag(uint64(height+1))}, nil)

       // Flush
       var commit_fingerprint hash.Hash
       if dir == -1 {
               commit_fingerprint = miner_mine_commit_pulled("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF",
                       new_flush_utxotag(uint64(parsed_block.height)-1), 0)
       } else if dir == 1 {
               commit_fingerprint = miner_mine_commit_pulled("FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF",
                       new_flush_utxotag(uint64(parsed_block.height)), 0)
       }

rpcuser=XXXXX
rpcpassword=XXXXX

btcuser=XXXXX
btcpass=XXXXX