279 lines
12 KiB
Bash
Executable File
279 lines
12 KiB
Bash
Executable File
#!/bin/bash
|
|
|
|
scanTxWallets() {
|
|
local REGEX_PUBKEYS="[a-zA-Z0-9]{42,44}"
|
|
# On vérifie le cache existant et on démarre au dernier bloc en cache
|
|
if ls $GPATH/cache/walletsUp-* > /dev/null 2>&1; then
|
|
local startFile=$(ls $GPATH/cache/walletsUp-* | tail -n1)
|
|
local startIter=$(echo "$startFile" | awk -F '-' '{ print $NF }')
|
|
((startIter++))
|
|
local startBloc=$(head -n1 "$startFile")
|
|
wallets=$(tail -n +2 "$startFile" | sed '/---/Q' | sort -u)
|
|
local walletsAuj=$(cat "$startFile" | sed -e '1,/---/d' | sed '/---/Q' | grep .)$'\n'
|
|
local nbrMembersYesterday=$(cat "$startFile" | sed -e '1,/---/d' | sed -e '1,/---/d' | sed '/---/Q' | grep . | cut -d '|' -f 1)
|
|
local blockDateLast=$(cat "$startFile" | sed -e '1,/---/d' | sed -e '1,/---/d' | sed '/---/Q' | grep . | cut -d '|' -f 2)
|
|
local nbrDays=$(cat "$startFile" | sed -e '1,/---/d' | sed -e '1,/---/d' | sed '/---/Q' | grep . | cut -d '|' -f 3)
|
|
#! ($debug) &&
|
|
[[ $lastBloc -le $startBloc || $startIter -ge ${#TXBLOCKS[@]} ]] && echo "$lastBloc -le $startBloc || $startIter -ge ${#TXBLOCKS[@]}" && return
|
|
rm $startFile
|
|
else
|
|
local startIter=0
|
|
local startBloc=0
|
|
local nbrDays=1
|
|
echo "[" > $jsonFile
|
|
fi
|
|
incExec=1
|
|
for ((i=$startIter; i<${#TXBLOCKS[@]}; i++)); do
|
|
local nbrIteration=$i
|
|
local startExec=$(($(date +%s%N)/1000000))
|
|
local bloc=${TXBLOCKS[$i]}
|
|
[[ -z $bloc ]] && break
|
|
# [[ $i -lt 1190 ]] && continue #kopa
|
|
|
|
# Récupération du bloc courant
|
|
local blocFull=$(curl -s ${DUNITER}/blockchain/block/$bloc)
|
|
while [[ $(jq -r '.ucode' <<<"$blocFull") == 1006 ]]; do
|
|
[[ $isWeb != "web" ]] && echo -e "i: $i\n$blocFull"
|
|
sleep 2
|
|
blocFull=$(curl -s ${DUNITER}/blockchain/block/$bloc)
|
|
done
|
|
until blocBrut=$(jq -r '.' <<<"$blocFull" 2>/dev/null); do
|
|
[[ $isWeb != "web" ]] && echo -e "i: $i\n$blocFull"
|
|
sleep 2
|
|
blocFull=$(curl -s ${DUNITER}/blockchain/block/$bloc)
|
|
done
|
|
[[ -z "$blocBrut" ]] && continue
|
|
|
|
echo "$blocFull" > debugTmp.txt
|
|
echo "-----------------------------------" >> debugTmp.txt
|
|
echo "$blocBrut" >> debugTmp.txt
|
|
|
|
# Récupération de la date du block
|
|
local blockDate=$(jq '.medianTime' <<<"$blocBrut")
|
|
#kopa echo "$blocBrut"
|
|
# echo "---"
|
|
# echo "$blockDate"
|
|
blockDate=$(date -d"@$blockDate" +%d-%m-%y -u)
|
|
local walletsReceivedBloc=$(jq '.transactions[]' <<<"$blocBrut")
|
|
|
|
# Si cette itération provient d'un cache, alors on aggrège la dernière date
|
|
if [[ $startBloc != 0 ]]; then
|
|
local lastDate=$(jq -r '.[].date' $jsonFile | tail -n1)
|
|
if [[ "$blockDate" == "$lastDate" || (-n $blockDateLast && $blockDateLast != $blockDate) ]]; then
|
|
local valueReceivedW=$(jq -r '.[].rWallets' $jsonFile | tail -n1 | xargs echo 100* | bc)
|
|
local valueReceivedM=$(jq -r '.[].rMembers' $jsonFile | tail -n1 | xargs echo 100* | bc)
|
|
local valueSentW=$(jq -r '.[].sWallets' $jsonFile | tail -n1 | xargs echo 100* | bc)
|
|
local valueSentM=$(jq -r '.[].sMembers' $jsonFile | tail -n1 | xargs echo 100* | bc)
|
|
|
|
local recusJson=$(head -n -11 $jsonFile)
|
|
echo "$recusJson" > $jsonFile
|
|
else
|
|
local recusJson=$(head -n -2 $jsonFile)
|
|
echo -e "$recusJson\n }," > $jsonFile
|
|
fi
|
|
startBloc=0
|
|
fi
|
|
|
|
# Sélectionne les ligne SIG en retirant les issuers
|
|
OIFS="$IFS"
|
|
IFS='{'
|
|
for j in $walletsReceivedBloc; do
|
|
[[ -z $j ]] && continue
|
|
local wIssuers=$(echo "{$j" | jq -r '.issuers[0]')
|
|
local walletsReceivedTodayTmp+=$(echo "{$j" | jq -r '.outputs[]' | grep -v "$wIssuers" | awk -F: '{print $3 "|" $1}' | sed 's/SIG(//g' | tr -d ')')$'\n'
|
|
local sumRBloc=$(echo "{$j" | jq -r '.outputs[]' | grep -v "$wIssuers" | awk -F: '{ print $1 }' | awk '{s+=$1} END {print s}')
|
|
[[ $sumRBloc ]] && local walletsSentTodayTmp+=$wIssuers'|'$sumRBloc'\n'
|
|
done
|
|
IFS="$OIFS"
|
|
local walletsSentToday=$(echo -e "$walletsSentTodayTmp" | head -n -1)
|
|
local walletsReceivedBloc=$(echo -e "$walletsReceivedTodayTmp" | head -n -1)
|
|
unset walletsReceivedTodayTmp walletsSentTodayTmp
|
|
[[ -z $walletsReceivedBloc ]] && continue
|
|
|
|
# Stock les clés publiques de ce bloc dans la variable $wallets
|
|
walletsAuj+=$(echo "$walletsReceivedBloc" | grep -Eo $REGEX_PUBKEYS)$'\n'
|
|
|
|
# Exporte les valeurs de la journée dans le fichier JSON
|
|
jsonify() {
|
|
[[ -z $valueReceivedW ]] && valueReceivedW=0 || valueReceivedW=$(echo "scale=2; $valueReceivedW/100" | bc | awk '{ printf("%.2f\n", $0); }')
|
|
[[ -z $valueReceivedM ]] && valueReceivedM=0 || valueReceivedM=$(echo "scale=2; $valueReceivedM/100" | bc | awk '{ printf("%.2f\n", $0); }')
|
|
[[ -z $valueSentM ]] && valueSentM=0 || valueSentM=$(echo "scale=2; $valueSentM/100" | bc | awk '{ printf("%.2f\n", $0); }')
|
|
[[ -z $valueSentW ]] && valueSentW=0 || valueSentW=$(echo "scale=2; $valueSentW/100" | bc | awk '{ printf("%.2f\n", $0); }')
|
|
[[ -z $nbrMembersToday ]] && nbrMembersToday=0
|
|
[[ -z $nbrWallets ]] && nbrWallets=0
|
|
[[ -z $UDToday ]] && UDToday=0
|
|
|
|
local jsonTPL=$(sed s/_DATE/$blockDateLast/g $GPATH/tpl/daily.json)
|
|
jsonTPL=$(sed s/_UDTODAY/$UDToday/g <<< $jsonTPL)
|
|
jsonTPL=$(sed s/_RWALLETS/$valueReceivedW/g <<< $jsonTPL)
|
|
jsonTPL=$(sed s/_SWALLETS/$valueSentW/g <<< $jsonTPL)
|
|
jsonTPL=$(sed s/_RMEMBERS/$valueReceivedM/g <<< $jsonTPL)
|
|
jsonTPL=$(sed s/_SMEMBERS/$valueSentM/g <<< $jsonTPL)
|
|
jsonTPL=$(sed s/_NBRMEMBERS/$nbrMembersToday/g <<< $jsonTPL)
|
|
jsonTPL=$(sed s/_NBRWALLETS/$nbrWallets/g <<< $jsonTPL)
|
|
echo -e "$jsonTPL" | tr -d '\\' >> $jsonFile
|
|
}
|
|
|
|
# Si la date du bloc courant est différente du bloc précedent, alors on stock les valeurs journalières
|
|
applyToday() {
|
|
[[ -z $wallets ]] && wallets="#"
|
|
local WALLETS=$(echo -e "$wallets" | grep .)
|
|
|
|
# On split la liste des wallets pour ne pas saturer grep
|
|
local id=$(cat /dev/urandom | tr -dc 'a-zA-Z0-9' | fold -w 32 | head -n 1)
|
|
local tmpSplit="/tmp/g1stats-splits-$id"
|
|
mkdir -p $tmpSplit
|
|
pushd $tmpSplit >/dev/null || exit 1
|
|
echo -e "$membresPubkeys\n$WALLETS" | split -d -l 2500
|
|
|
|
local walletsAujTmp=$(echo -e "$walletsAuj" | sort -u | awk 'NF')
|
|
local i
|
|
for i in $(ls x*); do
|
|
local walletToSup=$(cat $i)
|
|
local walletsAujTmp=$(echo "$walletsAujTmp" | grep -vF "$walletToSup")
|
|
done
|
|
[[ -d $tmpSplit ]] && rm -r $tmpSplit || exit 1
|
|
popd >/dev/null
|
|
|
|
nbrWallets=$(echo "$walletsAujTmp" | wc -l)
|
|
unset walletsAujTmp
|
|
|
|
# Obtention du dividende à ce block
|
|
lastUdBloc=$(head -n$nbrDays <<<"$udBlocs" | tail -n1)
|
|
|
|
[[ -z $lastUdBloc ]] && lastUdBloc=$(echo "$udBlocs" | tail -n1)
|
|
local blocUD=$(curl -s ${DUNITER}/blockchain/block/$lastUdBloc | jq '.membersCount,.dividend')
|
|
UDToday=$(echo "$blocUD" | tail -n1 | xargs -i echo "scale=2; {}/100" | bc)
|
|
|
|
# Calcul du nombre de nouveaux membres à ce block
|
|
nbrMembersTotalToday=$(echo "$blocUD" | head -n1)
|
|
[[ -z $nbrMembersYesterday ]] && nbrMembersYesterday=0
|
|
nbrMembersToday=$(($nbrMembersTotalToday-$nbrMembersYesterday))
|
|
|
|
jsonify
|
|
|
|
# Mise en cache périodique
|
|
|
|
## On supprime les doublons et les lignes vides
|
|
wallets=$(echo -e "$wallets" | sort -u | awk 'NF')
|
|
|
|
# if ((i % 50 == 0)); then #kopaa
|
|
echo -e "$bloc\n$wallets\n---\n$walletsAuj\n---\n$nbrMembersYesterday|$blockDateLast|$nbrDays" > $GPATH/cache/bk-walletsUp-$nbrIteration
|
|
cp $GPATH/db/daily.json $GPATH/db/bk-daily.json-$nbrIteration
|
|
|
|
## Retire la dernière virgule et ajoute le crochet de fin de JSON
|
|
sed -i '$ s/,//g' $GPATH/db/bk-daily.json-$nbrIteration
|
|
echo "]" >> $GPATH/db/bk-daily.json-$nbrIteration
|
|
|
|
## On supprime le vieux cache
|
|
rmOldCache
|
|
# fi
|
|
}
|
|
|
|
if [[ -n $blockDateLast && $blockDateLast != $blockDate ]]; then
|
|
applyToday
|
|
[[ $wallets == "#" ]] && unset wallets
|
|
wallets+=$'\n'"$walletsAuj"
|
|
wallets=$(echo -e "$wallets" | sort -u | grep .)$'\n'
|
|
nbrMembersYesterday=$nbrMembersTotalToday
|
|
unset valueReceivedM valueReceivedW valueSentM valueSentW walletsAuj nbrMembersToday nbrWallets
|
|
|
|
# Si il manque un jour sans transaction, on le génère
|
|
dateYesterday=$(awk -F '-' '{ print $3"-"$2"-"$1 }' <<<$blockDate | xargs -i date -d "{}-1day" '+%d-%m-%y')
|
|
if [[ $dateYesterday != $blockDateLast ]];then
|
|
blockDateLast=$dateYesterday
|
|
((nbrDays++))
|
|
|
|
# Obtention du dividende à ce block
|
|
lastUdBloc=$(head -n$nbrDays <<<"$udBlocs" | tail -n1)
|
|
|
|
[[ -z $lastUdBloc ]] && lastUdBloc=$(echo "$udBlocs" | tail -n1)
|
|
local blocUD=$(curl -s ${DUNITER}/blockchain/block/$lastUdBloc | jq '.membersCount,.dividend')
|
|
UDToday=$(echo "$blocUD" | tail -n1 | xargs -i echo "scale=2; {}/100" | bc)
|
|
|
|
# Calcul du nombre de nouveaux membres à ce block
|
|
nbrMembersTotalToday=$(echo "$blocUD" | head -n1)
|
|
[[ -z $nbrMembersYesterday ]] && nbrMembersYesterday=0
|
|
nbrMembersToday=$(($nbrMembersTotalToday-$nbrMembersYesterday))
|
|
|
|
jsonify
|
|
nbrMembersYesterday=$nbrMembersTotalToday
|
|
unset nbrMembersToday
|
|
fi
|
|
((nbrDays++))
|
|
fi
|
|
unset recusJson
|
|
|
|
# Sauvegarde la date de ce bloc pour l'itération suivante
|
|
blockDateLast=$blockDate
|
|
|
|
# Ajoute la valeur des transactions reçus de ce bloc au reste de la journée
|
|
for k in $walletsReceivedBloc; do
|
|
local pubkey=$(echo $k | awk -F '|' '{ print $1 }')
|
|
local value=$(echo $k | awk -F '|' '{ print $2 }')
|
|
|
|
if [[ $(echo "$membresPubkeys" | grep $pubkey) ]]; then
|
|
#valueReceivedM=$(($valueReceivedM+$value))
|
|
[[ -z $valueReceivedM ]] && valueReceivedM=0
|
|
valueReceivedM=$(echo "$valueReceivedM+$value" | bc)
|
|
pubkeyReceiveM+=${pubkey}\\n
|
|
else
|
|
#valueReceivedW=$(($valueReceivedW+$value))
|
|
[[ -z $valueReceivedW ]] && valueReceivedW=0
|
|
valueReceivedW=$(echo "$valueReceivedW+$value" | bc)
|
|
pubkeyReceiveW+=${pubkey}\\n
|
|
fi
|
|
done
|
|
|
|
# Ajoute la valeur des transactions envoyés de ce bloc au reste de la journée
|
|
for k in $walletsSentToday; do
|
|
local pubkey=$(echo $k | awk -F '|' '{ print $1 }')
|
|
local value=$(echo $k | awk -F '|' '{ print $2 }')
|
|
|
|
if [[ $(echo "$membresPubkeys" | grep $pubkey) ]]; then
|
|
#valueSentM=$(($valueSentM+$value))
|
|
[[ -z $valueSentM ]] && valueSentM=0
|
|
valueSentM=$(echo "$valueSentM+$value" | bc)
|
|
pubkeySentM+=${pubkey}\\n
|
|
else
|
|
#valueSentW=$(($valueSentW+$value))
|
|
[[ -z $valueSentW ]] && valueSentW=0
|
|
valueSentW=$(echo "$valueSentW+$value" | bc)
|
|
pubkeySentW+=${pubkey}\\n
|
|
fi
|
|
done
|
|
|
|
# Affiche la progression de la boucle si on est pas en mode web
|
|
local progress=$(echo "scale=1; $bloc*100/$lastBloc/1" | bc)
|
|
local endExec=$(($(date +%s%N)/1000000))
|
|
local timeExec=$(echo "scale=3; ($endExec-$startExec)/1000" | bc)
|
|
#[[ -z $midTimeExec ]] && midTimeExec=$timeExec
|
|
[[ $incExec == 1 ]] && midTimeExecCum=0
|
|
local midTimeExecCum=$(echo "scale=3; $midTimeExecCum+$timeExec" | bc)
|
|
local midTimeExec=$(echo "scale=3; $midTimeExecCum/$incExec" | bc)
|
|
((incExec++))
|
|
if [[ $isWeb != "web" ]]; then
|
|
tput cuu1;tput el;tput cuu1;tput el;tput cuu1;tput el;tput cuu1;tput el;tput cuu1;tput el; # Clear the last view
|
|
echo -e "Heure de début: $startTime\n
|
|
\rScan en cours: $progress% - $bloc/$lastBloc (Boucle $i)
|
|
\rDate: $blockDate (Jour $nbrDays)
|
|
\rTemps d'execution: $midTimeExec"
|
|
else
|
|
[[ -z $firstScan ]] && echo "Scan des blocs avec transactions en cours ..." && local firstScan=true
|
|
fi
|
|
# [[ $i -ge $1 ]] && break #kopa
|
|
done
|
|
|
|
[[ $blockDateLast == $blockDate ]] && applyToday
|
|
|
|
# Retire la dernière virgule et ajoute le crochet de fin de JSON
|
|
sed -i '$ s/,//g' $jsonFile
|
|
echo "]" >> $jsonFile
|
|
|
|
# On supprime les doublons et les lignes vides
|
|
wallets=$(echo -e "$wallets" | sort -u | awk 'NF')
|
|
# On écrit les pubkeys avec transaction dans un fichier de cache pour la prochaine itération
|
|
[[ ! -d $GPATH/cache ]] && mkdir $GPATH/cache
|
|
echo -e "$lastBloc\n$wallets\n---\n$walletsAuj\n---\n$nbrMembersYesterday|$blockDateLast|$nbrDays" > $GPATH/cache/walletsUp-$i
|
|
}
|