g1sms channel coming
This commit is contained in:
parent
35a9a673b3
commit
ab5ef9f755
Binary file not shown.
|
After Width: | Height: | Size: 26 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 77 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 120 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 253 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 13 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 14 KiB |
|
|
@ -0,0 +1,152 @@
|
|||
#!/bin/bash
|
||||
################################################################################
|
||||
# Authors: @jytou (https://git.duniter.org/jytou)
|
||||
# Modified by Fred (support@qo-op.com) to modifiy silkaj constant with best server
|
||||
# Version: 0.1
|
||||
# License: AGPL-3.0 (https://choosealicense.com/licenses/agpl-3.0/)
|
||||
################################################################################
|
||||
# Checks the current block number of nodes.txt (is run in parallel) and output random (from last synchronized) node
|
||||
# pip3 install duniterpy
|
||||
# pip3 install silkaj --user
|
||||
|
||||
checkonenode()
|
||||
{
|
||||
# Timeout in seconds for https nodes
|
||||
httpsTimeout=1
|
||||
# Timeout in seconds for http nodes
|
||||
httpTimeout=1
|
||||
|
||||
node=$1
|
||||
watched=$2
|
||||
outfile=$3
|
||||
# Curl: -m timeout, -k ignore SSL certificate errors
|
||||
cur=`echo "$( { curl -m $httpsTimeout -k https://$node/blockchain/current; } 2>&1 )"`
|
||||
n=$node
|
||||
if [[ "$cur" != *issuersFrameVar* ]]
|
||||
then
|
||||
# It failed in https, maybe try http?
|
||||
cur=`echo "$( { curl -m $httpTimeout http://$node/blockchain/current; } 2>&1 )"`
|
||||
if [[ "$cur" == *issuersFrameVar* ]]
|
||||
then
|
||||
# Indicate that the node is http
|
||||
n="$n-(http)"
|
||||
fi
|
||||
fi
|
||||
if [[ "$cur" != *issuersFrameVar* ]]
|
||||
then
|
||||
# The node didn't respond on time
|
||||
cur="ERROR"
|
||||
else
|
||||
# The node did respond - grab the block number and hash of the block as key
|
||||
cur="`echo "$cur"|grep '^ "number": '|awk '{print $2}'|awk -F, '{print $1}'`-`echo "$cur"|grep '^ "hash": '|awk '{print $2}'|awk '{print substr($1,2,13)}'`"
|
||||
fi
|
||||
if [[ $watched =~ .*#$node#.* ]]
|
||||
then
|
||||
# The node is a watched node, add some bold
|
||||
n="\e[1m$n\e[0m"
|
||||
fi
|
||||
# Put the result into the file
|
||||
echo "$cur $n">$outfile
|
||||
# Notify that we're done here
|
||||
touch $outfile.done
|
||||
}
|
||||
|
||||
# Temp dir where results are stored
|
||||
DIR=/tmp/gnodewatch
|
||||
export DIR
|
||||
mkdir -p $DIR/chains
|
||||
###########
|
||||
# BANNISH DUNITER NODE?
|
||||
# TODO: silkaj evolution!! Better CLI integration to make!
|
||||
# Duniter Node is too slow or behave badly, remove it from nodes.txt list
|
||||
BAN=$1
|
||||
if [[ "$BAN" == "BAN" ]]; then
|
||||
# Get actual Duniter node used by silkaj
|
||||
SERVER=$(cat ./silkaj/src/constants.py | grep G1_DEFAULT_ENDPOINT | awk '{print $3}' | sed s/\"\,//g | sed s/\"//g)
|
||||
[[ ! $(grep $SERVER:443 shell/bad.nodes.txt) ]] && echo $SERVER:443 >> shell/bad.nodes.txt
|
||||
sed -i "/$SERVER:443/d" ./shell/good.nodes.txt
|
||||
echo "$SERVER:443 IS NOW in ./shell/bad.nodes.txt"
|
||||
fi
|
||||
|
||||
### nodes.txt EMPTYNESS CARE
|
||||
NBgood=$(cat ./shell/good.nodes.txt | wc -l)
|
||||
NBbad=$(cat ./shell/bad.nodes.txt | wc -l)
|
||||
if [[ $NBgood -le $NBbad ]]; then
|
||||
echo "" > ./shell/good.nodes.txt
|
||||
echo "" > ./shell/bad.nodes.txt
|
||||
# TODO: Each decentralized App must have a source for its confidence to be UP and running and publishing latest code for our concensus behaviour!
|
||||
echo "___ REFRESH ./shell/nodes.txt from g1.duniter.org:443 ___"
|
||||
curl -s https://g1.duniter.org/network/peers | jq '.peers[] | .endpoints' | grep BMAS | awk '{print $2,$3}' | sed s/\"//g | sed s/\,//g | sed s/\ /:/g > "./shell/nodes.txt"
|
||||
echo $(cat "./shell/nodes.txt")
|
||||
fi
|
||||
###########
|
||||
# CONTINUE
|
||||
|
||||
# Grab the nodes we are actively watching - they will be in bold in the final output
|
||||
watched=`grep -v "#" ./shell/nodes.txt|egrep "\!$"|awk '{print "#" $1 "#"}'`
|
||||
# All nodes we are watching
|
||||
nodes=`grep -v "#" ./shell/nodes.txt|awk '{print $1}'`
|
||||
# The index to generate separate file names
|
||||
index=0
|
||||
# Wipe out the output directory
|
||||
rm $DIR/*out $DIR/*done $DIR/chains/* $DIR/NODE.* 2>/dev/null
|
||||
|
||||
# Query all nodes in parallel
|
||||
for node in $nodes
|
||||
do
|
||||
checkonenode $node "$watched" $DIR/$index.out &
|
||||
((index++))
|
||||
done
|
||||
|
||||
# Wait a little for the first files to be created
|
||||
sleep 1s
|
||||
# Wait for all the threads to report they are done
|
||||
while [ `ls $DIR/*done|wc -l` -lt $index ]
|
||||
do
|
||||
sleep 1s
|
||||
done
|
||||
|
||||
# Grab all results
|
||||
curs=`cat $DIR/*out|sort`
|
||||
# Extract all forks, excluding all errors
|
||||
chains="`echo "$curs"|grep -v ERROR|awk '{print $1}'|sort -r|uniq`"
|
||||
|
||||
# Count the number of chains and output most recent consensus to "good.nodes.txt"
|
||||
nb=0
|
||||
for chain in $chains
|
||||
do
|
||||
echo "$curs" | egrep "^$chain " | awk '{print $2}' >> $DIR/chains/$nb;
|
||||
((nb++))
|
||||
done
|
||||
|
||||
longchain=$(ls -S /tmp/gnodewatch/chains/ | head -n 1)
|
||||
cp /tmp/gnodewatch/chains/$longchain "./shell/good.nodes.txt"
|
||||
|
||||
#####################################################################################
|
||||
# ASK peers to all good.nodes.txt
|
||||
#for node in $(cat ./shell/good.nodes.txt); do
|
||||
# NANODATE=$(date +%s%N);
|
||||
# DUN="https://$(echo $node| cut -d ":" -f 1)";
|
||||
# curl -s -o $DIR/NODE.$NANODATE.$node ${DUN}/network/peers;
|
||||
#done
|
||||
|
||||
# REFRESH from all known peers NEW nodes.txt
|
||||
#cat /tmp/gnodewatch/NODE.* | jq '.peers[] | .endpoints' | grep BMAS | awk '{print $2,$3}' | sed s/\"//g | sed s/\,//g | sed s/\ /:/g | sort | uniq > "./shell/nodes.txt"
|
||||
#####################################################################################
|
||||
|
||||
# Output Random actual best node
|
||||
# Compare with ./shell/bad.nodes.txt
|
||||
while [[ "$BAD" == "$DUNITER" ]]; do
|
||||
DUNITER=$(shuf "./shell/good.nodes.txt" | head -n 1)
|
||||
BAD=$(grep -Rw "$DUNITER" ./shell/bad.nodes.txt)
|
||||
done
|
||||
################# MODIFY silkaj constants.py
|
||||
silkaj=$(echo $DUNITER | cut -d ":" -f 1)
|
||||
if [[ "$silkaj" != "" && "$silkaj" != "https" ]]; then
|
||||
#echo "PUT $silkaj SILKAJ PARAM"
|
||||
cat ./silkaj/src/constants.default.py | sed s/duniter-g1.p2p.legal/$silkaj/g > ./silkaj/src/constants.py
|
||||
else
|
||||
echo "RESTORE DEFAULT SILKAJ PARAM"
|
||||
cp -f ./silkaj/src/constants.default.py ./silkaj/src/constants.py
|
||||
fi
|
||||
echo $DUNITER
|
||||
|
|
@ -0,0 +1,71 @@
|
|||
#!/bin/bash
|
||||
################################################################################
|
||||
# Author: Fred (support@qo-op.com)
|
||||
# Version: 0.1
|
||||
# License: AGPL-3.0 (https://choosealicense.com/licenses/agpl-3.0/)
|
||||
# BACKUP G1sms+ current Devlt code and push it with SWARM_CODE_MASTER to IPFS
|
||||
################################################################################
|
||||
source ./shell/init.sh
|
||||
source ./shell/functions.sh
|
||||
now=$(date +%Y-%m-%d)
|
||||
|
||||
MY_PATH="`dirname \"$0\"`" # relative
|
||||
MY_PATH="`( cd \"$MY_PATH\" && pwd )`" # absolutized and normalized
|
||||
|
||||
echo "COMMENTAIRES?"
|
||||
read COMMENT
|
||||
|
||||
# CREATE CURRENT NODE "SWARM_CODE_MASTER" ipns key
|
||||
if [[ ! -f "/home/$YOU/.ipfs/keystore/SWARM_CODE_MASTER" ]]; then
|
||||
echo "Vous ne possédez pas la clef SWARM_CODE_MASTER de ce CODE..."
|
||||
# echo "FORK ? su $YOU -c \"ipfs key gen -t rsa -s 2048 SWARM_CODE_MASTER\""
|
||||
echo "Si vous souhaiter participer au CODE, contactez https://g1sms.fr "
|
||||
echo "Utilisez le script ./G1sms+/install.sh pour installer ou mettre à jour votre noeud"
|
||||
exit
|
||||
else
|
||||
# Only "SWARM_CODE_MASTER" key owner(s) can update & publish this _official _chain
|
||||
#rm "./$dir/_publishkey.pgp" # TEMP for file name correction...
|
||||
cat "/home/$YOU/.ipfs/keystore/SWARM_CODE_MASTER" | base64 | gpg -q --output "./$dir/_publishkey.gpg" --yes --pinentry-mode loopback --symmetric --passphrase-fd 0 "/home/$YOU/.ipfs/keystore/SWARM_CODE_MASTER"
|
||||
fi
|
||||
|
||||
## Backup $ROOT
|
||||
dir=$(pwd | awk 'BEGIN { FS = "/" } ; {print $4}')
|
||||
cd ..
|
||||
|
||||
###############################################
|
||||
# Create BASIC IPNS _official IPFS HASH _chain
|
||||
# with iterative update _chain, _nanodate, _zen, _g1cents values
|
||||
# + _external UID references & _comments lines
|
||||
###########################################################################################
|
||||
echo "PLEASE WAIT...."
|
||||
echo "GIT" > "./$dir/_type"
|
||||
hop=$(cat "./$dir/_chain")
|
||||
LASTDU=$(curl -s ${DUNITER}/blockchain/with/ud | jq '.result.blocks[]' | tail -n 1);
|
||||
[[ $LASTDU != "" ]] && curl -s ${DUNITER}/blockchain/block/${LASTDU} | jq '.dividend' > "./$dir/_DU" || LASTDU=$(cat ./$dir/_DU)
|
||||
echo "Valeur courante du DU=$(cat ./$dir/_DU) ZEN - CHAIN: $hop"
|
||||
read
|
||||
|
||||
if [[ ! -f "./$dir/_id" ]]; then echo "SWARM_CODE_MASTER" > "./$dir/_id"; fi
|
||||
if [[ ! -f "./$dir/_zen" ]]; then echo 0 > "./$dir/_zen"; fi
|
||||
if [[ ! -f "./$dir/_g1cents" ]]; then echo 0 > "./$dir/_g1cents"; fi
|
||||
if [[ ! -f "./$dir/_external" ]]; then echo "" > "./$dir/_external"; fi # Used to link to External UniqID
|
||||
echo $(date +%s%N) > "./$dir/_nanodate"
|
||||
|
||||
echo "$now: $COMMENT" >> "./$dir/_comments"
|
||||
|
||||
# TAR G1sms+ FILES (WITH EXCLUSIONS!!)
|
||||
tar -cvzf ~/G1sms+_backup_$now.tar.gz --exclude 'g1sms.preoni.*' --exclude 'authfile' --exclude 'init.sh' --exclude '.git' --exclude 'billets' --exclude 'constants.py' --exclude 'TAG' --exclude 'history*' --exclude 'trash' --exclude 'print' --exclude 'wallets' --exclude 'wallets_swarm' --exclude 'g1sms.priv.key' ./$dir
|
||||
|
||||
mkdir -p /tmp/CODE/ && tar xzf ~/G1sms+_backup_$now.tar.gz -C /tmp/CODE/ && rm -f ~/G1sms+_backup_$now.tar.gz
|
||||
|
||||
# PUBLISH IT
|
||||
hash=$(su $YOU -c "ipfs add -rq /tmp/CODE/ -w | tail -n 1")
|
||||
|
||||
echo $hash > "./$dir/_chain"
|
||||
publish=$(su $YOU -c "ipfs name publish -k SWARM_CODE_MASTER --quieter /ipfs/${hash}")
|
||||
echo $publish > "./$dir/_official"
|
||||
|
||||
rm -Rf /tmp/CODE
|
||||
|
||||
echo "_CHAIN: NEW /ipfs/$hash // $hop PUBLISHED with \"SWARM_CODE_MASTER\" key
|
||||
ipfs get --output=./ /ipns/$publish"
|
||||
|
|
@ -0,0 +1,40 @@
|
|||
#!/bin/bash
|
||||
################################################################################
|
||||
# Author: Fred (support@qo-op.com)
|
||||
# Version: 0.1
|
||||
# License: AGPL-3.0 (https://choosealicense.com/licenses/agpl-3.0/)
|
||||
# BACKUP G1sms+ current Devlt code and push it with NODE_G1AUTHFILE encryption to IPFS
|
||||
################################################################################
|
||||
## GET LATEST DEV $ROOT
|
||||
source ./shell/init.sh
|
||||
source ./shell/functions.sh
|
||||
now=$(date +%Y-%m-%d)
|
||||
dir=$(pwd | awk 'BEGIN { FS = "/" } ; {print $4}')
|
||||
cd ..
|
||||
|
||||
publish=$(cat "./$dir/_official")
|
||||
maillon=$(cat "./$dir/_chain")
|
||||
if [[ "$publish" == "" ]]; then lev="ipfs"; hash="$maillon"; else lev="ipns"; hash="$publish"; fi
|
||||
|
||||
su $YOU -c "ipfs get --output=./ /$lev/$hash"
|
||||
|
||||
if [[ -f "./CODE/G1sms+.latest.tgz" ]]; then
|
||||
echo "TODAY CODE FOUND... UNTAR in ls ./TODAY"
|
||||
mkdir -p ./TODAY
|
||||
cd TODAY
|
||||
tar xvzf ../CODE/G1sms+.latest.tgz
|
||||
# KEEP LOCAL NODE init.sh
|
||||
if [[ ! -f "./$dir/shell/init.sh" ]]; then echo "backup restore problem..."; exit; fi
|
||||
echo "REMOVE DEFAULT INIT..."
|
||||
rm -f ./$dir/shell/init.sh
|
||||
|
||||
echo "DIFFERENCES ENTRE LES 2 VERSIONS:"
|
||||
diff ./$dir/ ../$dir/
|
||||
|
||||
echo "VOULEZ VOUS METTRE A JOUR? Saisissez OUI"
|
||||
read QUOI
|
||||
if [[ "$QUOI" == "OUI" ]]; then sudo cp -Rf . ..; else echo "ANNULATION UPDATE"; exit; fi
|
||||
|
||||
fi
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,83 @@
|
|||
#!/bin/bash
|
||||
################################################################################
|
||||
# Author: Fred (support@qo-op.com)
|
||||
# Version: 0.1
|
||||
# License: AGPL-3.0 (https://choosealicense.com/licenses/agpl-3.0/)
|
||||
###########################################################################################
|
||||
# cron_G1TAG_REFRESH.sh
|
||||
# Scan all TAG created by current $IPFSNODEID
|
||||
# Update local and Publish it
|
||||
# Remove too old or empty ones
|
||||
##################################################################
|
||||
YOU=$(ps aux --sort=+utime | grep ipfs | tail -n 1 | cut -d " " -f 1)
|
||||
IPFSNODEID=$(su $YOU -c "ipfs id -f='<id>\n'")
|
||||
NANODATE=$(date -u +%s%N) #1569692075385428020
|
||||
|
||||
# PROTECT from null HASH
|
||||
for tag in ./wallets/.$IPFSNODEID/TAG/*; do
|
||||
function rmtag () {
|
||||
echo "__SUB:cron_G1TAG_REFRESH.sh: rm -Rf ./wallets/.$IPFSNODEID/TAG/${tagj}"
|
||||
rm -Rf ./TAG/${tagj}
|
||||
rm -f ./wallets/.$IPFSNODEID/TAG/${tagj}
|
||||
rm -f ./wallets_swarm/.$IPFSNODEID/TAG/${tagj}
|
||||
rm -f /home/$YOU/.ipfs/keystore/${tagj}
|
||||
}
|
||||
|
||||
# Refresh G1Tag created by this NODE
|
||||
tagj=$(echo $tag | cut -d '/' -f 5)
|
||||
if [[ "${tagj}" == "" ]]; then echo "__SUB:cron_G1TAG_REFRESH.sh: EMPTY"; continue; fi
|
||||
echo "__SUB:cron_G1TAG_REFRESH.sh: WORKING ON ${tagj}"
|
||||
RR=$($YOU -c "ipfs cat /ipns/${tagj}/TAG_id | sed s/\ //g");
|
||||
if [[ "$RR" == "" ]]; then
|
||||
echo "__SUB:cron_G1TAG_REFRESH.sh: G1Tag Destroyed !!!??";
|
||||
|
||||
rmtag
|
||||
continue;
|
||||
fi
|
||||
|
||||
# RE-SYNC LOCAL & SWARM G1TAG - TODO Check for G1Tag chain corruption
|
||||
mv ./TAG/${RR} ./TAG/${RR}.old
|
||||
mkdir -p ./TAG/${RR}
|
||||
chown -R $YOU ./TAG/${RR}
|
||||
su $YOU -c "ipfs get --output=./TAG/${RR} /ipns/${tagj}"
|
||||
oldtagval=$(cat ./TAG/${RR}.old/TAG_amount)
|
||||
curtagval=$(cat ./TAG/${RR}/TAG_amount)
|
||||
oldtagn=$(cat ./TAG/${RR}.old/TAG_n)
|
||||
curtagn=$(cat ./TAG/${RR}/TAG_n)
|
||||
oldtagchain=$(cat ./TAG/${RR}.old/TAG_chain)
|
||||
curtagchain=$(cat ./TAG/${RR}/TAG_chain)
|
||||
echo "__SUB:cron_G1TAG_REFRESH.sh: ./TAG/$RR VALUE: ($oldtagn) $oldtagval ZEN -> ($curtagn) $curtagval ZEN"
|
||||
echo "__SUB:cron_G1TAG_REFRESH.sh: $oldtagchain -> $curtagchain"
|
||||
|
||||
rm -Rf ./TAG/${RR}.old
|
||||
if [[ $curtagval -eq 0 || "$curtagval" == "" ]]; then rmtag; continue; fi
|
||||
|
||||
# SHOULD PUBLISH ONLY MORE THAN 6h NO USE G1TAG
|
||||
last=$(cat ./TAG/${RR}/TAG_nanodate)
|
||||
timediff=$( echo "${NANODATE} - ${last}" | bc -l )
|
||||
# G1TAG TIME SYNC 21600 milliards de nanosecondes = 6h
|
||||
if [[ $timediff -gt 21600000000000 ]]; then
|
||||
|
||||
# GET PUBLISHKEY for that G1TAG
|
||||
if [[ ! -f /home/$YOU/.ipfs/keystore/${RR} ]]; then
|
||||
echo "__SUB:cron_G1TAG_REFRESH.sh: GET PUBLISHKEY for that G1TAG";
|
||||
su $YOU -c "ipfs get -o /home/$YOU/.ipfs/keystore/${RR}.crypt /ipns/$tagj/TAG_publishkey.MASTER.crypt"
|
||||
if [[ ! -f /home/$YOU/.ipfs/keystore/${RR}.crypt ]]; then log "__SUB:cron_MINUTE.sh: error getting publishkey"; continue; fi
|
||||
./shell/natools.py decrypt -k "$NODE_G1AUTHFILE" -i /home/$YOU/.ipfs/keystore/${RR}.crypt -o /home/$YOU/.ipfs/keystore/$RR
|
||||
rm /home/$YOU/.ipfs/keystore/${RR}.crypt
|
||||
fi
|
||||
echo "__SUB:cron_G1TAG_REFRESH.sh: G1Tag PUBLISHKEY OK : /home/$YOU/.ipfs/keystore/${RR}"
|
||||
echo ${NANODATE} > ./TAG/${RR}/TAG_nanodate
|
||||
# PUBLISH VERIFIED G1Tag VERSION
|
||||
I=$(su $YOU -c "ipfs add -qr ./TAG/${RR} | tail -n 1")
|
||||
# RECORD TAG_chain And HASH again
|
||||
echo "$I" > "./TAG/${JDESTRR}/TAG_chain"
|
||||
I=$(su $YOU -c "ipfs add -qr ./TAG/${RR} | tail -n 1")
|
||||
# IPNS $JDESTRR PUBLISH
|
||||
J=$(su $YOU -c "ipfs name publish -k ${RR} --quieter /ipfs/${I}")
|
||||
echo "__SUB:cron_G1TAG_REFRESH.sh: G1Tag IPNS PUBLISH"
|
||||
fi
|
||||
|
||||
|
||||
done
|
||||
##################################################################
|
||||
|
|
@ -0,0 +1,49 @@
|
|||
#!/bin/bash
|
||||
################################################################################
|
||||
# Author: Fred (support@qo-op.com)
|
||||
# Version: 0.1
|
||||
# License: AGPL-3.0 (https://choosealicense.com/licenses/agpl-3.0/)
|
||||
################################################################################
|
||||
# TODO: SMS Alerte quand une annonce GCHANGE est proche du GeoPoint du téléphone/membre
|
||||
#
|
||||
# EXTRAIT LES DERNIERES ANNNONCES
|
||||
# TODO Requête ES sur la distance directement !!!! @kimamila or http://www.elasticsearchtutorial.com/spatial-search-tutorial.html help?
|
||||
|
||||
CESIUM="https://g1.data.le-sou.org"
|
||||
echo "Entrez PubKey"; read DESTRIB;
|
||||
curl -sk ${CESIUM}/user/profile/${DESTRIB} -o /tmp/profile.json
|
||||
LON=$(cat /tmp/profile.json | jq '._source.geoPoint.lon')
|
||||
LAT=$(cat /tmp/profile.json | jq '._source.geoPoint.lat')
|
||||
|
||||
if [[ "$LON" != "null" ]]; then
|
||||
curl -sk -XPOST 'https://data.gchange.fr/market/record/_search?pretty&_source=title' -d '
|
||||
{
|
||||
"size": 100,
|
||||
"query": {
|
||||
"bool": {
|
||||
"filter": [{
|
||||
"geo_distance": {
|
||||
"distance": "100km",
|
||||
"geoPoint": {
|
||||
"lat": '$LAT',
|
||||
"lon": '$LON'
|
||||
}
|
||||
}
|
||||
}]
|
||||
}
|
||||
}
|
||||
}' | jq
|
||||
else
|
||||
echo "Aucune coordonnées geoPoint pour $DESTRIB"
|
||||
fi
|
||||
|
||||
TOTAL=$(curl -s https://data.gchange.fr/market/record/_search | jq .hits.total)
|
||||
echo "TOTAL ANNONCES GCHANGE: $TOTAL"
|
||||
chunk=0
|
||||
while [[ $chunk -lt $TOTAL ]]; do
|
||||
for res in $(curl -s https://data.gchange.fr/market/record/_search?from=$chunk | jq .hits.hits[]._id | sed s/\"//g ) do;
|
||||
echo $res;
|
||||
# curl -s --create-dirs -o ./gchange/$ID.json -s https://data.gchange.fr/market/record/$ID?_source=category,title,description,issuer,time,creationTime,location,address,city,price,unit,currency,thumbnail._content_type,picturesCount,type,stock,fees,feesCurrency,geoPoint
|
||||
done
|
||||
chunk=$((chunk+10))
|
||||
done
|
||||
|
|
@ -0,0 +1,23 @@
|
|||
#!/bin/bash
|
||||
################################################################################
|
||||
# Author: Fred (support@qo-op.com)
|
||||
# Version: 0.1
|
||||
# License: AGPL-3.0 (https://choosealicense.com/licenses/agpl-3.0/)
|
||||
################################################################################
|
||||
# Activate SUPPORT MODE: open ssh over IPFS
|
||||
MY_PATH="`dirname \"$0\"`" # relative
|
||||
MY_PATH="`( cd \"$MY_PATH\" && pwd )`" # absolutized and normalized
|
||||
if [[ -f $MY_PATH/.install/.GPATH ]]; then source $MY_PATH/.install/.GPATH; fi
|
||||
if [[ -f $MY_PATH/../.install/.GPATH ]]; then source $MY_PATH/../.install/.GPATH; fi
|
||||
|
||||
YOU=$(ps aux --sort=+utime | grep ipfs | tail -n 1 | cut -d " " -f 1)
|
||||
if [[ "$USER" != "root" ]]; then echo "Hey, $USER you must at least be admin of your system (sudo $0)"; exit; fi
|
||||
if [[ "$YOU" == "" || "$YOU" == "root" ]]; then echo "BAD IPFS. Aucune installation IPFS satisfaisante ici... Ciao $YOU !"; exit; fi
|
||||
IPFSNODEID=$(su $YOU -c "ipfs id -f='<id>\n'")
|
||||
cd $GPATH
|
||||
|
||||
su $YOU -c "ipfs p2p close --all"
|
||||
su $YOU -c "ipfs p2p listen /x/ssh /ip4/127.0.0.1/tcp/22"
|
||||
su $YOU -c "ipfs p2p listen /x/http /ip4/127.0.0.1/tcp/80"
|
||||
su $YOU -c "ipfs p2p listen /x/https /ip4/127.0.0.1/tcp/443"
|
||||
su $YOU -c "ipfs p2p ls"
|
||||
|
|
@ -0,0 +1,108 @@
|
|||
#!/bin/bash
|
||||
################################################################################
|
||||
# Author: Fred (support@qo-op.com)
|
||||
# Version: 0.1
|
||||
# License: AGPL-3.0 (https://choosealicense.com/licenses/agpl-3.0/)
|
||||
################################################################################
|
||||
# CE FICHIER cron_MINUTE.sh EST EXECUTE TOUTES LES MINUTES
|
||||
# IL CONSTITUE LE BATEMENT DE COEUR DU SYSTEME
|
||||
################################################################################
|
||||
|
||||
MY_PATH="`dirname \"$0\"`" # relative
|
||||
MY_PATH="`( cd \"$MY_PATH\" && pwd )`" # absolutized and normalized
|
||||
if [[ -f $MY_PATH/.install/.GPATH ]]; then source $MY_PATH/.install/.GPATH; fi
|
||||
if [[ -f $MY_PATH/../.install/.GPATH ]]; then source $MY_PATH/../.install/.GPATH; fi
|
||||
|
||||
YOU=$(ps aux --sort=+utime | grep ipfs | tail -n 1 | cut -d " " -f 1)
|
||||
if [[ "$USER" != "root" ]]; then echo "Hey, $USER you must at least be admin of your system (sudo $0)"; exit; fi
|
||||
if [[ "$YOU" == "" || "$YOU" == "root" ]]; then echo "BAD IPFS. Aucune installation IPFS satisfaisante ici... Ciao $YOU !"; exit; fi
|
||||
IPFSNODEID=$(su $YOU -c "ipfs id -f='<id>\n'")
|
||||
cd $GPATH
|
||||
source ./shell/init.sh
|
||||
source ./shell/functions.sh
|
||||
|
||||
timebar=$(date +%H:%M)
|
||||
|
||||
##################################################################
|
||||
if [[ "$1" == "" ]]; then
|
||||
##################################################################
|
||||
echo "It is $timebar in the morning, or in the night? It depends on your day..."
|
||||
exit
|
||||
fi
|
||||
##################################################################
|
||||
|
||||
##################################################################
|
||||
if [[ "$1" == "PRINT" ]]; then
|
||||
##################################################################
|
||||
##################################################################
|
||||
# Refresh All peers SWARM Wallets.
|
||||
##################################################################
|
||||
ipfs_swarm_wallets_refresh "SIMPLE"
|
||||
|
||||
################################################################################
|
||||
# PRINT G1Tag PRINTED FROM ANOTHER NODE (TODO: Correct BAD Cypher KEY + BUG why last image png layers are not printed???)
|
||||
# CREATE and REMOVE rr.bin -> done.rr
|
||||
if [[ -d "./wallets_swarm/.$IPFSNODEID/PRINT/" ]]; then
|
||||
log "__SUB:cron_MINUTE.sh: SEARCH NEW PRINT FOR ME .$IPFSNODEID"
|
||||
mkdir -p ./wallets/.$IPFSNODEID/PRINT/
|
||||
|
||||
for qrrtag in ./wallets_swarm/.$IPFSNODEID/PRINT/*.bin; do
|
||||
rr=$(echo $qrrtag | cut -d '/' -f 5 | cut -d '.' -f 1)
|
||||
if [[ ! -f "./wallets/.$IPFSNODEID/PRINT/done.$rr" ]]; then
|
||||
log "__SUB:cron_MINUTE.sh: PRINT G1Tag $rr - START: $(date)"
|
||||
./shell/natools.py decrypt -k "$NODE_G1AUTHFILE" -i "${qrrtag}" -o "/tmp/G1Tag.png"
|
||||
log "__SUB:cron_MINUTE.sh: natools.py decrypt - $(date)"
|
||||
brother_ql_create --model QL-700 "/tmp/G1Tag.png" --label-size 62 > "/tmp/G1Tag.bin"
|
||||
log "__SUB:cron_MINUTE.sh: brother_ql_create - $(date)"
|
||||
brother_ql_print "/tmp/G1Tag.bin" /dev/usb/lp0
|
||||
log "__SUB:cron_MINUTE.sh: brother_ql_print - $(date)"
|
||||
# INFORM PRINT DONE
|
||||
echo "OK" > ./wallets/.$IPFSNODEID/PRINT/done.$rr
|
||||
I=$(ipfs_node_wallets_add)
|
||||
else
|
||||
lqrrtag=$(echo "${qrrtag}" | sed s/_swarm//g )
|
||||
log "__SUB:cron_MINUTE.sh: REMOVE OLD DONE PRINT ${lqrrtag} + ./wallets/.$IPFSNODEID/PRINT/done.$rr"
|
||||
rm -f "./wallets/.$IPFSNODEID/PRINT/done.$rr"
|
||||
rm -f "${lqrrtag}"
|
||||
I=$(ipfs_node_wallets_add)
|
||||
fi
|
||||
done
|
||||
|
||||
log "__SUB:cron_MINUTE.sh: REMOVE OLD PRINT MARKED AS DONE"
|
||||
for scan in ./wallets_swarm/.Qm*/PRINT/done.*; do
|
||||
lscan=$(echo $scan | sed s/_swarm//g )
|
||||
lid=$(echo $scan | cut -d '/' -f 3 | cut -d '.' -f 2 )
|
||||
lrr=$(echo $scan | cut -d '/' -f 5 | cut -d '.' -f 2 )
|
||||
log "__SUB:cron_MINUTE.sh: REMOVE ./wallets/.$lid/PRINT/$lrr.bin OLD PRINT ${lscan} SENT to $lid ($lrr.bin)"
|
||||
rm -f ./wallets/.$lid/PRINT/$lrr.bin
|
||||
rm -f "${lscan}"
|
||||
I=$(ipfs_node_wallets_add)
|
||||
done
|
||||
|
||||
rm "/tmp/G1Tag.bin"
|
||||
rm "/tmp/G1Tag.png"
|
||||
fi
|
||||
fi
|
||||
##################################################################
|
||||
|
||||
##################################################################
|
||||
if [[ "$1" == "KALKUN" ]]; then
|
||||
##################################################################
|
||||
for number in ./wallets/*; do
|
||||
member=""
|
||||
phone=$(echo $number | cut -d '/' -f 3);
|
||||
if [[ -f $number/$phone.uidname ]]; then member=$(cat $number/$phone.uidname); fi
|
||||
if [[ ! $member ]]; then member=$phone; fi
|
||||
if [[ $phone && $member ]]; then add_contact $phone $member; log "__SUB:cron_MINUTE.sh: KALKUN add_contact $phone $member"; fi
|
||||
done
|
||||
fi
|
||||
##################################################################
|
||||
|
||||
##################################################################
|
||||
if [[ "$1" == "TAG" ]]; then
|
||||
##################################################################
|
||||
for tag in ./TAG/*; do
|
||||
echo $tag
|
||||
done
|
||||
fi
|
||||
##################################################################
|
||||
|
|
@ -0,0 +1,94 @@
|
|||
#!/bin/bash
|
||||
################################################################################
|
||||
# Author: Fred (support@qo-op.com)
|
||||
# Version: 0.1
|
||||
# License: AGPL-3.0 (https://choosealicense.com/licenses/agpl-3.0/)
|
||||
################################################################################
|
||||
# Effectue les payements récurrents et enlève le vérrou (DESTROY)
|
||||
# TAKES CARE OF DOING RECURRENT PAYEMENTS EVERY DAY FOR ITS $PHONE G1Wallets
|
||||
# TODO: Add SMS Alert if G1sms Wallet is low...
|
||||
source ./shell/init.sh
|
||||
source ./shell/functions.sh
|
||||
log "__SUB:cron_VIR.reccurent.sh: START"
|
||||
|
||||
rm -f /tmp/VIR*
|
||||
echo "" > /tmp/VIR
|
||||
|
||||
TODAY=$(date '+%Y%m%d')
|
||||
log "__SUB:cron_VIR.reccurent.sh: Searching payements to do for $TODAY"
|
||||
for file in ./wallets/*/VIREMENTS.gpg ; do
|
||||
if [[ -f $file ]]; then
|
||||
log "__SUB:cron_VIR.reccurent.sh: FOUND $file decrypting with Node key"
|
||||
echo "${GPGPASS}" | gpg -d -q --output "/tmp/VIREMENTS" --yes --pinentry-mode loopback --passphrase-fd 0 "$file"
|
||||
cat /tmp/VIREMENTS | sort >> /tmp/VIR$TODAY
|
||||
else
|
||||
continue
|
||||
fi
|
||||
done
|
||||
|
||||
############################################
|
||||
if [[ -f /tmp/VIR$TODAY ]]; then
|
||||
############################################
|
||||
while read line
|
||||
do virement=(${line});
|
||||
if [[ ${virement[0]} == ${TODAY} ]]; then
|
||||
log "__SUB:cron_VIR.reccurent.sh: PAYING !!! ${line}"
|
||||
PHONE=${virement[2]}
|
||||
VIR=${virement[3]}
|
||||
DESTRIB=${virement[4]}
|
||||
DESTUID=${virement[5]}
|
||||
REF=${virement[6]}
|
||||
NB=${virement[7]}
|
||||
|
||||
sms_INIT_ACCOUNT "$PHONE" "NOSMS"
|
||||
# echo -salt="$PHONE" -password="$PIN" --amount="$VIR" --output="$DESTRIB" --comment="[G1sms+] VIR $REF / $NB"
|
||||
PAY=$(./silkaj/silkaj transaction --auth-scrypt -salt="$PHONE" -password="$PIN" --amount="$VIR" --output="$DESTRIB" --comment="[G1sms+] VIR $REF / $NB" -y)
|
||||
if [[ "$(echo $PAY | cut -d '|' -f 1)" == "KO" ]]; then
|
||||
new=$(./shell/checknodes.sh "BAN")
|
||||
sms_ERROR "$PHONE" "Il est survenu un problème avec votre virement. Retour silkaj: $PAY ... $new";
|
||||
else
|
||||
new=$(./shell/checknodes.sh)
|
||||
sms_SEND "$PHONE" "$TODAY Virement automatique $REF vers $DESTUID : $PAY (Reste $NB)"
|
||||
cents=$(echo $(bc -l <<< "scale=0; $VIR * 100") | cut -d '.' -f 1)
|
||||
move_g1cents "$PHONE" "$DESTRIB" "$cents"
|
||||
fi
|
||||
log "__SUB:cron_VIR.reccurent.sh: $TODAY VIR DONE.... Rotation Silkaj : $new "
|
||||
else
|
||||
virement=""
|
||||
echo "$(declare -p virement)"
|
||||
fi
|
||||
done < /tmp/VIR$TODAY
|
||||
|
||||
# CHECK FOR LAST VIREMENTS AND CLEAN IT?
|
||||
for virfile in "./wallets/*/VIREMENTS.gpg"; do
|
||||
phone=$(echo $virfile | cut -d '/' -f 3)
|
||||
if [[ "$phone" == "*" ]]; then exit; fi
|
||||
echo "${GPGPASS}" | gpg -d -q --output "/tmp/$phone.VIREMENTS" --yes --pinentry-mode loopback --passphrase-fd 0 "./wallets/$phone/VIREMENTS.gpg"
|
||||
nv=0; tot=0;
|
||||
while read ligne
|
||||
do virs=(${ligne});
|
||||
if [[ ${virs[0]} -gt ${TODAY} ]]; then
|
||||
# Some other payments are to be done in the future
|
||||
((nv++))
|
||||
tot=$((tot + {virs[3]}))
|
||||
fi
|
||||
done < /tmp/$phone.VIREMENTS
|
||||
|
||||
# NO FUTURE PAYMENTS. REMOVE VIREMENTS files
|
||||
if [[ $nv -eq 0 ]]; then
|
||||
log "__SUB:cron_VIR.reccurent.sh: Plus AUCUN payement récurrent !!"
|
||||
sms_SEND "$phone" "Plus AUCUN payement récurrent"
|
||||
rm -f "./wallets/$phone/VIREMENTS.gpg"
|
||||
rm -f "./wallets/$phone/VIREMENTS"
|
||||
I=$(ipfs_node_wallets_add)
|
||||
else
|
||||
log "__SUB:cron_VIR.reccurent.sh: Encore $nv payements récurrents à réaliser pour $tot G1"
|
||||
# TODO Verify Wallet Amount is not too low... To send alert (sms, email)
|
||||
# cts=$(echo $(bc -l <<< "scale=0; $tot * 100") | cut -d '.' -f 1)
|
||||
sms_SEND "$phone" "Encore $nv payements récurrents à réaliser pour $tot G1. Approvisionnez votre solde en conséqence..."
|
||||
fi
|
||||
rm -f "/tmp/$phone.VIREMENTS"
|
||||
done
|
||||
############################################
|
||||
fi
|
||||
############################################
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -0,0 +1,17 @@
|
|||
#!/usr/bin/env bash
|
||||
MOTS=$(echo "$1" | grep -E "^\-?[0-9]+$")
|
||||
# Default to 6 words passphrase
|
||||
if [[ "$MOTS" == "" ]]; then MOTS=6; fi
|
||||
WORDCOUNT=${1-$MOTS}
|
||||
# Download the wordlist
|
||||
# wget -nc -O ~/.diceware-wordlist http://world.std.com/%7Ereinhold/diceware.wordlist.asc 2> /dev/null
|
||||
# print a list of the diceware words
|
||||
cat ./shell/diceware-wordlist.txt |
|
||||
awk '/[1-6][1-6][1-6][1-6][1-6]/{ print $2 }' |
|
||||
# randomize the list order
|
||||
shuf --random-source=/dev/urandom |
|
||||
# pick the first n words
|
||||
head -n ${WORDCOUNT} |
|
||||
# pretty print
|
||||
tr '\n' ' '
|
||||
echo
|
||||
|
|
@ -0,0 +1,672 @@
|
|||
#!/bin/bash
|
||||
# License: AGPL-3.0 (https://choosealicense.com/licenses/agpl-3.0/)
|
||||
# G1SMS COMMUN FUNCTIONS
|
||||
|
||||
# TODO: REWRITE AND MAKE FULL IPFS get wallet value through IPNS links
|
||||
# ipfs cat /ipns/QmUrUdfz5hWJ6354D3N6DT64tbs5CLEndSYYiqrj9Wa4Ax/+33647683646/+33647683646.uidna
|
||||
###################################################################################################################################
|
||||
|
||||
###################################################################################################################################
|
||||
|
||||
MY_PATH="`dirname \"$0\"`" # relative
|
||||
MY_PATH="`( cd \"$MY_PATH\" && pwd )`" # absolutized and normalized
|
||||
|
||||
## Récupère les données du profile
|
||||
[[ -f $MY_PATH/.profile ]] && source $MY_PATH/.profile
|
||||
|
||||
function sms_SEND () {
|
||||
# sms_SEND ($1=phone, $2=message)
|
||||
local dest="$1"
|
||||
local mess="$2"
|
||||
if [[ ${#dest} -eq 10 || ${#dest} -eq 12 ]]; then
|
||||
if [[ -d ./wallets/$dest ]]; then
|
||||
# TEST IF $dest IS ON CURRENT NODE
|
||||
gammu-smsd-inject TEXT "$dest" -text "$mess" 1>&2
|
||||
else
|
||||
# Send SMS through $dest NODE (TODO: send it like PRINT, TASK, ...)
|
||||
DESTNODEID=$(cat ./wallets_swarm/$dest/MASTERPHONE.ipfsid)
|
||||
log "$dest is managed by NODE: $DESTNODEID)"
|
||||
mkdir "./wallets/.$DESTNODEID/SMS"
|
||||
echo $mess > "./wallets/.$DESTNODEID/SMS/$dest.sms2send"
|
||||
I=$(ipfs_node_wallets_add)
|
||||
fi
|
||||
else
|
||||
log ">>>>>>>>>>SMS ERROR BAD DESTINATION $dest"
|
||||
fi
|
||||
log ">>>>>>>>>> SENDING SMS $mess TO $dest ($DESTNODEID)"
|
||||
}
|
||||
|
||||
|
||||
#################################################################################################################################
|
||||
function sms_ERROR () {
|
||||
# sms_ERROR ($1=phone, $2=message)
|
||||
local dest="$1"
|
||||
local mess="[ERREUR]
|
||||
$2"
|
||||
if [[ ${#dest} -eq 10 || ${#dest} -eq 12 ]]; then
|
||||
gammu-smsd-inject TEXT "$dest" -text "$mess" 1>&2
|
||||
else
|
||||
log ">>>>>>>>>>SMS ERROR BAD DESTINATION $dest"
|
||||
fi
|
||||
log ">>>>>>>>>> SENDING SMS $mess TO $dest"
|
||||
# SEND ERROR COPY TO ADMINPHONE
|
||||
if [[ "$CPERROR" == "YES" ]]; then sms_SEND "$ADMINPHONE" "ADMIN! ERROR ($dest): $mess"; fi
|
||||
}
|
||||
|
||||
|
||||
#################################################################################################################################
|
||||
function log_history () {
|
||||
log "__SUB:log_history: history ($1, $2)"
|
||||
PHONE="$1"
|
||||
HISTFILE="./history.$IPFSNODEID.log.csv"
|
||||
|
||||
echo "$(date +%Y%m%d), $(date +%H:%M:%S), $1, $2" >> "$HISTFILE"
|
||||
}
|
||||
|
||||
|
||||
#################################################################################################################################
|
||||
function security () {
|
||||
|
||||
if [[ "$G1SMS" == "YES" ]]; then # ONLY OF gammu is really sending SMS on that NODE
|
||||
# No Reply to MySelf (or enjoy SMS LOOP of the death) Nobody neither
|
||||
if [[ "$PHONE" == "$MASTERPHONE" || "$PHONE" == "" ]]; then log "__SUB:security: SMS REJECTED !! $PHONE $TEXT"; exit; fi
|
||||
|
||||
# ADAPT TO YOUR PHONE COMPANY / ADVERT ANNOYANCE
|
||||
if [[ "$PHONE" == "Orange Info" ]]; then log "__SUB:security: SMS REJECTED !! $PHONE ADVERT $TEXT"; exit; fi
|
||||
if [[ ${#PHONE} -ne 12 && ${#PHONE} -ne 46 ]]; then log "!! SMS REJECTED !! $PHONE BAD $TEXT"; exit; fi
|
||||
fi
|
||||
|
||||
# ANTI SPAM SMS (1 mn entre chaque commande)
|
||||
find /tmp -cmin +1 -type f -name "sms_received_*" -exec rm -f '{}' \;
|
||||
|
||||
# Do not consider SPAM, Delivered notification
|
||||
if [[ "$CMD" != "DELIVERED" && "$CMD" != "PENDING" ]]; then
|
||||
if [[ -f "/tmp/sms_received_$PHONE" ]]; then
|
||||
# Send response SMS
|
||||
if [[ ! -f "/tmp/sms_SPAM_$PHONE" ]]; then
|
||||
sms_ERROR "$PHONE" "Je ne le dirai pas 2 fois... Laissez moi au moins 1 minute entre chacune de vos commandes SMS! Autrement je n'y répondrai pas. Merci!"
|
||||
echo $(date) > "/tmp/sms_SPAM_$PHONE"
|
||||
fi
|
||||
log "__SUB:security: ################################"
|
||||
log "__SUB:security: $PHONE COMMAND REJECTED: $TEXT"
|
||||
exit
|
||||
fi
|
||||
echo "$TEXT" > "/tmp/sms_received_$PHONE"
|
||||
# Remove SPAM flag older than one day
|
||||
find /tmp -ctime +1 -type f -name "sms_SPAM_*" -exec rm -f '{}' \;
|
||||
else
|
||||
# THIS IS AN AKNOWLEGEMENT
|
||||
log "__SUB:security: ################################"
|
||||
log "__SUB:security: $PHONE COMMAND REJECTED: $TEXT"
|
||||
exit
|
||||
fi
|
||||
# Remove SPAM flag older than one day
|
||||
find /tmp -ctime +1 -type f -name "sms_SPAM_*" -exec rm -f '{}' \;
|
||||
|
||||
}
|
||||
|
||||
|
||||
#################################################################################################################################
|
||||
function ipfs_swarm_wallets_refresh (){
|
||||
|
||||
# Refresh CURRENT NODE wallets STATUS
|
||||
I=$(ipfs_node_wallets_add)
|
||||
|
||||
# REFRESH SWARM MEMORY
|
||||
mkdir -p "./wallets_swarm"
|
||||
chown -R $YOU "./wallets_swarm"
|
||||
log "__SUB:ipfs_swarm_wallets_refresh: REFRESHING SWARM $PHONE shared memory..."
|
||||
if [[ $PHONE ]]; then rm -Rf ./wallets_swarm/$PHONE; fi
|
||||
|
||||
# GET IPNS published wallets from ALL SWARM NODES / TODO: IF NODES MISSING, check ./wallets_swarm/.QmNODES...
|
||||
#log "__SUB:ipfs_swarm_wallets_refresh: IPFS: ipfs get --output=./wallets_swarm/ /ipns/$IPFSNODEID"
|
||||
su $YOU -c "ipfs get --output=./wallets_swarm/ /ipns/$IPFSNODEID"
|
||||
count=1
|
||||
# Search for All peers Nodes. TODO: To be changed when Swarm is too bug or not expendanding
|
||||
#for id in ./wallets/.Qm*/;
|
||||
for id in $(su $YOU -c "ipfs swarm peers" | awk -F '/' '{print $7}');
|
||||
do
|
||||
count=$((count+1))
|
||||
id=$(echo $id | cut -d '.' -f 3 | cut -d '/' -f 1)
|
||||
log "__SUB:ipfs_swarm_wallets_refresh: IPFS: ipfs get --output=./wallets_swarm/ /ipns/$id"
|
||||
rm -Rf ./wallets_swarm/.$id
|
||||
./shell/timeout.sh -t 20 su $YOU -c "ipfs get --output=./wallets_swarm/ /ipns/$id"
|
||||
done
|
||||
log "__SUB:ipfs_swarm_wallets_refresh: ./wallets_swarm/ RENEW from $count peers .........OK!!!"
|
||||
|
||||
|
||||
############################################################################"
|
||||
# TREAT move_g1cents Tasks in ./wallets/.$IPFSNODEID
|
||||
# IF NODE find in ./wallets_swarm/.$IPFSNODEID/TASK directory && Have it's G1 Wallet already (for natools crypto)
|
||||
if [[ "$1" != "SIMPLE" && -d ./wallets_swarm/.$IPFSNODEID/TASK && -f "./wallets/.$IPFSNODEID/$IPFSNODEID.authfile.GPGPASS.gpg" ]]; then
|
||||
############################################################################"
|
||||
for task in $(ls ./wallets_swarm/.$IPFSNODEID/TASK/*.move_g1cents.*); # ./wallets/.$IPFSNODEID/TASK/$NANODATE.move_g1cents.$DESTPHONE.NODEPUB.crypt OR "done.$NANODATE" FILES
|
||||
do
|
||||
FTASK=$( echo $task | cut -d '/' -f 5 ) # "$NANODATE.move_g1cents.$DESTPHONE.NODEPUB.crypt"
|
||||
TNANO=$( echo $FTASK | cut -d '.' -f 1) # $NANODATE
|
||||
TTYPE=$( echo $FTASK | cut -d '.' -f 2) # move_g1cents
|
||||
TDEST=$( echo $FTASK | cut -d '.' -f 3) # $DESTPHONE
|
||||
log "__SUB:ipfs_swarm_wallets_refresh: .$IPFSNODEID($FTASK) FOUND TASK $TNANO:$TTYPE:$TDEST "
|
||||
# MAKE LOCAL .$IPFSNODEID directory
|
||||
mkdir -p ./wallets/.$IPFSNODEID/TASK/
|
||||
# TODO: CHECK BETTER NOT DONE YET and $NANODATE > $TNANO (=> detect NODES writing in the future!!)
|
||||
if [[ ! -f "./wallets/.$IPFSNODEID/TASK/done.$TNANO" ]]; then # NOT DONE YET: NEW TASK!
|
||||
tdiff=$(bc -l <<< "$NANODATE - $TNANO")
|
||||
if [[ $tdiff -gt 0 ]]; then
|
||||
# GET BACK MY NODE G1 Wallet authfile from my LOCAL ./wallets
|
||||
echo "${GPGPASS}" | gpg -q -d --output "./NODEG1Wallet.authfile" --yes --pinentry-mode loopback --symmetric --passphrase-fd 0 "./wallets/.$IPFSNODEID/$IPFSNODEID.authfile.GPGPASS.gpg"
|
||||
# DECRYPT and CAT move_g1cents VALUE
|
||||
./shell/natools.py decrypt -k "./NODEG1Wallet.authfile" -i "$task" -o "/tmp/move_g1cents.$TDEST"
|
||||
ZENVAL=$(cat "/tmp/move_g1cents.$TDEST")
|
||||
log "__SUB:ipfs_swarm_wallets_refresh: tdiff=$tdiff .$IPFSNODEID G1 = ./NODEG1Wallet.authfile :decrypt: Found $ZENVAL Zen to ADD"
|
||||
rm -f "./NODEG1Wallet.authfile"
|
||||
if [[ $ZENVAL -gt 0 ]]; then
|
||||
curvalue=$(cat ./wallets/$TDEST/$TDEST.g1cents)
|
||||
newvalue=$(bc -l <<< "$curvalue + $ZENVAL")
|
||||
echo $newvalue > ./wallets/$TDEST/$TDEST.g1cents
|
||||
echo "OK.$tdiff" > ./wallets/.$IPFSNODEID/TASK/done.$TNANO
|
||||
log "__SUB:ipfs_swarm_wallets_refresh: .$IPFSNODEID($FTASK) DONE! OPERATION: ($curvalue + $ZENVAL) = $newvalue Zen <=> ./wallets/$TDEST/$TDEST.g1cents:: OK"
|
||||
# REFRESH ./wallets and PUBLISH
|
||||
I=$(ipfs_node_wallets_add)
|
||||
else
|
||||
echo "KO.$tdiff" > ./wallets/.$IPFSNODEID/TASK/done.$TNANO
|
||||
log "__SUB:ipfs_swarm_wallets_refresh: .$IPFSNODEID($FTASK) ERROR! BAD: ($curvalue + $ZENVAL) = $newvalue Zen <=> ./wallets/$TDEST/$TDEST.g1cents :: KO"
|
||||
I=$(ipfs_node_wallets_add)
|
||||
sms_SEND "$ADMINPHONE" "ADMIN! TASK ERROR: .$IPFSNODEID($FTASK) ERROR! BAD: ($curvalue + $ZENVAL) = $newvalue Zen <=> ./wallets/$TDEST/$TDEST.g1cents :: KO"
|
||||
fi
|
||||
else
|
||||
# TODO: Bad NODE in the Future task !!! Make better BAD Node detection = Swarm Banish?
|
||||
echo "KO.$tdiff" > ./wallets/.$IPFSNODEID/TASK/done.$TNANO
|
||||
log "__SUB:ipfs_swarm_wallets_refresh: .$IPFSNODEID($FTASK) ERROR! DATE PROBLEM: $NANODATE < $TNANO :: KO"
|
||||
I=$(ipfs_node_wallets_add)
|
||||
sms_SEND "$ADMINPHONE" "ADMIN! .$IPFSNODEID($FTASK) ERROR! DATE PROBLEM: $NANODATE < $TNANO :: KO"
|
||||
fi
|
||||
fi
|
||||
done
|
||||
|
||||
log "__SUB:ipfs_swarm_wallets_refresh: REMOVE OLD TASK MARKED AS DONE"
|
||||
for scan in ./wallets_swarm/.Qm*/TASK/done.*; do
|
||||
lscan=$(echo $scan | sed s/_swarm//g )
|
||||
lid=$(echo $scan | cut -d '/' -f 3 | cut -d '.' -f 2 )
|
||||
lnano=$(echo $scan | cut -d '/' -f 5 | cut -d '.' -f 2 )
|
||||
if [[ "$lid" != "$IPFSNODEID" ]]; then
|
||||
log "__SUB:ipfs_swarm_wallets_refresh: CLEANING done OLD TASK ${lscan} SENT to $lid ($lnano.bin)"
|
||||
rm -f ./wallets/.$lid/TASK/$lnano.*
|
||||
I=$(ipfs_node_wallets_add)
|
||||
fi
|
||||
done
|
||||
else
|
||||
log "__SUB:ipfs_swarm_wallets_refresh: .$IPFSNODEID :: NO TASK ! "
|
||||
############################################################################"
|
||||
fi
|
||||
}
|
||||
|
||||
|
||||
#################################################################################################################################
|
||||
function ipfs_node_wallets_add (){
|
||||
##########################
|
||||
##########################
|
||||
IWALLETS=$(su $YOU -c "ipfs add -rHq './wallets' | tail -n 1")
|
||||
|
||||
# CHAIN STATE FOR $IPFSNODEID
|
||||
echo $IWALLETS > ./wallets/.$IPFSNODEID.wallets.chain
|
||||
log "__SUB:ipfs_node_wallets_add: NEW './wallets' HASH ipfs ls $IWALLETS"
|
||||
|
||||
# PUBLISH IPNS NODE WALLETS
|
||||
NODEWALLETS=$(su $YOU -c "ipfs name publish --quieter /ipfs/$IWALLETS")
|
||||
log "__SUB:ipfs_node_wallets_add: G1smsWallet = ipfs cat /ipns/$NODEWALLETS/$PHONE/$PHONE.g1cents Zen"
|
||||
|
||||
echo $IWALLETS
|
||||
}
|
||||
|
||||
|
||||
#################################################################################################################################
|
||||
function sms_uid2key (){
|
||||
RIBFILE="./wallets/$PHONE/$PHONE.uidrib"
|
||||
NAMEFILE="./wallets/$PHONE/$PHONE.uidname"
|
||||
UIDNAFILE="./wallets/$PHONE/$PHONE.uidna"
|
||||
# New related wallet asked
|
||||
ASKWALLET="$1"
|
||||
#For micro payement
|
||||
PHONE="$2"
|
||||
PIN="$3"
|
||||
if -f "$UIDNAFILE"; then UIDNA=$(cat "$UIDNAFILE"); else UIDNA=""; fi
|
||||
log "__SUB:sms_uid2key: $UIDNA Try to associate $ASKWALLET with $PHONE... SEARCHING..."
|
||||
|
||||
if [[ $UIDNA && "$ASKWALLET" == "$UIDNA" ]]; then
|
||||
log "__SUB:sms_uid2key: "$ASKWALLET" == "$UIDNA" !!"
|
||||
sms_SEND "$PHONE" "[G1sms+] $UIDNA est le nom de votre porte monnaie libre pour $PHONE. Il ne peut également être compte maître!"
|
||||
fi
|
||||
|
||||
# Test if member files exists
|
||||
if [ -f "$NAMEFILE" ]; then
|
||||
UIDNAME=$(cat "$NAMEFILE")
|
||||
log "__SUB:sms_uid2key: ALREADY $UIDNAME related Wallet for $PHONE Wallet change to $ASKWALLET !!"
|
||||
if [["$UIDNAME" != "$ASKWALLET" ]]; then
|
||||
sms_SEND "$ADMINPHONE" "ADMIN! INFO: $PHONE Wallet associé à $UIDNAME change en $ASKWALLET !!"
|
||||
sms_SEND "$PHONE" "[G1sms+] Votre portefeuille maitre va passer de $UIDNAME à $ASKWALLET!"
|
||||
fi
|
||||
fi
|
||||
|
||||
# Search fo duplicate
|
||||
DUP=$(grep -Rwl "$ASKWALLET" ./wallets/*/*.uidname | cut -f 3 -d '/')
|
||||
if [[ "$DUP" != "" && "$DUP" != "$PHONE" ]]; then
|
||||
sms_SEND "$ADMINPHONE" "ADMIN! INFO: $PHONE prend le même $ASKWALLET, que $DUP"
|
||||
sms_SEND "$DUP" "Vous devez savoir que $ASKWALLET est associé à un autre téléphone que le votre également!"
|
||||
fi
|
||||
|
||||
###########################################################
|
||||
# FIND ASKWALLET into wallets, wallest_swarm OR duniter (silkaj)
|
||||
DESTMEM="$VIRDEST"
|
||||
# SEARCH IN WALLETS
|
||||
LOCAL=$(grep -Rwl "$ASKWALLET" ./wallets/*/*.uidna | cut -f 3 -d '/')
|
||||
if [[ "$LOCAL" != "" ]]; then
|
||||
# LOCAL G1sms account
|
||||
DESTRIB=$(cat ./wallets/$LOCAL/$LOCAL.pub)
|
||||
DESTPHONE=$LOCAL
|
||||
log "__SUB:sms_uid2key: FOUND LOCAL ($MASTERPHONE) G1sms+ wallet: $DESTRIB ($LOCAL)"
|
||||
else
|
||||
# SEARCH IN WALLETS SWARM
|
||||
INSWARM=$(grep -Rwl "$ASKWALLET" ./wallets_swarm/*/*.uidna | cut -f 3 -d '/')
|
||||
if [[ "$INSWARM" != "" ]]; then
|
||||
REMOTENODE=$(cat ./wallets_swarm/$INSWARM/MASTERPHONE.sms)
|
||||
DESTRIB=$(cat ./wallets_swarm/$INSWARM/$INSWARM.pub)
|
||||
DESTPHONE=$INSWARM
|
||||
log "__SUB:sms_uid2key: FOUND SWARM ($REMOTENODE) G1sms+ wallet: $DESTRIB ($INSWARM)"
|
||||
else
|
||||
# SEARCH WITH SILKAJ
|
||||
log "__SUB:sms_uid2key: GETTING FROM SILKAJ MEMBER ID"
|
||||
DESTRIB=$(./silkaj/silkaj id "$ASKWALLET" | grep -w "$ASKWALLET" | awk '{print $2}')
|
||||
log "__SUB:sms_uid2key: OUT OFF SWARM MEMBER wallet: $DESTRIB"
|
||||
# GET CESIUM+ geoPoint DATA (TODO: cron for GCHANGE SMS Alert)
|
||||
curl -s ${CESIUM}/user/profile/${DESTRIB} | jq '._source.geoPoint' > "./wallets/$PHONE/$PHONE.uidgeo.json"
|
||||
log "__SUB:sms_uid2key: GET CESIUM+ geoPoint and AVATAR : $(cat ./wallets/$PHONE/$PHONE.uidgeo.json)"
|
||||
curl -s ${CESIUM}/user/profile/${DESTRIB} | jq '._source.avatar._content' | sed 's/\"//g' | base64 -d > "./wallets/$PHONE/$PHONE.avatar.png"
|
||||
fi
|
||||
fi
|
||||
|
||||
if [ "$DESTRIB" != "" ]; then
|
||||
echo "$DESTRIB" > "$RIBFILE"
|
||||
echo "$ASKWALLET" > "$NAMEFILE"
|
||||
log "__SUB:sms_uid2key: NEW EXTERNAL RELATED $DESTRIB / FOR MEMBER OR WALLET = $ASKWALLET - INIT 0.1 TX"
|
||||
INIT=$(./silkaj/silkaj transaction --auth-scrypt -salt="$PHONE" -password="$PIN" --amount="0.1" --output=$DESTRIB --comment="[G1sms+] Porte Monnaie $(cat $UIDNAFILE) -> $(cat $NAMEFILE)" -y)
|
||||
log "__SUB:sms_uid2key: INIT = $INIT | Create Connection with related Wallet."
|
||||
log_history "$PHONE" "MEMBER, $ASKWALLET"
|
||||
sms_SEND "$ADMINPHONE" "ADMIN! LOG: $PHONE Nouveau compte lié $UIDNA -- $ASKWALLET ($INIT)"
|
||||
else
|
||||
sms_SEND "$ADMINPHONE" "ADMIN! LOG: $PHONE / $ASKWALLET ABSENT"
|
||||
fi
|
||||
|
||||
log "__SUB:sms_uid2key: $MEMBER($DESTRIB)"
|
||||
echo "$DESTRIB"
|
||||
}
|
||||
|
||||
|
||||
#################################################################################################################################
|
||||
function sms_INIT_ACCOUNT () {
|
||||
log "__SUB:sms_INIT_ACCOUNT: ($1=phone, $2=NOSMS)"
|
||||
PHONE="$1"
|
||||
UNKNOWN=0
|
||||
# TODO Optimize GLOBAL/local variables use, use more function array output ?!
|
||||
# Initiate PHONE settings files and values
|
||||
IPFSNODEIDFILE="./wallets/$PHONE/MASTERPHONE.ipfsid" # Contains G1sms+ NODE IPFS id
|
||||
SMSNODE="./wallets/$PHONE/MASTERPHONE.sms" # Contains G1sms+ SMS phone number
|
||||
PINFILE="./wallets/$PHONE/$PHONE.pin" # Contains phone wallet diceware password
|
||||
GPGPINFILE="./wallets/$PHONE/$PHONE.pin.gpg" # Contains g1smsnode cypher phone wallet diceware password
|
||||
AUTHCRYPTFILE="./wallets/$PHONE/$PHONE.authfile.crypt" # Crypt with $NODE_G1PUBKEY
|
||||
PUBKEYFILE="./wallets/$PHONE/$PHONE.pub" # Contains phone wallet public key (RIB)
|
||||
UNITFILE="./wallets/$PHONE/$PHONE.unit" # Contains phone wallet prefered unit (LOVE,G1,DU)
|
||||
|
||||
RIBFILE="./wallets/$PHONE/$PHONE.uidrib" # Contains phone wallet related UID Pubkey
|
||||
NAMEFILE="./wallets/$PHONE/$PHONE.uidname" # Contains the member UID related to wallet
|
||||
MAILFILE="./wallets/$PHONE/$PHONE.email" # Contains the member EMAIL (Send BILLET)
|
||||
GPGMAILFILE="./wallets/$PHONE/$PHONE.email.gpg" # Contains the member EMAIL (Send BILLET)
|
||||
UIDNAFILE="./wallets/$PHONE/$PHONE.uidna" # Contains the G1sms+ UID Name for recursive VIR
|
||||
GEOFILE="./wallets/$PHONE/$PHONE.uidgeo.json" # Contains the member GeoPoint from member Cesium+ related to wallet
|
||||
|
||||
RECFILE="./wallets/$PHONE/VIREMENTS" # File showing recurrent payements are left to be done with this G1sms Wallet
|
||||
GPGRECFILE="./wallets/$PHONE/VIREMENTS.gpg" # Cypher file with GPGPASS (Node .Identity.PrivKey)
|
||||
G1COUNTFILE="./wallets/$PHONE/$PHONE.g1cents" # Last sms_COUNT.sh call value
|
||||
CHAINFILE="./wallets/$PHONE/$PHONE.chain" # Contains wallet last IPFS hash before ZEN value change
|
||||
|
||||
DABUIDF="./wallets/$PHONE/uidna.G1TAGNODE" # Contains G1Dab Name
|
||||
# GET CURRENT NODE UIDNA (default DABUID)
|
||||
NODEUIDNA=$(cat "./wallets/.$IPFSNODEID/$IPFSNODEID.uidna")
|
||||
[[ $NODEUIDNA == "" ]] && NODEUIDNA=$(cat "./wallets/.$IPFSNODEID/_uidna")
|
||||
######################################################################
|
||||
# (NO PIN) = FIRST ACCOUNT: Create wallet
|
||||
if [ ! -f "$PINFILE" ]; then
|
||||
# NOSMS mode?
|
||||
if [[ $2 == "NOSMS" ]]; then UNKNOWN="unknown"; return; fi
|
||||
|
||||
#######################
|
||||
# Create Account Files
|
||||
#######################
|
||||
mkdir -p "./wallets/$PHONE/"
|
||||
PIN=$(./shell/diceware.sh | xargs)
|
||||
PUBKEY=$(./silkaj/silkaj generate_auth_file --auth-scrypt -salt="$PHONE" -password="$PIN")
|
||||
|
||||
# BACKUP authfile available to authfile or PIN owner (DOUBLON AVEC PIN) TEST
|
||||
log "__SUB:sms_INIT_ACCOUNT: ./shell/natools.py encrypt -p $PUBKEY -i ""./authfile"" -o ""$AUTHCRYPTFILE"""
|
||||
./shell/natools.py encrypt -p $NODE_G1PUBKEY -i "./authfile" -o "$AUTHCRYPTFILE"
|
||||
rm -f ./authfile
|
||||
log "__SUB:sms_INIT_ACCOUNT: !! G1 Wallet CREATED: $PHONE $PIN : $PUBKEY"
|
||||
|
||||
#######################
|
||||
# GIVE NAME TO WALLET
|
||||
#######################
|
||||
# 4 derniers chiffres du numéro de téléphone
|
||||
TAIL=${PHONE:8:4}
|
||||
# No UIDNA yet. Create new
|
||||
UIDNA=$(./shell/diceware.sh 1 | xargs)
|
||||
# Check if already existing among all swarm wallets
|
||||
while [[ $(grep -Rwl $UIDNA$TAIL ./wallets_swarm/*/*.uidna) ]]; do UIDNA=$(./shell/diceware.sh 1 | xargs); done
|
||||
echo "$UIDNA$TAIL" > "$UIDNAFILE"
|
||||
|
||||
#######################
|
||||
# ACTIVATE G1SMS WALLET
|
||||
#######################
|
||||
# log "$NODE_G1AUTHFILE $PUBKEY THIRD_PARTY_MANAGER:$NODE_G1PUBKEY"
|
||||
TX_IN=$(./silkaj/silkaj transaction --auth-file -file="$NODE_G1AUTHFILE" --amount=3.24 --output=$PUBKEY --comment="[G1sms+] $UIDNA$TAIL 3RD:$NODE_G1PUBKEY " -y)
|
||||
log "__SUB:sms_INIT_ACCOUNT: G1 Wallet TX IN: $TX_IN"
|
||||
sleep 2
|
||||
TX_OUT=$(./silkaj/silkaj transaction --auth-scrypt -salt="$PHONE" -password="$PIN" --amount=0.1 --output=$NODE_G1PUBKEY --comment="[G1sms+] $UIDNA$TAIL 3RD:$NODE_G1PUBKEY:ACK" -y)
|
||||
log "__SUB:sms_INIT_ACCOUNT: G1 Wallet TX OUT: $TX_OUT"
|
||||
|
||||
################
|
||||
# GPG cypher PIN (ONLY CREATOR NODE CAN ACCESS IT !)
|
||||
################
|
||||
echo "$PIN" > "$PINFILE"
|
||||
echo "${GPGPASS}" | gpg -q --output "$GPGPINFILE" --yes --pinentry-mode loopback --symmetric --passphrase-fd 0 "$PINFILE"
|
||||
PIN=$(cat "$PINFILE" | xargs)
|
||||
[[ "$PIN" != "" ]] && echo "" > "$PINFILE" || log "SYSTEM ERROR :: PIN EMPTY !!! GPG???"
|
||||
|
||||
echo "114" > "$G1COUNTFILE"
|
||||
echo "$PUBKEY" > "$PUBKEYFILE"
|
||||
echo "$COIN" > "$UNITFILE"
|
||||
echo "$MASTERPHONE" > "$SMSNODE"
|
||||
log_history "$PHONE" "NEW, $PUBKEY"
|
||||
|
||||
# ADD WALLET TO IPFS
|
||||
I=$(ipfs_node_wallets_add)
|
||||
fi
|
||||
|
||||
|
||||
#################################################
|
||||
# PUBLISH G1sms+ WALLET PROPERTIES MAIN PROCESS
|
||||
#################################################
|
||||
######################################################################
|
||||
if [[ ! -f "$GPGPINFILE" ]]
|
||||
then
|
||||
# ------------8<------------------
|
||||
# WALLET MIGRATION -> CRYPT PIN (For Old G1sms clear PIN WALLETs...)
|
||||
# ADD NEW PARAMS TO WALLET
|
||||
#######################
|
||||
# 4 derniers chiffres du numéro de téléphone
|
||||
echo "$MASTERPHONE" > "$SMSNODE"
|
||||
TAIL=${PHONE:8:4}
|
||||
# No UIDNA yet. Create new
|
||||
UIDNA=$(./shell/diceware.sh 1 | xargs)
|
||||
# Check if already existing among all swarm wallets
|
||||
while [[ $(grep -Rwl $UIDNA$TAIL ./wallets_swarm/*/*.uidna) ]]; do UIDNA=$(./shell/diceware.sh 1 | xargs); done
|
||||
echo "$UIDNA$TAIL" > "$UIDNAFILE"
|
||||
|
||||
PIN=$(cat "$PINFILE" | xargs)
|
||||
log "__SUB:sms_INIT_ACCOUNT: Old G1sms wallet ;) SECURITY HOLE... Chiffrage PGP du PIN !!!"
|
||||
echo "${GPGPASS}" | gpg -q --output "$GPGPINFILE" --yes --pinentry-mode loopback --symmetric --passphrase-fd 0 "$PINFILE";
|
||||
./shell/natools.py encrypt -p $NODE_G1PUBKEY -i "$PINFILE" -o "$PINFILE.$NODE_UIDNA.crypt"
|
||||
else
|
||||
# ------------>8------------------
|
||||
log "__SUB:sms_INIT_ACCOUNT: Déchiffrage PGP PIN..."
|
||||
# GPG decypher PIN
|
||||
# TODO make decypher less stress on filesystem, use /tmp and ramdisk
|
||||
echo "${GPGPASS}" | gpg -d -q --output "$PINFILE" --yes --pinentry-mode loopback --passphrase-fd 0 "$GPGPINFILE"
|
||||
PIN=$(cat "$PINFILE" | xargs)
|
||||
[[ "$PIN" == "" && -f "$PINFILE.$NODE_UIDNA.crypt" ]] && ./shell/natools.py decrypt -k "$NODE_G1AUTHFILE" -i "$PINFILE.$NODE_UIDNA.crypt" -o "$PINFILE" && PIN=$(cat "$PINFILE");
|
||||
[[ "$PIN" != "" ]] && echo "" > "$PINFILE" || log "SYSTEM ERROR :: PIN EMPTY !!! GPG???"
|
||||
fi
|
||||
|
||||
# CYPHER EMAIL FILE
|
||||
if [[ ! -f "$GPGMAILFILE" ]]; then
|
||||
# ------------8<------------------
|
||||
log "__SUB:sms_INIT_ACCOUNT: NO EMAIL .gpg file, CREATING it"
|
||||
if [ -f "$MAILFILE" ]; then
|
||||
MAIL=$(cat "$MAILFILE");
|
||||
echo "${GPGPASS}" | gpg -q --output "$GPGMAILFILE" --yes --pinentry-mode loopback --symmetric --passphrase-fd 0 "$MAILFILE";
|
||||
else
|
||||
MAIL="";
|
||||
fi
|
||||
# ------------>8------------------
|
||||
else
|
||||
log "__SUB:sms_INIT_ACCOUNT: DECODING EMAIL .gpg... "
|
||||
echo "${GPGPASS}" | gpg -d -q --output "$MAILFILE" --yes --pinentry-mode loopback --passphrase-fd 0 "$GPGMAILFILE"
|
||||
MAIL=$(cat "$MAILFILE");
|
||||
[[ $MAIL == "" && -f "$MAILFILE.node.crypt" ]] && ./shell/natools.py decrypt -k "$NODE_G1AUTHFILE" -i "$MAILFILE.node.crypt" -o "$MAILFILE" && MAIL=$(cat "$MAILFILE");
|
||||
# EMPTY CLEAR EMAIL FILE
|
||||
[[ $MAIL != "" ]] && echo "" > "$MAILFILE" || log "SYSTEM ERROR :: MAIL EMPTY !!! GPG???"
|
||||
fi
|
||||
|
||||
# ------------8<------------------
|
||||
# REMOVE OLD HISTORY FILES
|
||||
rm -f ./wallets/$PHONE/$PHONE.hist
|
||||
# ------------>8------------------
|
||||
|
||||
# PUBLISH GLOBAL VARS FROM ACCOUNT FILES
|
||||
echo $IPFSNODEID > $IPFSNODEIDFILE
|
||||
PUBKEY=$(cat "$PUBKEYFILE" | xargs)
|
||||
UNIT=$(cat "$UNITFILE" | xargs)
|
||||
if [ -f "$G1COUNTFILE" ]; then AMOUNTG1=$(bc <<< "scale=2; $(cat $G1COUNTFILE) / 100"); fi
|
||||
if [ -f "$NAMEFILE" ]; then MEMBER=$(cat "$NAMEFILE"); else MEMBER=""; fi
|
||||
if [ -f "$RIBFILE" ]; then MEMRIB=$(cat "$RIBFILE"); else MEMRIB=""; fi
|
||||
if [ -f "$UIDNAFILE" ]; then UIDNA=$(cat "$UIDNAFILE"); else UIDNA=""; fi
|
||||
if [ -f "$DABUIDF" ]; then DABID=$(cat "$DABUIDF"); else DABID="$NODEUIDNA"; fi
|
||||
|
||||
|
||||
AMOUNTDU=$(bc <<< "scale=2; $AMOUNTG1 / $DUFACTOR")
|
||||
AMOUNTLOVE=$(bc <<< "$AMOUNTG1 * 100 / $DUFACTOR")
|
||||
|
||||
case "$UNIT" in
|
||||
G1)
|
||||
AMOUNT=$AMOUNTG1
|
||||
;;
|
||||
DU)
|
||||
AMOUNT=$AMOUNTDU
|
||||
;;
|
||||
*)
|
||||
AMOUNT=$AMOUNTLOVE
|
||||
;;
|
||||
esac
|
||||
log "__SUB:sms_INIT_ACCOUNT: $AMOUNTG1 = $AMOUNT $UNIT"
|
||||
|
||||
# LOG # TODO REMOVE PIN LOG!!
|
||||
log "#####################"
|
||||
log "PHONE: $PHONE"
|
||||
log "PIN: $PIN"
|
||||
log "PUBKEY: $PUBKEY"
|
||||
log "G1: $AMOUNTG1"
|
||||
log "AMOUNT: $AMOUNT $UNIT"
|
||||
log "UIDNA: $UIDNA"
|
||||
log "MEMBER: $MEMBER"
|
||||
log "MEMRIB: $MEMRIB"
|
||||
log "MAIL: $MAIL"
|
||||
log "DABID: $DABID"
|
||||
log "#####################"
|
||||
|
||||
|
||||
log "__SUB:sms_INIT_ACCOUNT: END"
|
||||
}
|
||||
|
||||
|
||||
#################################################################################################################################
|
||||
function check_account (){
|
||||
log "__SUB:check_account: SILKAJ...... max 30 sec....."
|
||||
AMOUNTG1=$(./shell/timeout.sh -t 30 ./silkaj/silkaj amount "$PUBKEY")
|
||||
AMOUNTDU=$(bc <<< "scale=2; $AMOUNTG1 / $DUFACTOR")
|
||||
AMOUNTLOVE=$(bc <<< "$AMOUNTG1 * 100 / $DUFACTOR")
|
||||
|
||||
case "$UNIT" in
|
||||
G1)
|
||||
AMOUNT=$AMOUNTG1
|
||||
;;
|
||||
DU)
|
||||
AMOUNT=$AMOUNTDU
|
||||
;;
|
||||
*)
|
||||
AMOUNT=$AMOUNTLOVE
|
||||
;;
|
||||
esac
|
||||
G1cents=$(echo "$AMOUNTG1*100" | bc -l | awk '{print int($0)}')
|
||||
|
||||
log "__SUB:check_account: $PHONE: $AMOUNTG1 = $AMOUNT $UNIT ($G1cents) - $PUBKEY"
|
||||
|
||||
if [[ "$G1cents" != "" ]]; then
|
||||
NN=$(cat "./wallets/$PHONE/$PHONE.n")
|
||||
((NN++))
|
||||
echo "$NN" > "./wallets/$PHONE/$PHONE.n"
|
||||
echo $G1cents > "./wallets/$PHONE/$PHONE.g1cents"
|
||||
# REFRESH NODE IPFS wallets & PUBLISH
|
||||
I=$(ipfs_node_wallets_add)
|
||||
# Register modification
|
||||
echo "$I" > "./wallets/$PHONE/$PHONE.chain"
|
||||
else
|
||||
# BAN actual Duniter Node in case of silkaj timeout.
|
||||
export NEWDUNITER=$(./shell/checknodes.sh 'BAN')
|
||||
log "__SUB:check_account: !!! SILKAJ IS TOO SLOW !!! => NEW DUNITER SERVER: $NEWDUNITER"
|
||||
fi
|
||||
|
||||
declare -a aaa
|
||||
aaa=( "$AMOUNTG1" "$AMOUNT" "$UNIT" )
|
||||
log "__SUB:check_account: $(declare -p aaa)"
|
||||
echo ${aaa[@]}
|
||||
}
|
||||
|
||||
|
||||
#################################################################################################################################
|
||||
function make_accounting (){
|
||||
# CONVERT AMOUNT UNIT to VIR G1
|
||||
case "$UNIT" in
|
||||
G1)
|
||||
VIR=$AMOUNT;
|
||||
;;
|
||||
DU)
|
||||
VIR=$(bc -l <<< "scale=2; $AMOUNT * $DUFACTOR")
|
||||
;;
|
||||
LOVE)
|
||||
VIR=$(bc -l <<< "scale=2; $AMOUNT * $DUFACTOR / 100")
|
||||
;;
|
||||
*)
|
||||
VIR=$(bc -l <<< "scale=2; $AMOUNT * $DUFACTOR / 100")
|
||||
;;
|
||||
esac
|
||||
|
||||
###########################################################
|
||||
# GET G1sms wallet AMOUNTG1 and CHECK for right balance
|
||||
log "__SUB:make_accounting: LOCAL $VIR amount for $PHONE : $PUBKEY"
|
||||
# Try to ask silkaj. If timeout, use SWARM last known $PHONE.g1cents value
|
||||
AMOUNTG1=$(./shell/timeout.sh -t 30 ./silkaj/silkaj amount "$PUBKEY")
|
||||
if [[ "$AMOUNTG1" == "" ]]; then AMOUNTG1=0; fi
|
||||
# TAX AND MINIMUM WALLET ACCOUNT CALCULATION
|
||||
PERCENT=0$(bc -l <<< "scale=2; $VIR / $SWARMCOMM")
|
||||
MIN=$(bc -l <<< "$AMOUNTG1 - $PERCENT - $LIMIT")
|
||||
CHARGE=$(bc -l <<< "scale=2; $VIR + $PERCENT + $LIMIT")
|
||||
TESTMIN=$( echo "${VIR} < ${MIN}" | bc -l )
|
||||
log "__SUB:make_accounting: TEST $AMOUNT $UNIT :: $VIR + $PERCENT + $LIMIT = $CHARGE < $AMOUNTG1 ? $TESTMIN"
|
||||
|
||||
declare -a myarray
|
||||
myarray=( "$TESTMIN" "$VIR" "$PERCENT" "$CHARGE")
|
||||
log "__SUB:make_accounting: $(declare -p myarray)"
|
||||
echo ${myarray[@]}
|
||||
}
|
||||
|
||||
#################################################################################################################################
|
||||
function move_g1cents (){
|
||||
# MODIFY $PHONE.g1cents value according to current silkaj
|
||||
# TODO MAKE ALL SILKAJ TX CALL HERE. OR REMOVE???
|
||||
# USE TASK COMMUNICATION BETWEEN NODES.
|
||||
phonesrc=$1
|
||||
pubkeydest=$2
|
||||
zenvalue=$3
|
||||
log "__SUB:move_g1cents: $phonesrc ($zenvalue) -> $pubkeydest :: $G1COUNTFILE ::"
|
||||
|
||||
### CHANGE INPUT VALUE ####
|
||||
curvalue=$(cat ./wallets/$phonesrc/$phonesrc.g1cents | cut -d '.' -f 1)
|
||||
newvalue=$(bc -l <<< "$curvalue - $zenvalue")
|
||||
echo $newvalue > ./wallets/$phonesrc/$phonesrc.g1cents
|
||||
log "__SUB:move_g1cents: DEBIT: OK APPLY $curvalue - $zenvalue = $newvalue TO ./wallets/$phonesrc/$phonesrc.g1cents"
|
||||
|
||||
### CHANGE OUTPUT VALUE ####
|
||||
# TEST IF $dest is a wallets_ G1sms PUBKEY?
|
||||
winnerphone=$(grep -Rwl "$pubkeydest" ./wallets_swarm/*/*.pub | cut -d '.' -f 2 | cut -d '/' -f 3)
|
||||
if [[ $winnerphone ]]; then
|
||||
# GET INFORMATON ON MANAGER NODE
|
||||
NODEID=$(cat ./wallets_swarm/$winnerphone/MASTERPHONE.ipfsid)
|
||||
|
||||
if [[ "$NODEID" == "$IPFSNODEID" ]]; then
|
||||
# ACTUAL NODE IS WALLET MANAGING NODE ;)
|
||||
curvalue=$(cat ./wallets/$winnerphone/$winnerphone.g1cents | cut -d '.' -f 1)
|
||||
newvalue=$(bc -l <<< "$curvalue + $zenvalue")
|
||||
echo $newvalue > ./wallets/$winnerphone/$winnerphone.g1cents
|
||||
log "__SUB:move_g1cents: CREDIT: OK APPLY $curvalue + $zenvalue = $newvalue TO ./wallets/$winnerphone/$winnerphone.g1cents"
|
||||
else
|
||||
# MUST ASK MANAGER NODE TO CORRECT g1cents FOR $winnerphone WALLET
|
||||
# WRITE TASK TO .$NODEID CHANNEL
|
||||
mkdir -p ./wallets/.$NODEID/TASK/
|
||||
# USE natools with NODEPUB crypt
|
||||
echo "$zenvalue" > "/tmp/move_g1cents.$winnerphone"
|
||||
# GET NODE G1sms Wallet PUBKEY
|
||||
NODEPUB=$(cat ./wallets_swarm/.$NODEID/$NODEID.pub)
|
||||
./shell/natools.py encrypt -p $NODEPUB -i "/tmp/move_g1cents.$winnerphone" -o "./wallets/.$NODEID/TASK/$NANODATE.move_g1cents.$winnerphone.NODEPUB.crypt"
|
||||
log "__SUB:move_g1cents: CREDIT: WRITE TASK TO ./wallets/.$NODEID/$NANODATE.move_g1cents.$winnerphone.NODEPUB.crypt "
|
||||
rm -f /tmp/move_g1cents.$winnerphone
|
||||
fi
|
||||
else
|
||||
log "__SUB:move_g1cents: ERROR: NO $pubkeydest WALLET FOUND"
|
||||
fi
|
||||
# UPDATE MY new ./wallet STATUS to SWARM
|
||||
I=$(ipfs_node_wallets_add)
|
||||
}
|
||||
|
||||
|
||||
#################################################################################################################################
|
||||
# Contact database management
|
||||
function add_contact(){
|
||||
userDB="gammu"
|
||||
pwdDB=$(cat /etc/gammu-smsdrc | grep "password =" | awk '{ print $3 }' || exit 1)
|
||||
local sql="mysql -N -u$userDB -p$pwdDB gammu -e"
|
||||
|
||||
local PHONE=$1
|
||||
local MEMBERUID=$2
|
||||
|
||||
[[ -z $MEMBERUID ]] && MEMBERUID=$PHONE
|
||||
|
||||
[[ -z $($sql "SELECT * FROM pbk_groups WHERE ID='1'") ]] && $sql "INSERT INTO pbk_groups (ID, Name, id_user, is_public) VALUES ('1', '$(grep "ADRESSE" $MY_PATH/../.profile | awk -F= '{ print $2 }' | tr -d '"')', '1', 'false')"
|
||||
|
||||
if [[ -z $($sql "SELECT * FROM pbk WHERE Number=$PHONE") ]]; then
|
||||
$sql "INSERT INTO pbk (GroupID, Name, Number, id_user, is_public) VALUES ('1', '$MEMBERUID', '$PHONE', '1', 'false')" || exit 1
|
||||
local id_user=$($sql "SELECT ID FROM pbk WHERE Number=$PHONE" || exit 1)
|
||||
$sql "INSERT INTO user_group (id_group, id_pbk, id_pbk_groups, id_user) VALUES ('$id_user', '$id_user', '1', '1')" || exit 1
|
||||
else
|
||||
log "${red}Contact already exist$c_"
|
||||
fi
|
||||
|
||||
}
|
||||
|
||||
function rm_contact(){
|
||||
userDB="gammu"
|
||||
pwdDB=$(cat /etc/gammu-smsdrc | grep "password =" | awk '{ print $3 }' || exit 1)
|
||||
local sql="mysql -N -u$userDB -p$pwdDB gammu -e"
|
||||
|
||||
local PHONE=$1
|
||||
local MEMBERUID=$2
|
||||
|
||||
[[ -z $MEMBERUID ]] && MEMBERUID=$PHONE
|
||||
|
||||
if [[ ! -z $($sql "SELECT * FROM pbk WHERE Number=$PHONE") ]]; then
|
||||
local id_user=$($sql "SELECT ID FROM pbk WHERE Number=$PHONE" || exit 1)
|
||||
$sql "DELETE FROM pbk WHERE Number=$PHONE" || exit 1
|
||||
$sql "DELETE FROM user_group WHERE id_group='$id_user'" || exit 1
|
||||
else
|
||||
log "${red}Contact doesn't exist$c_"
|
||||
fi
|
||||
|
||||
}
|
||||
Binary file not shown.
|
After Width: | Height: | Size: 33 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 23 KiB |
Binary file not shown.
|
After Width: | Height: | Size: 32 KiB |
|
|
@ -0,0 +1,6 @@
|
|||
duniter.moul.re:443
|
||||
g1.duniter.fr:443
|
||||
g1.duniter.org:443
|
||||
g1.le-sou.org:443
|
||||
g1.monnaielibreoccitanie.org:443
|
||||
g1.presles.fr:443
|
||||
|
|
@ -0,0 +1,83 @@
|
|||
#!/bin/bash
|
||||
##################################################################
|
||||
# Author: Fred (support@qo-op.com)
|
||||
# Version: 0.1
|
||||
# License: GPL (http://www.google.com/search?q=GPL)
|
||||
##################################################################
|
||||
|
||||
MY_PATH="`dirname \"$0\"`" # relative
|
||||
MY_PATH="`( cd \"$MY_PATH\" && pwd )`" # absolutized and normalized
|
||||
source $MY_PATH/.install/.GPATH
|
||||
|
||||
# Adapter les valeurs au contexte spatio-temporel du NODE G1SMS
|
||||
function log () {
|
||||
# log ($1=text)
|
||||
if [ "$DOLOG" == "YES" ]
|
||||
then
|
||||
echo "$PHONE:$1" >> /tmp/g1sms.log
|
||||
fi
|
||||
}
|
||||
|
||||
|
||||
###################################################################################################################################
|
||||
fn_exists() {
|
||||
# appended double quote is an ugly trick to make sure we do get a string -- if $1 is not a known command, type does not output anything
|
||||
[ `type -t $1`"" == 'file' ]
|
||||
}
|
||||
# ATOMATIC gammu-smsd-inject desactivation if no gammu is installed on system
|
||||
if ! fn_exists gammu-smsd-inject; then
|
||||
log ":p) DESACTIVATION ENVOI DE SMS .............."
|
||||
function gammu-smsd-inject () {
|
||||
log "$PHONE: >>> SENDING SMS $4 TO $2 "
|
||||
}
|
||||
else
|
||||
export G1SMS="YES"
|
||||
fi
|
||||
|
||||
|
||||
export YOU=$(ps auxf --sort=+utime | grep -w ipfs | grep -v -E 'color=auto|grep' | tail -n 1 | cut -d " " -f 1);
|
||||
cd $GPATH
|
||||
##################################################################
|
||||
# Activate logging to /tmp/g1sms.log (YES/NO)
|
||||
export DOLOG="YES"
|
||||
export CPERROR="NOYES"
|
||||
##################################################################
|
||||
# Country Node Phone international prefix (TODO Worldwide)
|
||||
export COUNTRY="+33"
|
||||
##################################################################
|
||||
# DU has a G1 value changed every 6 month!
|
||||
# ./_DU Updated by cron_CODE.backup.sh
|
||||
if [[ -f "./_DU" ]]; then export DUFACTOR=$(bc <<< "scale=2; $(cat "./_DU") / 100"); else log "__SUB:init.sh: FAILING TO FIND ./_DU EXIT!!!"; exit; fi
|
||||
##################################################################
|
||||
# Choose Default Unit: G1, DU, LOVE (DU cents), ZEN (G1 cents)
|
||||
export COIN="G1"
|
||||
##################################################################
|
||||
# Limit and commission values
|
||||
export LIMIT=2 # Solde minimum = 2 G1
|
||||
# FIXED COMMISSION SYSTEM
|
||||
export COMMISSION=1 # transaction commission amount (G1)
|
||||
export BILLCOM=20
|
||||
##################################################################
|
||||
# COMMISSION PARTS FROM TX FOR NODE & G1SMS NETWORK
|
||||
# PART COMMISSION SYSTEM
|
||||
export SWARMCOMM=10
|
||||
# TODO: NODE G1sms Wallet can receive rewards from SWARM or WALLETS/FILES
|
||||
export NODECOMM=10
|
||||
##################################################################
|
||||
# SMS SIM Card Phone Number
|
||||
export MASTERPHONE="+33651136520"
|
||||
export ADRESSE="G1_Fablab_Toulouse"
|
||||
export G1DAB="NO"
|
||||
##################################################################
|
||||
# ADMIN COMMAND PHONE ORIGIN
|
||||
export ADMINPHONE="+33647683646"
|
||||
export ADMINPSEUDO="Fred"
|
||||
##################################################################
|
||||
# DUNITER/CESIUM+ DEFAULT SERVERS
|
||||
export DUNITER="https://g1.duniter.org"
|
||||
export CESIUM="https://g1.data.le-sou.org"
|
||||
|
||||
# TODO Use latest Silkaj from "sudo fredp3 install silkaj"
|
||||
# export SILKAJ="/usr/local/bin/silkaj"
|
||||
source $GPATH/shell/init_keys.sh
|
||||
|
||||
|
|
@ -0,0 +1,148 @@
|
|||
#!/bin/bash
|
||||
##################################################################
|
||||
# Author: Fred (support@qo-op.com)
|
||||
# Version: 0.2
|
||||
# License: GPL (http://www.google.com/search?q=GPL)
|
||||
##################################################################
|
||||
# CHECK & WARN | CREATE Keys (gpg encrypt, G1wallet, IPNS publish)
|
||||
##################################################################
|
||||
|
||||
MY_PATH="`dirname \"$0\"`" # relative
|
||||
MY_PATH="`( cd \"$MY_PATH\" && pwd )`" # absolutized and normalized
|
||||
if [[ -f $MY_PATH/.install/.GPATH ]]; then source $MY_PATH/.install/.GPATH; fi
|
||||
if [[ -f $MY_PATH/../.install/.GPATH ]]; then source $MY_PATH/../.install/.GPATH; fi
|
||||
|
||||
YOU=$(ps aux --sort=+utime | grep ipfs | tail -n 1 | cut -d " " -f 1)
|
||||
IPFSNODEID=$(su $YOU -c "ipfs id -f='<id>\n'")
|
||||
NANODATE=$(date -u +%s%N) #1569692075385428020
|
||||
|
||||
##################################################################
|
||||
# G1sms+ Node KEYS (G1wallet, gpg, IPNS)
|
||||
##################################################################
|
||||
export GPGPASS=$(cat "/home/$YOU/.ipfs/config" | jq '.Identity.PrivKey' | sed s/\"//g) #"
|
||||
if [ ! $GPGPASS ]; then echo "FATAL ERROR:: IPFS Node.Identity.PrivKey GPGPASS EMPTY"; exit; fi
|
||||
|
||||
# GET SWARM KEY G1sms+ .ipfs/swarm.key
|
||||
export SWARMKEY=$(cat "/home/$YOU/.ipfs/swarm.key" | tail -n 1)
|
||||
if [ ! $SWARMKEY ]; then echo "FATAL ERROR:: .ipfs/swarm.key EMPTY"; exit; fi
|
||||
|
||||
##################################################################
|
||||
# G1sms+ Swarm KEYS
|
||||
##################################################################
|
||||
# G1sms Service - G1Wallet
|
||||
#
|
||||
# CLEF G1 DU SWARM
|
||||
SWARM_G1PUBKEY=$(cat "${GPATH}/g1sms.pub.key")
|
||||
SWARM_G1AUTHFILE="${GPATH}/g1sms.priv.key"
|
||||
|
||||
# CLEF G1 NODE = CLEF G1 SWARM !!
|
||||
if [[ ! -e "./g1sms.preoni.pub.key" && -f "./g1sms.priv.key" ]]; then
|
||||
log "__SUB:initkeys.sh: Linking preoni Keys to SWARM G1 Keys"
|
||||
ln -s ./g1sms.priv.key ./g1sms.preoni.priv.key
|
||||
ln -s ./g1sms.pub.key ./g1sms.preoni.pub.key
|
||||
elif [[ ! -f ./g1sms.preoni.priv.key ]]; then
|
||||
# CREATE NODE G1 KEYS AND FILES
|
||||
mkdir -p ./wallets/.$IPFSNODEID/TASK
|
||||
################################################
|
||||
# GIVE NAME TO NODE G1 WALLET: "0000diceware"
|
||||
# CREATE "preoni" KeyS & ./wallets/.Qm***/_files
|
||||
################################################
|
||||
# 4 derniers chiffres du MASTERPHONE + diceware
|
||||
PRE=${MASTERPHONE:8:4}
|
||||
ZUID=$(./shell/diceware.sh 1 | xargs)
|
||||
# Check if already existing among all swarm wallets
|
||||
while [[ $(grep -Rwl "$PRE$ZUID" ./wallets_swarm/.*/_uidna) ]]; do ZUID=$(./shell/diceware.sh 1 | xargs); done
|
||||
NODE_UIDNA="$PRE$ZUID"
|
||||
NODE_PIN=$(./shell/diceware.sh | xargs)
|
||||
|
||||
NODE_G1PUBKEY=$(./silkaj/silkaj generate_auth_file --auth-scrypt -salt="$NODE_UIDNA" -password="$NODE_PIN")
|
||||
if [[ ! $NODE_G1PUBKEY ]]; then log "PROBLEME CREATION DU WALLET G1 POUR $NODE_UIDNA = $IPFSNODEID"; exit; fi
|
||||
log "__SUB:initkeys.sh: NODE G1WALLET CESIUM: $NODE_UIDNA / $NODE_PIN CREATED..."
|
||||
|
||||
# WRITE NODE_UIDNA
|
||||
echo "$NODE_UIDNA" > "./wallets/.$IPFSNODEID/_uidna" ################# _uidna
|
||||
|
||||
############ SYSTEM MODIFY hosts & hostname ################
|
||||
# WRITE NODE uidna NAME TO /etc/hosts & .Qm*/_uidna file
|
||||
echo "127.0.0.101 $NODE_UIDNA" >> "/etc/hosts"
|
||||
echo $NODE_UIDNA > "/etc/hostname"
|
||||
############################################################
|
||||
|
||||
# BACKUP AUTHFILE FOR FOR SWARM USE (TODO: Refine Swarm, Node access): GIVES SMARM WITHDRAW ACTION
|
||||
./shell/natools.py encrypt -p $SWARM_G1PUBKEY -i "./authfile" -o "./wallets/.$IPFSNODEID/_authfile.swarm.crypt"
|
||||
|
||||
echo $NODE_G1PUBKEY > "./wallets/.$IPFSNODEID/_pub" ################# _pub
|
||||
echo $IPFSNODEID > "./wallets/.$IPFSNODEID/_ipfsid" ################# _ipfsid
|
||||
log "__SUB:initkeys.sh: [ADMIN] G1sms+ CREATE G1WALLET FOR: $IPFSNODEID: _pub = $NODE_G1PUBKEY "
|
||||
|
||||
# BACKUP $IPFSNODEID config ################# _ipfsconfig.swarm.crypt : GIVES SMARM NODE RESTORE ACTION
|
||||
./shell/natools.py encrypt -p $SWARM_G1PUBKEY -i "/home/$YOU/.ipfs/config" -o "./wallets/.$IPFSNODEID/_ipfsconfig.swarm.crypt"
|
||||
log "__SUB:initkeys.sh: [ADMIN] BACKUP IPFS NODE CONFIG to ./wallets/.$IPFSNODEID/_ipfsconfig.swarm.crypt"
|
||||
|
||||
# Cyper & Empty PIN
|
||||
echo "${NODE_PIN}" > "./wallets/.$IPFSNODEID/_pin" ################# _pin / _pin.node.crypt / _pin.gpg
|
||||
./shell/natools.py encrypt -p $NODE_G1PUBKEY -i "./wallets/.$IPFSNODEID/_pin" -o "./wallets/.$IPFSNODEID/_pin.node.crypt"
|
||||
echo "${GPGPASS}" | gpg -q --output "./wallets/.$IPFSNODEID/_pin.gpg" --yes --pinentry-mode loopback --symmetric --passphrase-fd 0 "./wallets/.$IPFSNODEID/_pin"
|
||||
echo "" > "./wallets/.$IPFSNODEID/_pin"
|
||||
|
||||
echo "314" > "./wallets/.$IPFSNODEID/_g1cents" ################# _g1cents
|
||||
echo $NANODATE > "./wallets/.$IPFSNODEID/_nanodate" ################# _nanodate
|
||||
|
||||
# SILKAJ INIT G1 NODE WALLET
|
||||
TX_IN=$(./silkaj/silkaj transaction --auth-file -file="$SWARM_G1AUTHFILE" --amount=3.24 --output=$NODE_G1PUBKEY --comment="[G1sms+] G1NODE ($ADMINPSEUDO) $NODE_UIDNA $IPFSNODEID" -y)
|
||||
TX_OUT=$(./silkaj/silkaj transaction --auth-scrypt -salt="$NODE_UIDNA" -password="$NODE_PIN" --amount=0.1 --output=$SWARM_G1PUBKEY --comment="[G1sms+] G1NODE ($ADMINPSEUDO) $NODE_UIDNA $IPFSNODEID:ACK" -y)
|
||||
|
||||
log "__SUB:initkeys.sh: [ADMIN] NODE G1sms+ $NODE_UIDNA : ls ./wallets/.$IPFSNODEID"
|
||||
gammu-smsd-inject -l TEXT "$ADMINPHONE" -text "[ADMIN] G1sms+ NODE $NODE_UIDNA ($IPFSNODEID)" 1>&2
|
||||
gammu-smsd-inject -l TEXT "$ADMINPHONE" -text "$NODE_G1PUBKEY" 1>&2
|
||||
|
||||
# CREATE preoni FILES
|
||||
mv ./authfile ./g1sms.preoni.priv.key
|
||||
echo $NODE_G1PUBKEY > ./g1sms.preoni.pub.key
|
||||
fi
|
||||
|
||||
NODE_UIDNA=$(cat "./wallets/.$IPFSNODEID/_uidna")
|
||||
## INIT NODE G1 PUB & PRIV KEY
|
||||
NODE_G1PUBKEY=$(cat "${GPATH}/g1sms.preoni.pub.key")
|
||||
NODE_G1AUTHFILE="${GPATH}/g1sms.preoni.priv.key"
|
||||
|
||||
##########################################################
|
||||
# MEMORIZE NODE NANODATE EXECUTION TIME (for ntpdate regular sync)
|
||||
if [[ -f ./wallets/.$IPFSNODEID/_nanodate ]]; then
|
||||
last=$(cat ./wallets/.$IPFSNODEID/_nanodate)
|
||||
timediff=$( echo "${NANODATE} - ${last}" | bc -l )
|
||||
# NODE TIME SYNC 600 milliards de nanosecondes = 600 s = 10 mn
|
||||
if [[ $timediff -gt 600000000000 ]]; then
|
||||
# RUN & LOG ntpdate
|
||||
log "__SUB:ntpdate pool.ntp.org: $timediff $(ntpdate pool.ntp.org)"
|
||||
export NANODATE=$(date -u +%s%N)
|
||||
fi
|
||||
echo $NANODATE > ./wallets/.$IPFSNODEID/_nanodate
|
||||
fi
|
||||
|
||||
################################################################
|
||||
#INFORM ABOUT NODE CAPACITIES
|
||||
export NODEPUB=$(cat "./wallets/.$IPFSNODEID/_pub")
|
||||
|
||||
## IS IT A SMS NODE (gammu-smsd is installed)??
|
||||
if [[ $G1SMS ]]; then
|
||||
echo $MASTERPHONE > "./wallets/.$IPFSNODEID/_sms"
|
||||
else
|
||||
if [ -f "./wallets/.$IPFSNODEID/_sms" ]; then rm -f "./wallets/.$IPFSNODEID/_sms"; fi
|
||||
fi
|
||||
|
||||
## IS THERE USB PRINTER CONNECTED?
|
||||
if [[ -e "/dev/usb/lp0" ]]; then
|
||||
log "G1CORE: IMPRESSION G1Tag ACTIF .............."
|
||||
echo $ADRESSE > "./wallets/.$IPFSNODEID/_where"
|
||||
fi
|
||||
|
||||
## IS THERE SERIAL QR CODE READER CONNECTED?
|
||||
if [[ -e "/dev/ttyACM0" ]]; then
|
||||
log "G1CORE: SCAN G1Tag ACTIF .............."
|
||||
export G1TX="YES"
|
||||
echo "/dev/ttyACM0" > "./wallets/.$IPFSNODEID/_scan"
|
||||
else
|
||||
if [ -f "./wallets/.$IPFSNODEID/_scan" ]; then rm -f "./wallets/.$IPFSNODEID/_scan"; fi
|
||||
fi
|
||||
|
||||
|
|
@ -0,0 +1,64 @@
|
|||
#!/bin/bash
|
||||
################################################################################
|
||||
# Author: Fred (support@qo-op.com)
|
||||
# Version: 0.1
|
||||
# License: AGPL-3.0 (https://choosealicense.com/licenses/agpl-3.0/)
|
||||
################################################################################
|
||||
# TODO: Before June 2020: Get "./billets/$bpath/note.authfile.GPGPASS.gpg" for automatic Payback
|
||||
# Search for old G1Billets for final CHK : Forget & Transfer G1 ?
|
||||
source ./shell/init.sh
|
||||
source ./shell/functions.sh
|
||||
|
||||
# Existence days number can be $1
|
||||
if [[ "$1" ]]; then vieux="$1"; else vieux=210; fi
|
||||
if [[ "$2" ]]; then dest="$2"; else dest=$NODE_G1PUBKEY; fi
|
||||
|
||||
echo "Recherche de G1Billets plus vieux que $vieux jours."
|
||||
Nbillets=$(find billets/ -daystart -mtime +$vieux -type f -name "*.pubkey" | wc -l)
|
||||
echo "$Nbillets G1Billets trouvés..."
|
||||
|
||||
for result in $(find billets/ -daystart -mtime +$vieux -type d -name "*"); do
|
||||
billetname=$(echo $result | cut -d '/' -f 2)
|
||||
if [[ $billetname && "$billetname" != "MEMBERS" ]]; then
|
||||
((Nbillets --))
|
||||
numero=$(echo $billetname | sed s/_/\ /g )
|
||||
creator=$(cat "$result/note.creator")
|
||||
value=$(cat "$result/note.value")
|
||||
unit=$(cat "$result/note.unit")
|
||||
pubkey=$(cat "$result/note.pubkey")
|
||||
salt=$(cat "$result/note.salt")
|
||||
secret=$(cat "$result/note.secret")
|
||||
|
||||
solde=$(/usr/local/bin/silkaj -p duniter-g1.p2p.legal:443 balance $pubkey | grep Quantitative | cut -d '=' -f 2 | cut -d ' ' -f 2)
|
||||
|
||||
# GET creator member wallet ($dest) and refund if still at initial G1 value (lost or unused BILL).
|
||||
virement=$solde
|
||||
[[ -f "$result/note.g1" ]] && initialvalue=$(cat "$result/note.g1") && if [[ $solde -eq $initialvalue ]]; then virement=$solde; else virement=1; fi
|
||||
[[ -f "$result/note.memrib" ]] && dest=$(cat "$result/memrib")
|
||||
|
||||
echo ">>> $billetname $pubkey créé par $creator, valeur initiale $virement G1 (initialement $initialvalue G1)."
|
||||
echo ">>> Virer à $dest $virement G1 du G1billet !! ID / Pass:"
|
||||
echo $numero
|
||||
echo $secret $salt
|
||||
echo "/usr/local/bin/silkaj tx --amount=\"$virement\" --output=\"$dest\""
|
||||
|
||||
if [[ "$virement" == "0.0" ]]; then
|
||||
echo "G1Billet déjà vide, suppression de $result"; rm -Rf $result;
|
||||
else
|
||||
PAY=$(/usr/local/bin/silkaj -p duniter-g1.p2p.legal:443 tx --amount="$virement" --output="$dest" --comment="[G1Billet] $numero" -y)
|
||||
if [[ ! $(echo $PAY | grep "successfully sent") ]]; then
|
||||
echo "!!!! ERREUR: $virement Something Wrong happened with $result. Moving to /tmp/ERROR_BILL_$billetname (please check or remove)"
|
||||
mkdir -p /tmp/ERROR_BILL_$billetname
|
||||
mv $result/* /tmp/ERROR_BILL_$billetname
|
||||
else
|
||||
echo $PAY
|
||||
echo "OK! On supprime $result et continue avec le billet $Nbillets"
|
||||
echo
|
||||
rm -Rf $result
|
||||
fi
|
||||
fi
|
||||
else
|
||||
echo "MEMBER:" $result
|
||||
fi
|
||||
done
|
||||
|
||||
|
|
@ -0,0 +1,85 @@
|
|||
#!/usr/bin/env python3
|
||||
|
||||
import os, sys, duniterpy.key, libnacl.sign
|
||||
|
||||
def getargv(arg:str, default:str="", n:int=1, args:list=sys.argv) -> str:
|
||||
if arg in args and len(args) > args.index(arg)+n:
|
||||
return args[args.index(arg)+n]
|
||||
else:
|
||||
return default
|
||||
|
||||
def read_data(data_path, b=True):
|
||||
if data_path == "-":
|
||||
if b:
|
||||
return sys.stdin.read().encode()
|
||||
else:
|
||||
return sys.stdin.read()
|
||||
else:
|
||||
if b:
|
||||
return open(os.path.expanduser(data_path), "rb").read()
|
||||
else:
|
||||
return open(os.path.expanduser(data_path), "r").read()
|
||||
|
||||
def write_data(data, result_path):
|
||||
(sys.stdout if result_path == "-" else open(os.path.expanduser(result_path), "wb")).write(data)
|
||||
|
||||
def encrypt(data, pubkey):
|
||||
return duniterpy.key.PublicKey(pubkey).encrypt_seal(data)
|
||||
|
||||
def decrypt(data, privkey):
|
||||
return duniterpy.key.SigningKey.from_seedhex(privkey).decrypt_seal(data)
|
||||
|
||||
def sign(data, privkey):
|
||||
return duniterpy.key.SigningKey.from_seedhex(privkey).sign(data)
|
||||
|
||||
def verify(data, pubkey):
|
||||
try:
|
||||
return libnacl.sign.Verifier(duniterpy.key.PublicKey(pubkey).hex_pk()).verify(data)
|
||||
except ValueError:
|
||||
exit(1)
|
||||
|
||||
def show_help():
|
||||
print("""Usage:
|
||||
python3 natools.py <command> [options]
|
||||
|
||||
Commands:
|
||||
encrypt Encrypt data
|
||||
decrypt Decrypt data
|
||||
sign Sign data
|
||||
verify Verify data
|
||||
|
||||
Options:
|
||||
-i <path> Input file path (default: -)
|
||||
-k <path> Privkey file path (default: authfile.key)
|
||||
-p <str> Pubkey (base58)
|
||||
-o <path> Output file path (default: -)
|
||||
|
||||
Note: "-" means stdin or stdout.
|
||||
""")
|
||||
|
||||
if __name__ == "__main__":
|
||||
|
||||
if "--help" in sys.argv:
|
||||
show_help()
|
||||
exit()
|
||||
|
||||
data_path = getargv("-i", "-")
|
||||
privkey_path = getargv("-k", "authfile.key")
|
||||
pubkey = getargv("-p")
|
||||
result_path = getargv("-o", "-")
|
||||
|
||||
try:
|
||||
if sys.argv[1] == "encrypt":
|
||||
write_data(encrypt(read_data(data_path), pubkey), result_path)
|
||||
elif sys.argv[1] == "decrypt":
|
||||
write_data(decrypt(read_data(data_path), read_data(privkey_path, False)), result_path)
|
||||
elif sys.argv[1] == "sign":
|
||||
write_data(sign(read_data(data_path), read_data(privkey_path, False)), result_path)
|
||||
elif sys.argv[1] == "verify":
|
||||
write_data(verify(read_data(data_path), pubkey), result_path)
|
||||
else:
|
||||
show_help()
|
||||
except Exception as e:
|
||||
sys.stderr.write("Error: ", e, "\n")
|
||||
show_help()
|
||||
exit(1)
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
duniter.moul.re:443
|
||||
duniter.dethegeek.eu.org:443
|
||||
g1.presles.fr:443
|
||||
g1.duniter.fr:443
|
||||
monit.g1.nordstrom.duniter.org:443
|
||||
g1.le-sou.org:443
|
||||
g1.duniter.org:443
|
||||
g1.monnaielibreoccitanie.org:443
|
||||
follow.the.white-rabbit.net:443
|
||||
g1.acostey.fr:443
|
||||
duniter.acostey.fr:443
|
||||
|
|
@ -0,0 +1,12 @@
|
|||
#!/bin/bash
|
||||
f=$(echo "$1" | sed 's/ //g' )
|
||||
echo "parle.sh: $1 | $2 = $f" >> /tmp/parle.log 2>&1
|
||||
if [[ "$2" == "" ]]; then
|
||||
lang="fr-FR"
|
||||
else
|
||||
lang="en-US"
|
||||
fi
|
||||
if [[ ! -f "/tmp/$lang_${f}.wav" ]]; then
|
||||
pico2wave -l $lang -w /tmp/$lang_${f}.wav "$1"
|
||||
fi
|
||||
aplay -q /tmp/$lang_${f}.wav
|
||||
|
|
@ -0,0 +1,49 @@
|
|||
#!/bin/bash
|
||||
##################################################################
|
||||
# Author: Fred (support@qo-op.com)
|
||||
# Version: 0.1
|
||||
# License: GPL (http://www.google.com/search?q=GPL)
|
||||
##################################################################
|
||||
# Commande SMS: sms_ABO.sh
|
||||
# ABO "$SERVICE" "$YESNO"
|
||||
# Gère les Abonnements aux communications PUSH SMS
|
||||
##################################################################
|
||||
# TODO: Create information Channels and moderate OPT IN/OUT
|
||||
source ./shell/init.sh
|
||||
source ./shell/functions.sh
|
||||
log "__SUB:sms_ABO.sh: START ($1=PHONE, $2=SERVICE)"
|
||||
PHONE=$1
|
||||
SERVICE=$2
|
||||
|
||||
sms_INIT_ACCOUNT "$PHONE"
|
||||
|
||||
case "$SERVICE" in
|
||||
ON)
|
||||
log "Abonnement Kalkun"
|
||||
add_contact $PHONE $MEMBER && log "${c_green}Contact has been added to database$c_" || log "${c_red}Contact can't be added to database$c_";
|
||||
sms_SEND "$PHONE" "$MEMBER votre inscription annuaire est active"
|
||||
;;
|
||||
OFF)
|
||||
log "Retrait Kalkun"
|
||||
rm_contact $PHONE $MEMBER && log "${c_green}Contact has been deleted from database$c_" || log "${c_red}Contact can't be deleted database$c_";
|
||||
sms_SEND "$PHONE" "$MEMBER retrait annuaire prise en compte..."
|
||||
;;
|
||||
|
||||
MARCHE)
|
||||
log "Avertissement G1 marchés"
|
||||
# PARAMS could be "$distance" to Member GeoPoint...
|
||||
;;
|
||||
GCHANGE)
|
||||
log "Création Alerte Annonce GCHANGE"
|
||||
# PARAMS could be "$distance#$keyword" to search gchange.fr near Member GeoPoint...
|
||||
;;
|
||||
INFO)
|
||||
log "Abonnement Newsletter"
|
||||
# PARAMS could be "$distance#$keyword" to search gchange.fr near Member GeoPoint...
|
||||
;;
|
||||
*)
|
||||
# AIDE : ABO GCHANGE 100#maison...
|
||||
log "Renvoyez AIDE..."
|
||||
sms_SEND "$PHONE" "Cette commande est inactive..."
|
||||
;;
|
||||
esac
|
||||
|
|
@ -0,0 +1,89 @@
|
|||
#!/bin/bash
|
||||
################################################################################
|
||||
# Author: Fred (support@qo-op.com)
|
||||
# Version: 0.1
|
||||
# License: AGPL-3.0 (https://choosealicense.com/licenses/agpl-3.0/)
|
||||
################################################################################
|
||||
# Accessible seulement pour ADMINPHONE.
|
||||
# Permet de lancer des paquets de SMS aux membres, wallets, ...
|
||||
# TODO Add OptIN/OUT options (./shell/sms_ABO.sh) + Extand ADMIN functions...
|
||||
source ./shell/init.sh
|
||||
source ./shell/functions.sh
|
||||
log "__SUB:sms_ADMIN.sh: START ($1=CMD, $2=MESSAGE)"
|
||||
|
||||
CMD="$1"
|
||||
MESSAGE="$2"
|
||||
|
||||
case "$CMD" in
|
||||
|
||||
USR)
|
||||
log "__SUB:sms_ADMIN.sh: Send message to phone Member or Wallet UIDNA"
|
||||
# Get it from first MESSAGE message word...
|
||||
towoo=$(echo $MESSAGE | cut -d ' ' -f 1)
|
||||
|
||||
SEARCH=$(grep -Rwl "$towoo" ./wallets_swarm/*/*.uidna* | tail -n 1 | cut -f 3 -d '/')
|
||||
if [[ "$SEARCH" != "" ]]; then
|
||||
REMOTENODE=$(cat ./wallets_swarm/$SEARCH/MASTERPHONE.sms)
|
||||
DESTRIB=$(cat ./wallets_swarm/$SEARCH/$SEARCH.pub)
|
||||
DESTPHONE=$SEARCH
|
||||
log "__SUB:sms_ADMIN.sh: FOUND $towoo on NODE ($REMOTENODE) G1sms+ wallet: $DESTRIB : $DESTPHONE)"
|
||||
|
||||
if [[ "$DESTPHONE" == "$ADMINPHONE" || "$DESTPHONE" == "$MASTERPHONE" ]]; then continue; fi
|
||||
sms_SEND "$DESTPHONE" "$MESSAGE"
|
||||
sms_SEND "$ADMINPHONE" "ADMIN OK!! Message: $MESSAGE envoyé à $towoo: $DESTPHONE"
|
||||
fi
|
||||
;;
|
||||
|
||||
|
||||
MEM)
|
||||
log "__SUB:sms_ADMIN.sh: Send $MESSAGE message to All NODE members"
|
||||
for f in ./wallets/*/*.uidname; do
|
||||
uid=$(cat $f);
|
||||
num=$(echo $f | cut -d '/' -f3);
|
||||
if [[ "$num" == "$ADMINPHONE" || "$num" == "$MASTERPHONE" ]]; then continue; fi
|
||||
log "__SUB:sms_ADMIN.sh: Send SMS to $num: $uid"
|
||||
sms_SEND "$num" "$uid, $MESSAGE"
|
||||
sleep 5
|
||||
done
|
||||
sms_SEND "$ADMINPHONE" "ADMIN! Message envoyé aux $(cat ./wallets/*/*.uidname | wc -l) membres de ce NODE"
|
||||
;;
|
||||
|
||||
ALL)
|
||||
log "__SUB:sms_ADMIN.sh: Send $MESSAGE message to All NODE G1sms wallets"
|
||||
for f in ./wallets/*; do
|
||||
num=$(echo $f | cut -d '/' -f3);
|
||||
if [[ "$num" == "$ADMINPHONE" || "$num" == "$MASTERPHONE" ]]; then continue; fi
|
||||
log "__SUB:sms_ADMIN.sh: Send SMS to $num"
|
||||
sms_SEND "$num" "$MESSAGE"
|
||||
sleep 5
|
||||
done
|
||||
sms_SEND "$ADMINPHONE" "ADMIN! Message envoyé aux $(ls ./wallets/ | cut -d '/' -f3 | wc -l) possesseur de G1sms Wallets de ce NODE"
|
||||
;;
|
||||
|
||||
SWARM)
|
||||
log "__SUB:sms_ADMIN.sh: Send $MESSAGE message to All SWARM G1sms wallets"
|
||||
for f in ./wallets_swarm/+33*; do
|
||||
num=$(echo $f | cut -d '/' -f3);
|
||||
if [[ "$num" == "$ADMINPHONE" || "$num" == "$MASTERPHONE" ]]; then continue; fi
|
||||
log "__SUB:sms_ADMIN.sh: Send SMS to $num"
|
||||
sms_SEND "$num" "$MESSAGE"
|
||||
sleep 5
|
||||
done
|
||||
sms_SEND "$ADMINPHONE" "ADMIN! Message: $MESSAGE envoyé aux $(ls ./wallets_swarm/ | cut -d '/' -f3 | wc -l) PHONE G1sms Wallets du SWARM"
|
||||
;;
|
||||
|
||||
*)
|
||||
log "__SUB:sms_ADMIN.sh: Send back ERRORs message to Admin"
|
||||
if [ -f "/tmp/ERROR.CRON" ]; then
|
||||
text=$(cat "/tmp/ERROR.CRON")
|
||||
rm -f "/tmp/ERROR.CRON"
|
||||
fi
|
||||
sms_SEND "$ADMINPHONE" "USR / MEM / ALL / SWARM
|
||||
$text"
|
||||
;;
|
||||
esac
|
||||
|
||||
sms_SEND "$ADMINPHONE" "ADMIN! JOB FINISHED"
|
||||
|
||||
log "__SUB:sms_ADMIN.sh: END ~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
|
||||
exit
|
||||
|
|
@ -0,0 +1,33 @@
|
|||
#!/bin/bash
|
||||
################################################################################
|
||||
# Author: Fred (support@qo-op.com)
|
||||
# Version: 0.1
|
||||
# License: AGPL-3.0 (https://choosealicense.com/licenses/agpl-3.0/)
|
||||
################################################################################
|
||||
source ./shell/init.sh
|
||||
source ./shell/functions.sh
|
||||
log "X sms_AIDE.sh ($1=phone)"
|
||||
|
||||
sms_INIT_ACCOUNT "$1" "NOSMS"
|
||||
|
||||
MESS="[Aide]
|
||||
N Pseudo (membre ou nom de portefeuille) : Création portefeuille
|
||||
U G1/DU/LOVE : Unité
|
||||
S : Solde
|
||||
P 06nnnnnnnn 300 : Payer 300 à 06nnnnnnnn"
|
||||
# Send response SMS
|
||||
sms_SEND "$1" "$MESS"
|
||||
|
||||
MESS="EMAIL moi@email : Indiquer son email
|
||||
VIR 50 Pseudo : Virer 50 à Pseudo (membre ou Portefeuille SMS)"
|
||||
sms_SEND "$1" "$MESS"
|
||||
|
||||
MESS="REC 50 Dest S 4 : Virer 50 à Dest pendant 4 Semaines (J/S/M/A)
|
||||
BILL n : Recevoir 6 G1Billets remplis de n LOVE par email!
|
||||
https://g1sms.fr - $ADMINPSEUDO ($ADMINPHONE)"
|
||||
sms_SEND "$1" "$MESS"
|
||||
|
||||
log "END sms_AIDE.sh"
|
||||
log "~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
|
||||
|
||||
exit
|
||||
|
|
@ -0,0 +1,180 @@
|
|||
#!/bin/bash
|
||||
################################################################################
|
||||
# Author: Fred (support@qo-op.com)
|
||||
# Version: 0.1
|
||||
# License: AGPL-3.0 (https://choosealicense.com/licenses/agpl-3.0/)
|
||||
################################################################################
|
||||
# Create and print 6 G1Billets de nn LOVE
|
||||
source ./shell/init.sh
|
||||
source ./shell/functions.sh
|
||||
log "__SUB:sms_BILLET.sh: ($1=phone, $2=VALbillet)"
|
||||
|
||||
phone="$1"
|
||||
VALbillet="$2"
|
||||
# 6 BILLETS DE $VALbillet LOVE PAR SMS !!
|
||||
NBbillets=6
|
||||
|
||||
# Initialise PHONE, PIN, PUBKEY, UNIT, HIST + MEMBER + MEMRIB +...
|
||||
sms_INIT_ACCOUNT "$phone" "NOSMS"
|
||||
|
||||
# FIXED LOVE UNIT (6 month maximum validity)
|
||||
UNIT="LOVE"
|
||||
|
||||
log "__SUB:sms_BILLET.sh: MEMBER? $PHONE => $MEMBER"
|
||||
|
||||
if [[ $UNKNOWN == "unknown" || "$MEMBER" == "" ]]; then
|
||||
sms_ERROR "$phone" "Porte-monnaie non identifié.
|
||||
Envoyez N suivi de votre pseudo membre (en respectant Majuscule et minuscule)."
|
||||
exit
|
||||
fi
|
||||
|
||||
if [[ $MAIL == "" ]]; then
|
||||
sms_ERROR "$phone" "Impossible de réaliser votre commande.
|
||||
Envoyez \"EMAIL votre_email\" pour pouvoir recevoir vos billets..."
|
||||
exit
|
||||
fi
|
||||
|
||||
if [ $VALbillet -lt 10 ]; then
|
||||
sms_ERROR "$phone" "Montant minimum 10 $UNIT !!"
|
||||
exit
|
||||
fi
|
||||
|
||||
if [ $VALbillet -gt 1000 ]; then
|
||||
sms_ERROR "$phone" "Montant maximum: 1000 $UNIT !!"
|
||||
exit
|
||||
fi
|
||||
|
||||
# Get AMOUNTG1, AMOUNTLOVE, AMOUNTDU
|
||||
AMOUNTG1=$(./silkaj/silkaj amount "$PUBKEY")
|
||||
AMOUNTDU=$(bc -l <<< "scale=2; $AMOUNTG1 / $DUFACTOR")
|
||||
AMOUNTLOVE=$(bc -l <<< "scale=0; $AMOUNTG1 * 100 / $DUFACTOR")
|
||||
|
||||
# Convert amount to G1 unit
|
||||
amount=$(bc <<< "$NBbillets * $VALbillet")
|
||||
VIR=$(bc -l <<< "scale=2; $amount * $DUFACTOR / 100")
|
||||
|
||||
# Need at least $MIN G1 available! $BILLCOM G1 commission
|
||||
MIN=$(bc -l <<< "$AMOUNTG1 - $LIMIT - $BILLCOM")
|
||||
testmin=$( echo "${VIR} < ${MIN}" | bc -l )
|
||||
log "__SUB:sms_BILLET.sh: TEST : $VIR < $MIN ? $testmin"
|
||||
|
||||
# silkaj NODE CHANGE !!!
|
||||
#SILKAJNODE=$(./shell/checknodes.sh)
|
||||
#log "NEW SILKAJ NODE: $SILKAJNODE"
|
||||
|
||||
if [[ "$testmin" -eq "1" ]]
|
||||
then
|
||||
# Clean MEMBER directory
|
||||
rm -f ./billets/MEMBERS/$MEMBER/*.jpg
|
||||
boucle=0;
|
||||
while [ $boucle -lt $NBbillets ]
|
||||
do
|
||||
# Creation du numéro de billet
|
||||
NUMBER=$(./shell/diceware.sh 2 | xargs)
|
||||
bpath=$(echo $NUMBER | sed 's/ /_/g')
|
||||
|
||||
# Cas d'un billet existant
|
||||
while [ -d "./billets/$bpath" ]
|
||||
do
|
||||
NUMBER=$(./shell/diceware.sh 2 | xargs)
|
||||
bpath=$(echo $NUMBER | sed 's/ /_/g')
|
||||
done
|
||||
|
||||
SECRET=$(./shell/diceware.sh 4 | xargs)
|
||||
|
||||
boucle=$(bc -l <<< "$boucle + 1")
|
||||
|
||||
log "__SUB:sms_BILLET.sh: ->BILLET:$PHONE:$NUMBER:$VALbillet:$UNIT"
|
||||
# CREATE "NUMBER SECRET" ACCOUNT for G1 transfert
|
||||
TRANSAC=$(bc -l <<< "scale=2; $VIR / $NBbillets")
|
||||
BILLETPUBKEY=$(./silkaj/silkaj generate_auth_file --auth-scrypt -salt="$NUMBER" -password="$SECRET")
|
||||
# COPY authfile for Usage in 6 month...
|
||||
log "__SUB:sms_BILLET.sh: authfile KEY : ./billets/$bpath/note.authfile.GPGPASS.gpg"
|
||||
mkdir -p "./billets/$bpath"
|
||||
echo "${GPGPASS}" | gpg -q --output "./billets/$bpath/note.authfile.GPGPASS.gpg" --yes --pinentry-mode loopback --symmetric --passphrase-fd 0 "./authfile"
|
||||
./shell/natools.py encrypt -p $NODE_G1PUBKEY -i "./authfile" -o "./billets/$bpath/note.authfile.$NODE_UIDNA.crypt"
|
||||
rm -f "./authfile"
|
||||
|
||||
log_history $PHONE "G1BILLET, $TRANSAC, $BILLETPUBKEY"
|
||||
sleep 3
|
||||
# Fill BILLET with TRANSAC amount
|
||||
PAY=$(./silkaj/silkaj transaction --auth-scrypt -salt="$PHONE" -password="$PIN" --amount="$TRANSAC" --output="$BILLETPUBKEY" --comment="G1Billet $NUMBER" -y)
|
||||
if [[ "$(echo $PAY | cut -d '|' -f 1)" != "KO" ]]; then
|
||||
# NOTES ARE FILES STORED IN DICEWARE COMPOSED SUBDIR
|
||||
echo "$(date +%Y%m%d)" > "./billets/$bpath/note.creationdate"
|
||||
echo "$MEMBER" > "./billets/$bpath/note.creator"
|
||||
echo "$MEMRIB" > "./billets/$bpath/note.memrib"
|
||||
echo "$NUMBER" > "./billets/$bpath/note.number"
|
||||
echo "$PHONE" > "./billets/$bpath/note.phone"
|
||||
echo "$SECRET" > "./billets/$bpath/note.secret"
|
||||
echo "$VALbillet" > "./billets/$bpath/note.love"
|
||||
echo "$TRANSAC" > "./billets/$bpath/note.g1"
|
||||
echo "$BILLETPUBKEY" > "./billets/$bpath/note.pubkey"
|
||||
log "Remplissage: $TRANSAC G1... $BILLETPUBKEY = $PAY"
|
||||
|
||||
# CREATION FICHIER IMAGE BILLET
|
||||
$(./shell/sms_BILLET_MAKE.sh "$NUMBER" "$SECRET" "$VALbillet" "$UNIT" "$TRANSAC" "$BILLETPUBKEY" "$MEMBER" "$TRANSAC" "$PHONE")
|
||||
log "./shell/sms_BILLET_MAKE.sh \"$NUMBER\" \"$SECRET\" \"$VALbillet\" \"$UNIT\" \"$TRANSAC\" \"$BILLETPUBKEY\" \"$MEMBER\" \"$TRANSAC\" \"$PHONE\""
|
||||
|
||||
# Transaction to create Link BILLET <-> MEMBER RIB => Decrease BILLET value !
|
||||
sleep 2
|
||||
# PAY=$(./silkaj/silkaj transaction --auth-scrypt -salt="$NUMBER" -password="$SECRET" --amount="0.05" --output="$MEMRIB" --comment="THIRD_PARTY_MANAGER:$NODE_G1PUBKEY:G1SMS:BILLET:$VALbillet:$UNIT:$NUMBER" -y)
|
||||
else
|
||||
sms_ERROR "$PHONE" "Un problème est survenu. Contactez $ADMINPSEUDO au $ADMINPHONE"
|
||||
# Copy & Send produced files
|
||||
zip /tmp/$PHONE_Bills_$bpath.zip ./billets/MEMBERS/$MEMBER/*.*
|
||||
mpack -s "[G1sms+]_G1Billets ($bpath) Erreur... création G1Billets..." -d /tmp/message_body.txt /tmp/$PHONE_Bills_$bpath.zip $MAIL && mv /tmp/$PHONE_Bills_$bpath.zip ./billets/MEMBERS/$MEMBER/ && log "__SUB:sms_BILLET.sh: ALERT sent....."
|
||||
|
||||
log "__SUB:sms_BILLET.sh: ERROR SILKAJ $(cat ./silkaj/src/constants.py)"
|
||||
exit
|
||||
fi
|
||||
done
|
||||
|
||||
# + G1SMS Commission
|
||||
sleep 2
|
||||
COM=$(./silkaj/silkaj transaction --auth-scrypt -salt="$PHONE" -password="$PIN" --amount="$BILLCOM" --output="$NODE_G1PUBKEY" --comment="[G1sms+] Achat G1Billets" -y)
|
||||
|
||||
# POUR IMPRIMER LES BILLETS! Brancher votre imprimante, configurer cups, activer code lp ;)
|
||||
num=$(date +%Y%m%d)
|
||||
log "__SUB:sms_BILLET.sh: PRINT $num $MEMBER"
|
||||
montage ./billets/MEMBERS/$MEMBER/*.jpg -tile 2x3 -geometry 964x459 /tmp/$PHONE_Bills_$bpath.pdf && rm -f ./billets/MEMBERS/$MEMBER/*.jpg && log "__SUB:sms_BILLET.sh: PDF made /tmp/$PHONE_Bills_$bpath.pdf"
|
||||
cd /tmp && zip $PHONE_Bills_$bpath.zip $PHONE_Bills_$bpath.pdf && log "__SUB:sms_BILLET.sh: Zip DONE :: /tmp$PHONE_Bills_$bpath.zip !!" && cd -
|
||||
# rm -f /tmp/$PHONE_Bills_$bpath.pdf
|
||||
|
||||
# SEND EMAIL ZIP attached
|
||||
echo "Commande #$NANODATE/$bpath
|
||||
>> Planche de 6 G1Billets : $VALbillet LOVE <<
|
||||
Envoyez-nous vos remarques...
|
||||
|
||||
https://g1sms.fr" > /tmp/message_body.txt
|
||||
|
||||
mpack -s "[G1sms+]_G1Billets ($bpath) A IMPRIMER et détruire cet email..." -d /tmp/message_body.txt /tmp/$PHONE_Bills_$bpath.zip $MAIL && log "__SUB:sms_BILLET.sh: EMAIL sent....."
|
||||
|
||||
log "__SUB:sms_BILLET.sh: G1Billets $PHONE_Bills_$bpath.pdf envoyé par email à $MEMBER : $MAIL "
|
||||
mess="[G1SMS]
|
||||
$NBbillets G1Billets de $VALbillet $UNIT ($TRANSAC G1) créé(s).
|
||||
Envoyés vers $MAIL, vérifiez vos SPAM...
|
||||
Support: $ADMINPSEUDO ($ADMINPHONE)
|
||||
"
|
||||
|
||||
sms_SEND "$phone" "$mess"
|
||||
# ADMIN ALERT SMS + TODO Add ADMINEMAIL parameter in "install.sh"
|
||||
sms_SEND "$ADMINPHONE" "$MEMBER vient de créer $NBbillets G1Billets de $VALbillet $UNIT ($TRANSAC G1): $MAIL"
|
||||
cat ./email.txt | sed s/EMAIL/frenault@linkeo.com/g | sed s/SUBJECT/Creation_G1Billets/g | sed s/MESSAGE/"$MEMBER ($PHONE) vient de creer $NBbillets G1Billets de $VALbillet $UNIT ($TRANSAC G1) vers $MAIL"/g | ssmtp "frenault@linkeo.com"
|
||||
|
||||
#####################################
|
||||
# Amount too High, solde insuffisant
|
||||
else
|
||||
text="Solde: $AMOUNTLOVE LOVE ($AMOUNTG1 G1 = $AMOUNTDU DU)
|
||||
Insuffisant pour créer $NBbillets billet(s) de $VALbillet $UNIT
|
||||
(= $VIR G1 + Commission $BILLCOM G1)"
|
||||
sms_ERROR "$phone" "$text"
|
||||
|
||||
sms_SEND "$phone" "Rechargez votre porte-monnaie!
|
||||
https://g1.duniter.fr/api/#/v1/payment/$PUBKEY?amount=$VIR"
|
||||
fi
|
||||
|
||||
log "__SUB:sms_BILLET.sh: END sms_BILLET.sh"
|
||||
log "~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
|
||||
|
||||
exit
|
||||
|
|
@ -0,0 +1,76 @@
|
|||
#!/bin/bash
|
||||
# If 4 words provided => Check if Billet exists and return BILLET AMOUNT VALUE
|
||||
# If 7 words provided => if Billet exists, transfer AMOUNT to PHONE & destroy BILLET
|
||||
# License: AGPL-3.0 (https://choosealicense.com/licenses/agpl-3.0/)
|
||||
source ./shell/init.sh
|
||||
source ./shell/functions.sh
|
||||
log "X sms_BILLETCHK.sh $0"
|
||||
|
||||
PHONE="$1"
|
||||
CODE="$2 $3"
|
||||
SEC="$4 $5 $6 $7"
|
||||
|
||||
# Construct billet path
|
||||
bpath=$(echo "$CODE" | sed 's/ /_/g')
|
||||
|
||||
if [ -d "./billets/$bpath" ]
|
||||
then
|
||||
SECRET=$(cat "./billets/$bpath/note.secret")
|
||||
SALT=$(cat "./billets/$bpath/note.salt")
|
||||
VALbillet=$(cat "./billets/$bpath/note.value")
|
||||
UNIT=$(cat "./billets/$bpath/note.unit")
|
||||
BILLETPUBKEY=$(cat "./billets/$bpath/note.pubkey")
|
||||
|
||||
AMOUNTG1=$(./silkaj/silkaj amount "$BILLETPUBKEY")
|
||||
log "Billet: $AMOUNTG1 ($VALbillet $UNIT): $BILLETPUBKEY"
|
||||
|
||||
# NO GOOD SECRET
|
||||
if [[ "$SEC" != "$SECRET" ]]; then
|
||||
# SEND ACTUAL BILLET VALUE
|
||||
mess="[G1SMS]
|
||||
Billet de $VALbillet $UNIT Valide!
|
||||
Valeur: $AMOUNTG1 G1
|
||||
https://www.g1sms.fr/contact"
|
||||
sms_SEND "$PHONE" "$mess"
|
||||
log "BILLETCHK: $VALbillet $UNIT ($AMOUNTG1 G1)"
|
||||
log_history $PHONE "BILLET_CHK, $AMOUNTG1, $bpath"
|
||||
else
|
||||
# TRANSFER & DESTROY
|
||||
sms_INIT_ACCOUNT "$PHONE" "NOSMS"
|
||||
if [[ "$UNKNOWN" == "unknown" ]]; then
|
||||
# Account creation
|
||||
sms_INIT_ACCOUNT "$PHONE"
|
||||
fi
|
||||
log "./silkaj/silkaj transaction --auth-scrypt -salt=\"$CODE\" -password=\"$SEC$SALT\" --amount=\"$AMOUNTG1\" --output=\"$PUBKEY\" --comment=\"THIRD_PARTY_MANAGER:$NODE_G1PUBKEY:G1SMS:ENCAISSEMENT:$CODE\" -y"
|
||||
PAY=$(./silkaj/silkaj transaction --auth-scrypt -salt="$CODE" -password="$SEC$SALT" --amount="$AMOUNTG1" --output="$PUBKEY" --comment="THIRD_PARTY_MANAGER:$NODE_G1PUBKEY:ENCAISSEMENT:$CODE" -y)
|
||||
|
||||
if [[ "$(echo $PAY | cut -d '|' -f 1)" != "KO" ]]; then
|
||||
# DESTROY BILLET
|
||||
rm -Rf ./billets/$bpath
|
||||
# DESTROY PUBLIC CACHE in /tmp
|
||||
if [ -d "/tmp/billets_valides/$bpath" ]; then
|
||||
rm -Rf /tmp/billets_valides/$bpath
|
||||
fi
|
||||
|
||||
SOLDE=$(./silkaj/silkaj amount "$PUBKEY")
|
||||
|
||||
mess="[G1SMS]
|
||||
ENCAISSEMENT de $VALbillet $UNIT ($AMOUNTG1 G1)
|
||||
dans portefeuille $UIDNA ($PHONE)
|
||||
OK!
|
||||
Solde: $SOLDE G1"
|
||||
sms_SEND "$PHONE" "$mess"
|
||||
log "BILLETCHK DESTROY: $VALbillet $UNIT ($AMOUNTG1 G1)"
|
||||
log "=> $PUBKEY"
|
||||
log_history $PHONE "BILLET_CHK, $AMOUNTG1, $bpath, $PUBKEY"
|
||||
else
|
||||
sms_ERROR "$PHONE" "Erreur! Transaction Impossible! Valeur du G1Billet $AMOUNTG1 G1. Contactez $ADMINPSEUDO : $ADMINPHONE"
|
||||
fi
|
||||
fi
|
||||
else
|
||||
sms_SEND "$PHONE" "BILLET \"$CODE\" INCONNU !!"
|
||||
log_history $PHONE "BILLET_CHK, ERROR, $bpath"
|
||||
fi
|
||||
|
||||
log "END sms_BILLETCHK.sh"
|
||||
log "~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
|
||||
|
|
@ -0,0 +1,129 @@
|
|||
#!/bin/bash
|
||||
# Make Billet fabrique l'image de 6 billets de monnaie libre
|
||||
# Date de validité de 6 mois à compter du premier jour du mois courant
|
||||
############################################################################
|
||||
# INSTALLER convert et qrencode: sudo apt install imagemagick qrencode
|
||||
# IMPRIMANTE (http://smspi:631/) : sudo apt install printer-driver-all cups
|
||||
# https://junise.wordpress.com/2015/04/12/install-online-cups-printer-in-raspberry-pi/
|
||||
############################################################################
|
||||
# License: AGPL-3.0 (https://choosealicense.com/licenses/agpl-3.0/)
|
||||
# TEST:
|
||||
# ./shell/sms_BILLET_MAKE.sh "nu me ro test" "se cr et" 100 LOVE 10.04 "https://g1sms.fr" G1SMS TEST
|
||||
############################################################################
|
||||
source "./shell/init.sh"
|
||||
source "./shell/functions.sh"
|
||||
|
||||
NUMERO="$1"
|
||||
SECRET="$2"
|
||||
MONTANT="$3"
|
||||
UNIT="$4"
|
||||
JUNE="$5"
|
||||
NOTERIB="$6"
|
||||
MEMBER="$7"
|
||||
TRANSAC="$8"
|
||||
PHONE="$9"
|
||||
log "X sudo ./shell/sms_BILLET_MAKE.sh \"$1\" \"$2\" \"$3\" \"$4\" \"$5\" \"$6\" \"$7\" \"$8\""
|
||||
|
||||
if [[ "$NOTERIB" == "" || "$MEMBER" == "" ]]
|
||||
then
|
||||
log "ERROR MAKE BILLET"
|
||||
exit
|
||||
fi
|
||||
|
||||
# VALIDITY? Calculate 6 month period dates
|
||||
cm=$(date +%m)
|
||||
cy=$(date +%Y)
|
||||
valid=$(bc <<< "$cm + 6")
|
||||
if [ $valid -gt 12 ]
|
||||
then
|
||||
valid=$(bc <<< "$valid - 12")
|
||||
year=$(bc <<< "$cy + 1")
|
||||
else
|
||||
year=$cy
|
||||
fi
|
||||
valid="0${valid:0:2}"
|
||||
# ADD VALIDITY to convert: -pointsize 20 -draw 'text 380,410 "'"A encaisser avant le 01/$valid/$year"'"' \
|
||||
|
||||
# ADD Avatar on G1 Logo SouthEast
|
||||
if [[ $(file "./wallets/$PHONE/$PHONE.avatar.png" | grep 'PNG') ]]; then
|
||||
composite -compose Over -gravity East -geometry +15+0 -dissolve 33% "./wallets/$PHONE/$PHONE.avatar.png" "./shell/Oeuro.jpg" "/tmp/$NUMERO.jpg"
|
||||
composite -compose Over -gravity West -geometry +15+0 -dissolve 33% "./wallets/$PHONE/$PHONE.avatar.png" "/tmp/$NUMERO.jpg" "/tmp/$NUMERO.jpg"
|
||||
else
|
||||
composite -compose Over -gravity East -geometry +15+0 -dissolve 33% "./shell/G1Anar.png" "./shell/Oeuro.jpg" "/tmp/$NUMERO.jpg"
|
||||
composite -compose Over -gravity West -geometry +15+0 -dissolve 33% "./shell/G1Anar.png" "/tmp/$NUMERO.jpg" "/tmp/$NUMERO.jpg"
|
||||
fi
|
||||
|
||||
# Add G1Billet_LOVE.png logo (250px)
|
||||
composite -compose Over -gravity SouthWest -geometry +50+50 -dissolve 70% "./shell/G1Billet_LOVE.png" "/tmp/$NUMERO.jpg" "/tmp/$NUMERO.jpg"
|
||||
|
||||
# Prepare BILLET qrcode verification URL
|
||||
qrencode -s 3 -o "/tmp/$NUMERO_NOTERIB.png" "$NOTERIB"
|
||||
|
||||
# BILL PUBKEY means Someone can Add amount to it !!!
|
||||
# Add verification QRCode
|
||||
composite -compose Over -gravity NorthEast -geometry +50+25 "/tmp/$NUMERO_NOTERIB.png" "/tmp/$NUMERO.jpg" "/tmp/$NUMERO.jpg"
|
||||
|
||||
# Add June logo
|
||||
case "$MONTANT" in
|
||||
10)
|
||||
convert "./shell/g1.png" -fuzz 20% -fill grey -opaque '#e5912b' "/tmp/g1.png"
|
||||
;;
|
||||
20)
|
||||
convert "./shell/g1.png" -fuzz 20% -fill green -opaque '#e5912b' "/tmp/g1.png"
|
||||
;;
|
||||
50)
|
||||
convert "./shell/g1.png" -fuzz 20% -fill orange -opaque '#e5912b' "/tmp/g1.png"
|
||||
;;
|
||||
100)
|
||||
convert "./shell/g1.png" -fuzz 20% -fill blue -opaque '#e5912b' "/tmp/g1.png"
|
||||
;;
|
||||
200)
|
||||
convert "./shell/g1.png" -fuzz 20% -fill purple -opaque '#e5912b' "/tmp/g1.png"
|
||||
;;
|
||||
500)
|
||||
convert "./shell/g1.png" -fuzz 20% -fill red -opaque '#e5912b' "/tmp/g1.png"
|
||||
;;
|
||||
1000)
|
||||
convert "./shell/g1.png" -fuzz 20% -fill black -opaque '#e5912b' "/tmp/g1.png"
|
||||
;;
|
||||
*)
|
||||
cp "./shell/g1.png" "/tmp/g1.png"
|
||||
;;
|
||||
esac
|
||||
composite -compose Over -gravity SouthEast -geometry +20+20 -dissolve 90% "/tmp/g1.png" "/tmp/$NUMERO.jpg" "/tmp/$NUMERO.jpg"
|
||||
|
||||
DUPART=$(bc -l <<< "scale=2; $MONTANT / 100")
|
||||
# ADD 0 to <1 DUPART
|
||||
testdu=$( echo "${DUPART} < 1" | bc -l )
|
||||
if [[ "$testdu" -eq "1" ]]; then
|
||||
DUPART="0${DUPART}"
|
||||
fi
|
||||
|
||||
SIMPLEPHONE=$(echo $MASTERPHONE | sed 's/\+33/0/g')
|
||||
|
||||
convert -font 'Liberation-Sans' \
|
||||
-pointsize 120 -fill black -draw 'text 200,220 "'"$DUPART DU"'"' \
|
||||
-pointsize 45 -draw 'text 550,270 "'"$MONTANT $UNIT"'"' \
|
||||
-pointsize 35 -draw 'text 50,60 "'"https://g1sms.fr _ G1Billet _ $JUNE G1"'"' \
|
||||
-pointsize 30 -draw 'text 60,100 "'"Identifiant: $NUMERO"'"' \
|
||||
-pointsize 22 -fill black -draw 'text 380,340 "'"Code Secret: $SECRET"'"' \
|
||||
-pointsize 22 -fill black -draw 'text 260,408 "'"Porte Monnaie Libre!! A utiliser avant le 01/$valid/$year"'"' \
|
||||
-pointsize 20 -draw 'text 15,442 "'"Utilisation: CHK $NUMERO (+ code secret) par SMS au $SIMPLEPHONE ou https://cesium.app"'"' \
|
||||
"/tmp/$NUMERO.jpg" "/tmp/BILL.$year.$valid.$NUMERO.$MONTANT.$UNIT.jpg"
|
||||
|
||||
# Payable par SMS en envoyant les codes grattant la case comportant le SECRET
|
||||
# "CHK $NUMERO $SECRET"
|
||||
|
||||
if [[ "$TRANSAC" == "TEST" ]]; then
|
||||
exit
|
||||
else
|
||||
# Move billet to MEMBER folder 6 month later
|
||||
mkdir -p "./billets/MEMBERS/$MEMBER/"
|
||||
mv "/tmp/BILL.$year.$valid.$NUMERO.$MONTANT.$UNIT.jpg" "./billets/MEMBERS/$MEMBER/"
|
||||
# Clean TEMP files
|
||||
rm "/tmp/$NUMERO_NOTERIB.png"
|
||||
rm "/tmp/$NUMERO.jpg"
|
||||
fi
|
||||
|
||||
log "END sms_BILLET_MAKE.sh"
|
||||
log "~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
|
||||
|
|
@ -0,0 +1,77 @@
|
|||
#!/bin/bash
|
||||
################################################################################
|
||||
# Author: Fred (support@qo-op.com)
|
||||
# Version: 0.1
|
||||
# License: AGPL-3.0 (https://choosealicense.com/licenses/agpl-3.0/)
|
||||
################################################################################
|
||||
source ./shell/init.sh
|
||||
source ./shell/functions.sh
|
||||
log "X sms_COUNT.sh ($1=phone $2=NOSMS)"
|
||||
PHONE=$1
|
||||
TODAY=$(date '+%Y%m%d')
|
||||
# Initialise PHONE, PIN, PUBKEY, UNIT
|
||||
sms_INIT_ACCOUNT "$PHONE" "NOSMS"
|
||||
if [[ $UNKNOWN == "unknown" && "$PHONE" != "" ]]; then
|
||||
sms_ERROR "$PHONE" "Porte-monnaie inconnu. Envoyez N (suivi de votre Pseudo membre) pour le créer."
|
||||
exit
|
||||
fi
|
||||
|
||||
# Check account amount
|
||||
declare -a accounting
|
||||
accounting=($(check_account))
|
||||
log "$(declare -p accounting)"
|
||||
AMOUNTG1=${accounting[0]}
|
||||
AMOUNT=${accounting[1]}
|
||||
UNIT=${accounting[2]}
|
||||
|
||||
# SEARCH FOR VIREMENT
|
||||
if [[ -f ./wallets/$PHONE/VIREMENTS.gpg ]]; then
|
||||
echo "FOUND $file decrypting with Node key"
|
||||
echo "${GPGPASS}" | gpg -d -q --output "/tmp/VIREMENTS.$PHONE" --yes --pinentry-mode loopback --passphrase-fd 0 "$file"
|
||||
declare -a LIST
|
||||
num=0
|
||||
cat /tmp/VIREMENTS.$PHONE | while read LIST; do
|
||||
if [[ ${LIST[0]} -gt $TODAY ]]; then
|
||||
((num++))
|
||||
todo="$todo
|
||||
${LIST[0]}: ${LIST[3]} G1 vers ${LIST[5]}"
|
||||
fi
|
||||
done
|
||||
rm "/tmp/VIREMENTS.$PHONE"
|
||||
fi
|
||||
|
||||
# LOG
|
||||
log "Solde = $AMOUNTG1 ($UNIT)"
|
||||
|
||||
# If script control only run: NOSMS
|
||||
if [ "$2" != "NOSMS" ]; then
|
||||
if [[ "$AMOUNT" != "" ]]; then
|
||||
mess="[G1sms+]
|
||||
ID: $UIDNA
|
||||
$AMOUNT $UNIT ($AMOUNTG1 G1)
|
||||
=> $MEMBER
|
||||
$MEMRIB
|
||||
https://cesium.app"
|
||||
# Send response SMS
|
||||
sms_SEND "$PHONE" "$mess"
|
||||
sms_SEND "$PHONE" "$PUBKEY"
|
||||
|
||||
# CHECK NEXT VIREMENTS
|
||||
if [[ $num -gt 0 ]]; then
|
||||
sms_SEND "$PHONE" "Reste $num Virements récurrents
|
||||
$(echo $todo | head -n 2)
|
||||
...
|
||||
|
||||
$(echo $todo | tail -n 1)";
|
||||
fi
|
||||
log_history $PHONE "SOLDE, $AMOUNTG1"
|
||||
else
|
||||
sms_ERROR "$PHONE" "Problème de dialogue silkaj, Serveur $NEWDUNITER... Essayez dans 1 minute SVP..."
|
||||
fi
|
||||
else
|
||||
echo $AMOUNTG1
|
||||
fi
|
||||
|
||||
log "END sms_COUNT.sh"
|
||||
log "~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
|
||||
exit
|
||||
|
|
@ -0,0 +1,78 @@
|
|||
#!/bin/bash
|
||||
################################################################################
|
||||
# Author: Fred (support@qo-op.com)
|
||||
# Version: 0.1
|
||||
# License: AGPL-3.0 (https://choosealicense.com/licenses/agpl-3.0/)
|
||||
################################################################################
|
||||
source ./shell/init.sh
|
||||
source ./shell/functions.sh
|
||||
log "${c_yellow}__SUB:sms_DESTROY.sh: START ($1=phone, $2=uid)$c_"
|
||||
|
||||
PHONE="$1"
|
||||
MEMBERUID="$2"
|
||||
TODAY=$(date '+%Y%m%d')
|
||||
|
||||
if [[ -f "./wallets/$PHONE/VIREMENTS" ]]; then
|
||||
# CHECK IF ALL DONE.
|
||||
log "__SUB:sms_DESTROY.sh: FOUND "./wallets/$PHONE/VIREMENTS" decrypting with Node key"
|
||||
echo "${GPGPASS}" | gpg -d -q --output "/tmp/VIREMENTS.$PHONE" --yes --pinentry-mode loopback --passphrase-fd 0 "./wallets/$PHONE/VIREMENTS.gpg"
|
||||
for next in $(cat /tmp/VIREMENTS.$PHONE | cut -d ' ' -f 1); do
|
||||
if [[ $next -ge $TODAY ]]; then
|
||||
log "__SUB:sms_DESTROY.sh: VIREMENT $next >= $TODAY"
|
||||
sms_ERROR "$PHONE" "Votre portefeuille comporte des virements non réglés... FERMETURE IMPOSSIBLE!"
|
||||
exit
|
||||
else
|
||||
log "__SUB:sms_DESTROY.sh: VIREMENT $next ${c_green}OK$c_"
|
||||
fi
|
||||
done
|
||||
fi
|
||||
|
||||
# Initialise PHONE, PIN, PUBKEY, UNIT ...
|
||||
sms_INIT_ACCOUNT "$PHONE"
|
||||
if [[ "$MEMBERUID" == "DON" || "$MEMBERUID" == "" || "$MEMBERUID" == "$MEMBER" ]]; then
|
||||
# OK THAT GUYS KNOWS something (TODO Secure better with double authentification, with email or second phone number...)
|
||||
# IF no Dest PubKey (no member) or DON, then NODE_G1PUBKEY is collecting LOVE money.
|
||||
if [[ $MEMRIB == "" || "$MEMBERUID" == "DON" ]]; then MEMBER=$ADMINPSEUDO; MEMRIB=$NODE_G1PUBKEY; fi
|
||||
|
||||
AMOUNTG1=$(./silkaj/silkaj amount "$PUBKEY")
|
||||
GETLIMIT=$(bc <<< "$AMOUNTG1 - $LIMIT")
|
||||
PAY=$(./silkaj/silkaj transaction --auth-scrypt -salt="$PHONE" -password="$PIN" --amount="$GETLIMIT" --output="$MEMRIB" --comment="[G1sms+] Wallet DESTROY $MEMBER $MEMBERUID" -y)
|
||||
sleep 5
|
||||
back=$(./silkaj/silkaj transaction --auth-scrypt -salt="$PHONE" -password="$PIN" --amount="$LIMIT" --output="$NODEPUB" --comment="[G1sms+] Wallet DESTROY Send $LIMIT To NODE" -y)
|
||||
|
||||
if [[ "$(echo $PAY | cut -d '|' -f 1)" != "KO" && "$PAY" != "" && "$(echo $back | cut -d '|' -f 1)" != "KO" ]]; then
|
||||
# DESTROY FILESYSTEM AND G1sms WALLET SWARM REFERENCE
|
||||
if [[ "$PHONE" != "" ]]; then
|
||||
# SEND SMS BEFORE DELETE FOLDER
|
||||
mess="[G1sms+] $PAY
|
||||
Portefeuille détruit!
|
||||
Viré vers $MEMBER
|
||||
$MEMRIB
|
||||
|
||||
Merci, à bientôt.
|
||||
$ADMINPSEUDO @ $NODEUIDNA
|
||||
$back"
|
||||
sms_SEND "$PHONE" "$mess"
|
||||
|
||||
rm -Rf ./wallets/$PHONE;
|
||||
rm -Rf ./wallets_swarm/$PHONE;
|
||||
cents=$(echo $(bc -l <<< "scale=0; $GETLIMIT * 100") | cut -d '.' -f 1)
|
||||
move_g1cents "$PHONE" "$MEMRIB" "$cents"
|
||||
cents=$(echo $(bc -l <<< "scale=0; $LIMIT * 100") | cut -d '.' -f 1)
|
||||
move_g1cents "$PHONE" "$NODEPUB" "$cents"
|
||||
I=$(ipfs_node_wallets_add)
|
||||
log "__SUB:sms_DESTROY.sh: WALLET DESTROYED : $PHONE / $UIDNA / $MEMBER : ${c_green}OK$c_"
|
||||
fi
|
||||
else
|
||||
new=$(./shell/checknodes.sh "BAN")
|
||||
sms_ERROR "$PHONE" "Problème de payement avec silkaj (changement de serveur $new): $PAY";
|
||||
log "${c_red}__SUB:sms_DESTROY.sh: END WITH ERRORS ~~~~~~~~~~~~~~~~~~~~~~~~~~~~$c_"
|
||||
exit
|
||||
fi
|
||||
fi
|
||||
|
||||
# Remove contact from database
|
||||
rm_contact $PHONE $MEMBERUID && log "${c_green}Contact has been deleted from database$c_" || log "${c_red}Contact can't be deleted database$c_"
|
||||
|
||||
log "${c_yellow}__SUB:sms_DESTROY.sh: END ~~~~~~~~~~~~~~~~~~~~~~~~~~~~$c_"
|
||||
exit
|
||||
|
|
@ -0,0 +1,58 @@
|
|||
#!/bin/bash
|
||||
################################################################################
|
||||
# Author: Fred (support@qo-op.com)
|
||||
# Version: 0.1
|
||||
# License: AGPL-3.0 (https://choosealicense.com/licenses/agpl-3.0/)
|
||||
################################################################################
|
||||
# sudo apt install ssmtp mpack
|
||||
# Configure in /etc/ssmtp
|
||||
# Send email with file attachement: mpack -s "Logo G1Tag" /home/pi/G1sms+/G1Tag.png dest@email.ext
|
||||
|
||||
source ./shell/init.sh
|
||||
source ./shell/functions.sh
|
||||
|
||||
log "__SUB:sms_EMAIL.sh.sh: START ($1=phone, $2=mail)"
|
||||
|
||||
phone="$1"
|
||||
mail="$2"
|
||||
|
||||
MAILFILE="./wallets/$phone/$phone.email" # Contains the member EMAIL (Send BILLET)
|
||||
|
||||
# Initialise PHONE, PIN, PUBKEY, UNIT ...
|
||||
sms_INIT_ACCOUNT "$phone" "NOSMS"
|
||||
if [[ $UNKNOWN == "unknown" || "$MEMBER" == "" ]]; then
|
||||
sms_ERROR "$phone" "Porte-monnaie non identifié.
|
||||
Envoyez N suivi de votre pseudo membre (en respectant Majuscule et minuscule)."
|
||||
exit
|
||||
fi
|
||||
|
||||
if [[ "$mail" != "" ]]; then
|
||||
echo "$mail" > "$MAILFILE"
|
||||
./shell/natools.py encrypt -p $NODE_G1PUBKEY -i "$MAILFILE" -o "$MAILFILE.node.crypt"
|
||||
echo "" > "$MAILFILE"
|
||||
log "__SUB:sms_EMAIL.sh.sh: EMAIL $MEMBER ($PHONE) NOUVEAU: $mail... Publishing to IPFS"
|
||||
ipfs_node_wallets_add
|
||||
else
|
||||
mail=$MAIL
|
||||
fi
|
||||
|
||||
# SEND EMAIL WITH ssmtp
|
||||
SUBJECT="[G1sms+] $MEMBER, Message de votre portefeuille monnaie libre $UIDNA ($PHONE)"
|
||||
MESSAGE="Bonjour $MEMBER\n\nVotre porte-monnaie G1sms $UIDNA ($PHONE) a choisi votre email comme contact.\nPour commander vos G1Billets, envoyez par SMS à $MASTERPHONE :\nBILL 10/20/50/100/200/500/1000\n\n\nA bientot <3\n$ADMINPSEUDO ($ADMINPHONE)"
|
||||
cat ./email.txt | sed s/EMAIL/"${mail}"/g | sed s/SUBJECT/"${SUBJECT}"/g | sed s/MESSAGE/"${MESSAGE}"/g | ssmtp ${mail}
|
||||
mpack -s "[G1sms+] $PHONE, $UIDNA :: Envoyer 'BILL nnn' à $MASTERPHONE pour fabriquer des G1Billets (ci-joint exemple de verso)" ./Dos_G1Billets.odt ${mail}
|
||||
|
||||
log "__SUB:sms_EMAIL.sh.sh: Send welcome EMAIL to $mail via ssmtp"
|
||||
log_history $PHONE "EMAIL, $mail"
|
||||
|
||||
mess="[G1sms+]
|
||||
$MEMBER
|
||||
Votre email est : $mail
|
||||
Mettez le à jour, si cela est nécessaire..."
|
||||
|
||||
sms_SEND "$phone" "$mess"
|
||||
|
||||
|
||||
log "END sms_EMAIL.sh"
|
||||
log "~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
|
||||
exit
|
||||
|
|
@ -0,0 +1,16 @@
|
|||
#!/bin/bash
|
||||
################################################################################
|
||||
# Author: Fred (support@qo-op.com)
|
||||
# Version: 0.1
|
||||
# License: AGPL-3.0 (https://choosealicense.com/licenses/agpl-3.0/)
|
||||
################################################################################
|
||||
source ./shell/init.sh
|
||||
source ./shell/functions.sh
|
||||
log "X sms_ERROR.sh ($1=phone, $2=message)"
|
||||
|
||||
MESS="Commande inconnue $2."
|
||||
|
||||
# Send response SMS
|
||||
$(sms_ERROR "$1" "$MESS")
|
||||
|
||||
exit
|
||||
|
|
@ -0,0 +1,302 @@
|
|||
#!/bin/bash
|
||||
################################################################################
|
||||
# Author: Fred (support@qo-op.com)
|
||||
# Version: 0.2020
|
||||
# License: AGPL-3.0 (https://choosealicense.com/licenses/agpl-3.0/)
|
||||
###########################################################################################
|
||||
# == G1tag ==
|
||||
# IPFS ZEN WALLETS
|
||||
# RJ: READ G1Tag
|
||||
# BJ: WRITE G1Tag
|
||||
# WRITE ACCESS ONLY for B possessor and NODE G1Tag Creator
|
||||
# TODO: MAKE http API for G1Tag accessible through local ipfs gateway !!!!
|
||||
# https://github.com/typicode/lowdb USE json and ipfs DAG??!
|
||||
#
|
||||
# TAG 250 => Imprime un G1Tag rempli de 250 UNIT
|
||||
# TAG 2 100 => Imprime 100 G1Tag BON de 2 UNIT
|
||||
# PHONE any ./wallets/IDs
|
||||
# TODO: for multi-channel -> Use HASHLINK + UIDNA + NODE_UIDNA + AMOUNT ...
|
||||
###########################################################################################
|
||||
source ./shell/init.sh
|
||||
source ./shell/functions.sh
|
||||
log "__SUB:sms_G1TAG.sh: START ($1=PHONE, $2=AMOUNT, $3=NUMBER)"
|
||||
|
||||
PHONE=$1
|
||||
AMOUNT=$2
|
||||
if [[ "$AMOUNT" == "" ]]; then AMOUNT=0; fi
|
||||
NUMBER=$3
|
||||
# DEFAULT TYPE IS PRINTED G1TAG
|
||||
# BUT COULD BE USED TO CARRY VALUE INTO IPFS STORED FILES
|
||||
# FIRST ATTEMPT IS TO COPY YOUTUBE INTO M4A AND LEND THEM G1.
|
||||
TYPE=$4 # This is the type of passenger: YOUTUBE, NODE (EMPTY = default means sticker printed G1Tag)
|
||||
# Give ipfs hash of any External ID like YOUTUBEID ;)
|
||||
PASSENGER=$5
|
||||
|
||||
# == G1tag ==
|
||||
# IPFS G1sms Wallet to TAG creation/relation manager
|
||||
# TODO Modulate access to TAGs with IPNS publish key cypher
|
||||
# A/R: (G1TagID)
|
||||
# B: (GPG Key for HUMAN WRITE access)
|
||||
# J: (IPNS link to G1tag storage)
|
||||
# MASTER: Global SWARM Access
|
||||
###############################################################################################
|
||||
# Initialize PHONE, PIN, PUBKEY, UNIT, MEMBER, MEMRIB, EMAIL, etc...
|
||||
sms_INIT_ACCOUNT "$PHONE" "NOSMS"
|
||||
|
||||
if [[ $UNKNOWN == "unknown" ]]; then
|
||||
sms_ERROR "$PHONE" "Porte-monnaie inconnu. Envoyez N (suivi de votre Pseudo membre) pour le créer."
|
||||
log "__SUB:sms_G1TAG.sh: Porte-monnaie inconnu"
|
||||
exit
|
||||
fi
|
||||
|
||||
###########################################################
|
||||
# CALCULATE if wallet have enough for VIR+PERCENT
|
||||
AMOUNT=$2 # BE CAREFULL AMOUNT was changed by 1st sms_INIT_ACCOUNT!!
|
||||
if [[ "$AMOUNT" == "" ]]; then AMOUNT=0; fi
|
||||
if [[ ! $PASSENGER && "$NUMBER" != "" ]]; then
|
||||
# MULTI TAG NUMBER ($NUMBER = How many tags to print)
|
||||
AMOUNT=$(bc -l <<< "$AMOUNT * $NUMBER")
|
||||
else
|
||||
NUMBER=1
|
||||
fi
|
||||
VIR=0
|
||||
accounting=($(make_accounting))
|
||||
log "__SUB:sms_G1TAG.sh: $(declare -p accounting)"
|
||||
testmin=${accounting[0]}
|
||||
VIR=${accounting[1]}
|
||||
PERCENT=${accounting[2]}
|
||||
CHARGE=${accounting[3]}
|
||||
if [[ $testmin -eq 0 ]]; then
|
||||
sms_SEND "$PHONE" "Le solde de votre Porte-monnaie est insuffisant. Minimum requis = ${CHARGE} + ${PERCENT} (+ ${LIMIT}) G1! Rechargez avec https://cesium.app"
|
||||
exit
|
||||
fi
|
||||
|
||||
##### IS G1DAB NODE?
|
||||
if [[ ! $PASSENGER && ! $G1DAB ]]; then
|
||||
if [[ -f ./wallets/$PHONE/ipfsid.G1TAGNODE ]]; then
|
||||
DABnode=$(cat ./wallets/$PHONE/ipfsid.G1TAGNODE)
|
||||
if [[ "$DABnode" == "$IPFSNODEID" ]]; then
|
||||
sms_ERROR "$PHONE" "IMPRIMANTE G1Tag sur $DABnode non détectée!! Choisissez un autre G1Dab..."
|
||||
log "__SUB:sms_G1TAG.sh: IMPRIMANTE G1Tag non détectée!!"
|
||||
exit
|
||||
fi
|
||||
fi
|
||||
fi
|
||||
|
||||
# TODO: SEARCH PROXIMITY DAB LOCATION (GeoPoint + GPS)...
|
||||
# for node in ./wallets_swarm/.*/*.where; do
|
||||
# done
|
||||
###########################################################
|
||||
# silkaj NODE CHANGE !!!
|
||||
#SILKAJNODE=$(./shell/checknodes.sh)
|
||||
#log "NEW SILKAJ NODE: $SILKAJNODE"
|
||||
|
||||
###########################################
|
||||
# PAY VIR + PERCENT G1
|
||||
ML=$(bc -l <<< "scale=2; $VIR + $PERCENT")
|
||||
PAY=$(./shell/timeout.sh -t 29 ./silkaj/silkaj transaction --auth-scrypt -salt="$PHONE" -password="$PIN" --amount="$ML" --output="$NODE_G1PUBKEY" --comment="[G1sms+] ACHAT $3 G1Tag(s) - $2 $UNIT" -y)
|
||||
if [[ "$PAY" == "" || "$(echo $PAY | cut -d '|' -f 1)" == "KO" ]]; then
|
||||
# new=$(./shell/checknodes.sh "BAN")
|
||||
sms_ERROR "$PHONE" "Il est survenu un problème lors de votre virement: $PAY / Silkaj: $new";
|
||||
exit
|
||||
else
|
||||
cents=$(echo $(bc -l <<< "scale=0; $ML * 100") | cut -d '.' -f 1)
|
||||
move_g1cents "$PHONE" "$NODE_G1PUBKEY" "$cents"
|
||||
fi
|
||||
|
||||
#############################################
|
||||
log "__SUB:sms_G1TAG.sh: CREATE $NUMBER x $2 $UNIT G1Tag(s) for $MEMBER ($PHONE) : PAYEMENT $ML G1 to $NODE_G1PUBKEY: $PAY"
|
||||
c=0
|
||||
while [[ $c -lt $NUMBER ]]; do
|
||||
((c++))
|
||||
# Nom du G1Tag imprimé du le QRCode RJ
|
||||
AA=$(./shell/diceware.sh 6 | xargs); # Nom = Diceware de 6 mots
|
||||
RR=$(echo ${AA} | sed s/\ //g ); # Nom concaténé
|
||||
PR=$(echo ${AA} | cut -d ' ' -f 1 ); # Prénom du G1Tag
|
||||
# Create Unique G1tag in all SWARM!
|
||||
while [[ $(ls ./wallets_swarm/.Qm*/TAG/${RR}) ]]; do
|
||||
AA=$(./shell/diceware.sh 6 | xargs); RR=$(echo ${AA} | sed s/\ //g ); PR=$(echo ${AA} | cut -d ' ' -f 1 );
|
||||
done
|
||||
# Clef de chiffrage PGP imprimée sur le QRCode BJ
|
||||
BB=$(date +%N | sha256sum | base64 | head -c 32) #YjY4MDc3OTVjNmUxN2JhYWVjYmU3MDcy
|
||||
# BB=$(openssl rand -base64 32 | base64) #Yk8yMnVtdzZmendJbHNoK2Q0b0liakRpNHNJUk9UQW5Dd042cFdDODlJTT0K
|
||||
|
||||
# G1Tag init : Nom et usage des fichiers du G1Tag
|
||||
# TODO CHECK _nanodate to detect bad nodes/tx behaviour... and banish them)
|
||||
TAGDATE="./TAG/${RR}/TAG_nanodate" # Nanodate notification (ntpdate in init.sh for NODE sync in case of
|
||||
TAGNODEID="./TAG/${RR}/TAG_nodeid" # G1sms+ NODE IPFS ID managing that G1Tag
|
||||
TAGID="./TAG/${RR}/TAG_id" #Nom du TAG
|
||||
TAGCURRENCY="./TAG/${RR}/TAG_currency" # ZEN (0.01 G1)
|
||||
TAGAMOUNT="./TAG/${RR}/TAG_amount" # Tag amount. It is!
|
||||
TAGTYPE="./TAG/${RR}/TAG_type" # G1 Tag type
|
||||
TAGPASSENGER="./TAG/${RR}/TAG_passenger" # Reference to G1Tag owner/counter put in "./wallets/.$IPFSNODEID/TAG/${J}"
|
||||
# ... GESTION DE LA CLEF DE PUBLICATION IPNS ".ipfs/keystore/${RR}" ...
|
||||
TAGPUBLISH_B_GPG="./TAG/${RR}/TAG_publishkey.B.gpg" # ipns publish key B PGP cyphered
|
||||
TAGPUBLISH_PHONE_CRYPT="./TAG/${RR}/TAG_publishkey.phone.crypt" # natools.py crypt with creator G1sms Wallet PUBKEY
|
||||
TAGPUBLISH_NODE_CRYPT="./TAG/${RR}/TAG_publishkey.$NODE_UIDNA.crypt" # natools.py crypt with NODE G1sms Wallet PUBKEY
|
||||
TAGPUBLISH_SWARM_CRYPT="./TAG/${RR}/TAG_publishkey.swarm.crypt" # natools.py crypt with SWARM G1sms Wallet PUBKEY
|
||||
TAGN="./TAG/${RR}/TAG_n" # Tag modification number (0 first)
|
||||
TAGIPNS="./TAG/${RR}/TAG_ipns" # /ipns/Qm... link to last G1Tag version
|
||||
TAGCHAIN="./TAG/${RR}/TAG_chain" # contains IPFS current ipfs hash
|
||||
|
||||
# WRITE MULTITAG FILES with AMOUNT
|
||||
mkdir -p ./TAG/${RR}
|
||||
|
||||
log "__SUB:sms_G1TAG.sh: G1Tag: $RR / ${NANODATE}"
|
||||
log "__SUB:sms_G1TAG.sh: MEMRIB: $MEMRIB"
|
||||
log "__SUB:sms_G1TAG.sh: A: ${AA}"
|
||||
log "__SUB:sms_G1TAG.sh: B: ${BB}"
|
||||
log "__SUB:sms_G1TAG.sh: USER_KEY: $TAGPUBLISH_B_GPG"
|
||||
log "__SUB:sms_G1TAG.sh: PHONE G1WALLET_KEY: $TAGPUBLISH_PHONE_CRYPT"
|
||||
log "__SUB:sms_G1TAG.sh: NODE G1WALLET_KEY: $TAGPUBLISH_NODE_CRYPT"
|
||||
log "__SUB:sms_G1TAG.sh: SWARM G1WALLET_KEY: $TAGPUBLISH_SWARM_CRYPT"
|
||||
####################
|
||||
|
||||
####################################################
|
||||
# IPFS files are created and calculated immutable I
|
||||
####################################################
|
||||
# A or R is Human readable G1tag Name
|
||||
echo "${AA}" > "$TAGID"
|
||||
echo "0" > "$TAGN"
|
||||
echo "${NANODATE}" > "$TAGDATE"
|
||||
echo "${IPFSNODEID}" > "$TAGNODEID"
|
||||
echo "${TYPE}" > "$TAGTYPE"
|
||||
|
||||
echo "ZEN" > "$TAGCURRENCY"
|
||||
ZEN=$(bc -l <<< "$2 * 100") # TODO, Test. Unit != G1 may lead to miss calculation BUG??
|
||||
echo "${ZEN}" > "$TAGAMOUNT"
|
||||
|
||||
# Création de la clef ${R} IPNS qui permet de publier des changements sur le TAG!
|
||||
if [[ ! -f "/home/$YOU/.ipfs/keystore/${RR}" ]]; then
|
||||
su $YOU -c "ipfs key gen -t rsa -s 2048 ${RR}"
|
||||
fi
|
||||
|
||||
# GIVE QRCODE BJ ACCESS TO G1TAG
|
||||
# Enregistrement de la clef de publication IPNS du wallet ${R} cryptée par B
|
||||
echo "${BB}" | gpg -q --output "$TAGPUBLISH_B_GPG" --yes --pinentry-mode loopback --symmetric --passphrase-fd 0 "/home/$YOU/.ipfs/keystore/${RR}"
|
||||
|
||||
# GIVE PHONE CREATOR G1WALLET ACCESS TO ZEN TAG
|
||||
# Enregistrement de la clef de publication chiffrée par $PUBKEY la clef publique du portefeuille G1 createur.
|
||||
./shell/natools.py encrypt -p $PUBKEY -i "/home/$YOU/.ipfs/keystore/${RR}" -o "$TAGPUBLISH_PHONE_CRYPT"
|
||||
|
||||
# GIVE NODE_UIDNA ACCESS TO ZEN TAG
|
||||
./shell/natools.py encrypt -p $NODE_G1PUBKEY -i "/home/$YOU/.ipfs/keystore/${RR}" -o "$TAGPUBLISH_NODE_CRYPT"
|
||||
|
||||
# GIVE SWARM ACCESS TO ZEN TAG
|
||||
./shell/natools.py encrypt -p $SWARM_G1PUBKEY -i "/home/$YOU/.ipfs/keystore/${RR}" -o "$TAGPUBLISH_SWARM_CRYPT"
|
||||
|
||||
###########################################################
|
||||
# TAG IPFS STORAGE & G1Tag IPNS PUBLISHING
|
||||
###########################################################
|
||||
I=$(su $YOU -c "ipfs add -qr ./TAG/${RR} | tail -n 1")
|
||||
# MEMORIZE FOR CHAINING FUTURE CHANGES ( Block0 TAG version has no file published ;)
|
||||
echo "${I}" > "$TAGCHAIN"
|
||||
# Activate chain
|
||||
I=$(su $YOU -c "ipfs add -qr ./TAG/${RR} | tail -n 1")
|
||||
# IPFS Hash for Immutable G1tag data
|
||||
J=$(su $YOU -c "ipfs name publish -k ${RR} --quieter /ipfs/${I}")
|
||||
echo "${J}" > "$TAGIPNS"
|
||||
|
||||
# KEEP G1Tag J MEMORY in NODE ./wallets/.$IPFSNODEID/TAG/ (TODO: OPTIMIZE SWARM SYNC and REPUBLISH)
|
||||
mkdir -p "./wallets/.$IPFSNODEID/TAG/"
|
||||
# WRITE PASSENGER to J Link (G1Tag is stick to it: PHONE, NODE, FILE )
|
||||
# TODO USE SHA256 ID !!!
|
||||
echo "$PHONE" > "./wallets/.$IPFSNODEID/TAG/${J}"
|
||||
if [[ $PASSENGER ]]; then
|
||||
HPASSENGER=$(echo -n $PASSENGER | sha256sum | cut -d ' ' -f 1)
|
||||
echo "$HPASSENGER" > "./wallets/.$IPFSNODEID/TAG/${J}";
|
||||
fi
|
||||
|
||||
###########################################################
|
||||
log "__SUB:sms_G1TAG.sh: TAG: ipfs ls /ipns/${J}"
|
||||
if [[ ! $PASSENGER ]]; then
|
||||
# QR CODE LECTURE
|
||||
qrencode -s 5 -o "./TAG/${RR}/TAG_READ.png" "RJ:${RR}#${J}"
|
||||
log "__SUB:sms_G1TAG.sh: CREATE READ QRCODE -> RJ: ${RR} # ipfs ls /ipns/${J}"
|
||||
|
||||
# QR CODE ECRITURE
|
||||
qrencode -s 5 -o "./TAG/${RR}/TAG_WRITE.png" "BJ:${BB}#${J}"
|
||||
log "__SUB:sms_G1TAG.sh: CREATE WRITE QRCODE [] BJ: ${BB} # ipfs ls /ipns/${J}"
|
||||
|
||||
# COMPOSE G1TAG PRINT + TAG_READ.png + TAG_WRITE.png
|
||||
composite -compose Over -resize 133% -gravity West "./TAG/${RR}/TAG_READ.png" "./shell/g1tag.png" "./TAG/${RR}/${RR}.png"
|
||||
|
||||
composite -compose Over -gravity SouthEast "./TAG/${RR}/TAG_WRITE.png" "./TAG/${RR}/${RR}.png" "./TAG/${RR}/${RR}.png"
|
||||
|
||||
# ADD Avatar in the Center
|
||||
# if [[ $(file "./wallets/$PHONE/$PHONE.avatar.png" | grep 'PNG') ]]; then
|
||||
# composite -compose Over -resize 150% -gravity Center "./wallets/$PHONE/$PHONE.avatar.png" "./TAG/${RR}/${RR}.png" "./TAG/${RR}/${RR}.png"
|
||||
# else
|
||||
# composite -compose Over -resize 100% -gravity Center "./shell/G1Anar.png" "./TAG/${RR}/${RR}.png" "./TAG/${RR}/${RR}.png"
|
||||
# fi
|
||||
|
||||
|
||||
convert -pointsize 60 -fill black -gravity Center -draw 'text 0,-100 "'"$2"'"' "./TAG/${RR}/${RR}.png" "./TAG/${RR}/${RR}.png";
|
||||
|
||||
convert -pointsize 40 -fill black -gravity NorthEast -draw 'text 80,0 "'"${PR}"'"' "./TAG/${RR}/${RR}.png" "./TAG/${RR}/${RR}.png"
|
||||
# WRITE G1Tag RR
|
||||
convert -pointsize 40 -fill black -gravity SouthWest -draw 'text 3,0 "'"${RR}"'"' "./TAG/${RR}/${RR}.png" "./TAG/${RR}/${RR}.png"
|
||||
|
||||
# ROTATION (FIXE AVATAR & CHIFFRE)?
|
||||
# convert "./TAG/${RR}/${RR}.png" -rotate -180 "./TAG/${RR}/${RR}.png"
|
||||
# QL-700 PRINT PREPARE
|
||||
|
||||
if [[ -f "./wallets/$PHONE/ipfsid.G1TAGNODE" ]]; then
|
||||
destnode=$(cat "./wallets/$PHONE/ipfsid.G1TAGNODE")
|
||||
if [[ "$destnode" == "" || "$destnode" == "$IPFSNODEID" ]]; then
|
||||
log "__SUB:sms_G1TAG.sh: Local PRINT ${RR} # ipfs ls /ipns/${J}"
|
||||
brother_ql_create --model QL-700 "./TAG/${RR}/${RR}.png" --label-size 62 > "./TAG/${RR}/${RR}.bin"
|
||||
brother_ql_print "./TAG/${RR}/${RR}.bin" /dev/usb/lp0
|
||||
else
|
||||
# PRINT ON ANOTHER G1Dab. Send files to G1Tag Printer TODO: Could use DESTNODEPUB instead of NODE_G1PUBKEY ?
|
||||
log "__SUB:sms_G1TAG.sh: Remote PRINT :: ./wallets/.$destnode/PRINT/${RR}.bin "
|
||||
mkdir -p "./wallets/.$destnode/PRINT/"
|
||||
# TODO: USE $DEST_G1PUBKEY is better
|
||||
./shell/natools.py encrypt -p $NODE_G1PUBKEY -i "./TAG/${RR}/${RR}.png" -o "./wallets/.$destnode/PRINT/${RR}.bin"
|
||||
fi
|
||||
else
|
||||
#
|
||||
log "__SUB:sms_G1TAG.sh: Becoming default PRINTER :: $IPFSNODEID"
|
||||
echo "$IPFSNODEID" > "./wallets/$PHONE/ipfsid.G1TAGNODE"
|
||||
brother_ql_create --model QL-700 "./TAG/${RR}/${RR}.png" --label-size 62 > "./TAG/${RR}/${RR}.bin"
|
||||
brother_ql_print "./TAG/${RR}/${RR}.bin" /dev/usb/lp0
|
||||
destnode="$IPFSNODEID"
|
||||
fi
|
||||
fi
|
||||
done
|
||||
|
||||
####################################################
|
||||
# PRINT $PHONE WALLET PUBKEY
|
||||
####################################################
|
||||
if [[ "$destnode" == "" || "$destnode" == "$IPFSNODEID" ]]; then
|
||||
qrencode -s 5 -o "/tmp/G1PubQR.$PHONE.png" "$(cat ./wallets/$PHONE/$PHONE.pub)"
|
||||
composite -compose Over -gravity West "/tmp/G1PubQR.$PHONE.png" "./shell/g1tag.png" "/tmp/G1PubQR.$PHONE.png"
|
||||
|
||||
if [[ $(file "./wallets/$PHONE/$PHONE.avatar.png" | grep 'PNG') ]]; then
|
||||
composite -compose Over -gravity Center "./wallets/$PHONE/$PHONE.avatar.png" "/tmp/G1PubQR.$PHONE.png" "/tmp/G1PubQR.$PHONE.png"
|
||||
fi
|
||||
if [[ -f ./wallets/$PHONE/$PHONE.uidrib ]]; then
|
||||
qrencode -s 6 -o "/tmp/G1MemQR.$PHONE.png" "$(cat ./wallets/$PHONE/$PHONE.uidrib)";
|
||||
composite -compose Over -gravity SouthEast "/tmp/G1MemQR.$PHONE.png" "/tmp/G1PubQR.$PHONE.png" "/tmp/G1PubQR.$PHONE.png" && rm /tmp/G1MemQR.$PHONE.png
|
||||
fi
|
||||
|
||||
convert -pointsize 40 -fill black -gravity NorthEast -draw 'text 100,0 "'"G1 $MEMBER"'"' "/tmp/G1PubQR.$PHONE.png" "/tmp/G1PubQR.$PHONE.png"
|
||||
convert -pointsize 40 -fill black -gravity SouthWest -draw 'text 10,0 "'"$UIDNA"'"' "/tmp/G1PubQR.$PHONE.png" "/tmp/G1PubQR.$PHONE.png"
|
||||
#convert -pointsize 60 -fill black -gravity Center -draw 'text 350,80 "'"$PHONE"'"' "/tmp/G1PubQR.$PHONE.png" "/tmp/G1PubQR.$PHONE.png"
|
||||
brother_ql_create --model QL-700 "/tmp/G1PubQR.$PHONE.png" --label-size 62 > "/tmp/G1PubQR.$PHONE.bin"
|
||||
brother_ql_print "/tmp/G1PubQR.$PHONE.bin" /dev/usb/lp0
|
||||
rm -f /tmp/G1PubQR.*
|
||||
fi
|
||||
|
||||
# Send dest SMS
|
||||
mess_dest="[G1sms+]
|
||||
Vos $NUMBER G1Tag(s) de $2 $UNIT sont imprimé(s).
|
||||
Veuillez les récupérer ici:
|
||||
$ADRESSE
|
||||
Merci"
|
||||
sms_SEND "$PHONE" "$mess_dest"
|
||||
|
||||
ipfs_node_wallets_add
|
||||
|
||||
log "__SUB:sms_G1TAG.sh: END ~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
|
||||
exit
|
||||
|
|
@ -0,0 +1,60 @@
|
|||
#!/bin/bash
|
||||
################################################################################
|
||||
# Author: Fred (support@qo-op.com)
|
||||
# Version: 0.1
|
||||
# License: AGPL-3.0 (https://choosealicense.com/licenses/agpl-3.0/)
|
||||
################################################################################
|
||||
source ./shell/init.sh
|
||||
source ./shell/functions.sh
|
||||
log "${c_yellow}X sms_NEW.sh ($1=phone, $2=uid)$c_"
|
||||
|
||||
PHONE="$1"
|
||||
MEMBERUID="$2"
|
||||
|
||||
# Initialise PHONE, PIN, PUBKEY, UNIT
|
||||
sms_INIT_ACCOUNT "$PHONE"
|
||||
if [[ "$MEMBERUID" != "" && "$MEMBERUID" != "N" && "$MEMBERUID" != "D" && "$MEMBERUID" != "NOUV" ]]; then
|
||||
# UID RECEIVED in SMS
|
||||
VIRDEST=$MEMBERUID
|
||||
MEMRIB=$(sms_uid2key "$MEMBERUID" "$PHONE" "$PIN")
|
||||
if [[ $MEMRIB == "" ]]; then exit; fi
|
||||
MEMBER="$MEMBERUID"
|
||||
fi
|
||||
|
||||
sms_INIT_ACCOUNT "$PHONE" "NOSMS"
|
||||
# Check account amount
|
||||
countvalues=($(check_account))
|
||||
log "$(declare -p countvalues)"
|
||||
AMOUNTG1=${countvalues[0]}
|
||||
AMOUNT=${countvalues[1]}
|
||||
UNIT=${countvalues[2]}
|
||||
|
||||
mess="[G1sms+]
|
||||
Id: $UIDNA
|
||||
Solde: $AMOUNT $UNIT
|
||||
DAB: $DABID
|
||||
---
|
||||
https://cesium.app
|
||||
* Identifiant ="
|
||||
sms_SEND "$PHONE" "$mess"
|
||||
sleep 2
|
||||
sms_SEND "$PHONE" "$PHONE"
|
||||
sleep 2
|
||||
sms_SEND "$PHONE" "* Mot de passe ="
|
||||
sleep 2
|
||||
sms_SEND "$PHONE" "$PIN"
|
||||
sleep 2
|
||||
sms_SEND "$PHONE" "* Clef Publique (RIB) ="
|
||||
sleep 2
|
||||
sms_SEND "$PHONE" "$PUBKEY"
|
||||
sleep 2
|
||||
[[ $MEMRIB != "" ]] && sms_SEND "$PHONE" "Compte relié? $MEMBER $MAIL
|
||||
$MEMRIB"
|
||||
|
||||
# Add contact to database
|
||||
add_contact $PHONE $MEMBERUID && log "${c_green}Contact has been added to database$c_" || log "${c_red}Contact can't be added to database$c_"
|
||||
|
||||
log "${c_yellow}END sms_NEW.sh$c_"
|
||||
log "~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
|
||||
exit
|
||||
|
||||
|
|
@ -0,0 +1,98 @@
|
|||
#!/bin/bash
|
||||
################################################################################
|
||||
# Author: Fred (support@qo-op.com)
|
||||
# Version: 0.1
|
||||
# License: AGPL-3.0 (https://choosealicense.com/licenses/agpl-3.0/)
|
||||
################################################################################
|
||||
source ./shell/init.sh
|
||||
source ./shell/functions.sh
|
||||
log "__SUB:sms_PAY.sh: START ($1=PHONE, $2=PHONEDEST, $3=AMOUNT)"
|
||||
|
||||
phone="$1"
|
||||
PHONEDEST="$2"
|
||||
|
||||
# Initialise PHONE, PIN, PUBKEY, UNIT
|
||||
sms_INIT_ACCOUNT "$phone" "NOSMS"
|
||||
pin=$PIN
|
||||
if [[ $UNKNOWN == "unknown" ]]; then
|
||||
sms_ERROR "$phone" "Porte-monnaie inconnu. Envoyez N (suivi de votre Pseudo membre) pour le créer."
|
||||
exit
|
||||
fi
|
||||
|
||||
###########################################################
|
||||
# CALCULATE if wallet have enough for VIR+PERCENT
|
||||
AMOUNT="$3"
|
||||
accounting=($(make_accounting))
|
||||
log "__SUB:sms_PAY.sh: $(declare -p accounting)"
|
||||
testmin=${accounting[0]}
|
||||
VIR=${accounting[1]}
|
||||
PERCENT=${accounting[2]}
|
||||
CHARGE=${accounting[3]}
|
||||
if [[ $testmin -eq 0 ]]; then
|
||||
sms_ERROR "$phone" "Solde de votre Porte-monnaie G1sms insuffisant. Minimum: $CHARGE G1! Rechargez avec https://Cesium.app"
|
||||
exit
|
||||
fi
|
||||
|
||||
# Add COUNTRY code to PHONEDEST + PHONEDEST INIT
|
||||
PHONEDEST="$COUNTRY${PHONEDEST:1:10}"
|
||||
|
||||
# CHECK if PHONEDEST have an account in IPFS G1sms+ SWARM
|
||||
if [[ -f "./wallets_swarm/$PHONEDEST/$PHONEDEST.pub" ]]
|
||||
then
|
||||
PUBKEYDEST=$(cat "./wallets_swarm/$PHONEDEST/$PHONEDEST.pub")
|
||||
UNITDEST=$(cat "./wallets_swarm/$PHONEDEST/$PHONEDEST.unit")
|
||||
else
|
||||
# NO, then create NEW Wallet
|
||||
sms_INIT_ACCOUNT "$PHONEDEST"
|
||||
# Refreshed new values
|
||||
PUBKEYDEST="$PUBKEY"
|
||||
UNITDEST="$UNIT"
|
||||
fi
|
||||
|
||||
# Payement
|
||||
PAY=$(./shell/timeout.sh -t 20 ./silkaj/silkaj transaction --auth-scrypt -salt="$phone" -password="$pin" --amount="$VIR" --output="$PUBKEYDEST" --comment="[G1sms+] PAY" -y)
|
||||
if [[ "$(echo $PAY | cut -d '|' -f 1)" == "KO" || "$PAY" == "" ]]; then
|
||||
sms_ERROR "$phone" "Problème de payement avec silkaj (changement de serveur $new): $PAY";
|
||||
log "__SUB:sms_PAY.sh: Problème de payement avec silkaj $new : $PAY"
|
||||
exit
|
||||
else
|
||||
# OK: Sync g1cents TODO check move_g1cents function and generalize on all silkaj transactions
|
||||
cents=$(echo $(bc -l <<< "scale=0; $VIR * 100") | cut -d '.' -f 1)
|
||||
move_g1cents "$phone" "$PUBKEYDEST" "$cents"
|
||||
fi
|
||||
|
||||
sleep 2
|
||||
|
||||
# + G1SMS Commission
|
||||
COM=$(./shell/timeout.sh -t 20 ./silkaj/silkaj transaction --auth-scrypt -salt="$phone" -password="$pin" --amount="$PERCENT" --output="$NODE_G1PUBKEY" --comment="[G1sms+] Commission" -y)
|
||||
if [[ "$(echo $COM | cut -d '|' -f 1)" == "KO" || "$PAY" == "" ]]; then
|
||||
new=$(./shell/checknodes.sh "BAN")
|
||||
sms_ERROR "$phone" "Problème de payement avec silkaj (changement de serveur $new): $COM";
|
||||
log "__SUB:sms_PAY.sh: Problème de payement avec silkaj $new : $COM"
|
||||
exit
|
||||
else
|
||||
# OK: Sync g1cents
|
||||
cents=$(echo $(bc -l <<< "scale=0; $PERCENT * 100") | cut -d '.' -f 1)
|
||||
move_g1cents "$phone" "$NODE_G1PUBKEY" "$cents"
|
||||
fi
|
||||
|
||||
# LOG ACCOUNT HISTORY EVENTS
|
||||
log "__SUB:sms_PAY.sh: $1 => $2 = $3 $UNIT / SILKAJ == TxPay $PAY + TxCom $COM /"
|
||||
log_history $phone "PAY, $VIR, $PHONEDEST, $PUBKEYDEST"
|
||||
|
||||
# Send response SMS
|
||||
mess_src="[G1sms+]
|
||||
Envoi de $VIR G1 vers $PHONEDEST effectué!
|
||||
+ Commission: $PERCENT G1"
|
||||
sms_SEND "$phone" "$mess_src"
|
||||
|
||||
# Send dest SMS
|
||||
mess_dest="[G1sms+] Bonjour.
|
||||
Un(e) ami(e) ($phone) vient de vous envoyer $VIR G1 sur votre portefeuille G1sms!
|
||||
Envoyez D pour (D)étail.
|
||||
A pour (A)ide..."
|
||||
sms_SEND "$PHONEDEST" "$mess_dest"
|
||||
|
||||
|
||||
log "__SUB:sms_PAY.sh: END ~~~~~~~~~~~~~~~~~~~~~~~~~~ "
|
||||
exit
|
||||
|
|
@ -0,0 +1,170 @@
|
|||
#!/bin/bash
|
||||
################################################################################
|
||||
# Author: Fred (support@qo-op.com)
|
||||
# Version: 0.1
|
||||
# License: AGPL-3.0 (https://choosealicense.com/licenses/agpl-3.0/)
|
||||
# RECORD RECURRENT PAYEMENTS WITH "Cesium+ ID" Pubkey TODO cron ./wallets/$PHONE/VIREMENTS, Fusion avec sms_VIR.sh
|
||||
################################################################################
|
||||
source ./shell/init.sh
|
||||
source ./shell/functions.sh
|
||||
log "__SUB:sms_REC.sh: START ($1=PHONE, $2=VIRDEST, $3=AMOUNT, $4=PERIOD, $5=TIME)"
|
||||
|
||||
PHONE="$1"
|
||||
VIRDEST="$2"
|
||||
AMOUNT=$3
|
||||
PERIOD="$4"
|
||||
TIME=$5
|
||||
|
||||
case "$PERIOD" in
|
||||
J|D)
|
||||
PERIOD="jour";
|
||||
NEXTDATE="days";
|
||||
;;
|
||||
S|W)
|
||||
PERIOD="semaine";
|
||||
NEXTDATE="weeks";
|
||||
;;
|
||||
M)
|
||||
PERIOD="mois";
|
||||
NEXTDATE="months";
|
||||
;;
|
||||
A|Y)
|
||||
PERIOD="année";
|
||||
NEXTDATE="years";
|
||||
;;
|
||||
*)
|
||||
sms_ERROR "$PHONE" "Erreur sur la période de votre virement! Jour, Semaine, Mois, Année? Valeur: J,S,M,A (ex: REC 10 Fred J 3)"
|
||||
exit;
|
||||
;;
|
||||
esac
|
||||
|
||||
###########################################################
|
||||
# Initialise PHONE, PIN, PUBKEY, UNIT
|
||||
sms_INIT_ACCOUNT "$PHONE" "NOSMS"
|
||||
if [[ $MEMBER == "" ]]; then MEMBER=$UIDNA; fi
|
||||
###########################################################
|
||||
# CHECK FOR ERRORS
|
||||
if [[ $UNKNOWN == "unknown" ]]; then
|
||||
sms_ERROR "$PHONE" "Porte-monnaie inconnu. Envoyez N (suivi de votre Pseudo membre) pour le créer."
|
||||
exit
|
||||
fi
|
||||
if [[ "$MEMBER" == "" ]]; then
|
||||
sms_ERROR "$PHONE" "Aucun membre associé à votre Portefeuille!? Envoyer N suivi de votre Pseudo membre pour activer les virements récurrents..."
|
||||
exit
|
||||
fi
|
||||
|
||||
###########################################################
|
||||
# CALCULATE if wallet have enough for VIR+PERCENT
|
||||
AMOUNT=$(bc -l <<< "$3 * $TIME")
|
||||
accounting=($(make_accounting))
|
||||
log "__SUB:sms_REC.sh: $(declare -p accounting)"
|
||||
testmin=${accounting[0]}
|
||||
VIR=$(bc -l <<< "scale=2; ${accounting[1]} / $TIME")
|
||||
PERCENT=${accounting[2]}
|
||||
CHARGE=${accounting[3]}
|
||||
if [[ $testmin -eq 0 ]]; then
|
||||
sms_ERROR "$PHONE" "Votre Porte-monnaie G1sms doit comporter un solde suffisant! Au minimum $CHARGE G1! Rechargez par Cesium (ou contactez https://g1sms.fr)."
|
||||
exit
|
||||
fi
|
||||
|
||||
###########################################################
|
||||
# TODO Unify REC and VIR
|
||||
# FIND VIRDEST into wallets, wallest-swarm OR duniter (silkaj)
|
||||
if [[ "$VIRDEST" == "" || "$VIRDEST" == "$MEMBER" ]]; then
|
||||
# VIR TO MEMBER PHONE OWNER
|
||||
DESTMEM="$MEMBER"
|
||||
DESTRIB="$MEMRIB"
|
||||
log "__SUB:sms_REC.sh: SEND TO MEMBER related wallet!!! $DESTRIB "
|
||||
else
|
||||
log "__SUB:sms_REC.sh: SEARCH $VIRDEST related wallet!!! $DESTRIB "
|
||||
DESTMEM="$VIRDEST"
|
||||
# SEARCH IN WALLETS
|
||||
LOCAL=$(grep -Rwl "$DESTMEM" ./wallets/*/*.uidname | tail -n 1 | cut -f 3 -d '/')
|
||||
if [[ "$LOCAL" == "" ]]; then LOCAL=$(grep -Rwl "$DESTMEM" ./wallets/*/*.uidna | tail -n 1 | cut -f 3 -d '/'); fi
|
||||
if [[ "$LOCAL" != "" ]]; then
|
||||
# LOCAL G1sms account
|
||||
DESTRIB=$(cat ./wallets/$LOCAL/$LOCAL.pub)
|
||||
DESTPHONE=$LOCAL
|
||||
log "__SUB:sms_REC.sh: FOUND LOCAL ($MASTERPHONE) G1sms+ wallet: $DESTRIB ($LOCAL)"
|
||||
else
|
||||
# SEARCH IN WALLETS SWARM (MEMBER THEN UIDNA)
|
||||
INSWARM=$(grep -Rwl "$DESTMEM" ./wallets_swarm/*/*.uidname | tail -n 1 | cut -f 3 -d '/')
|
||||
if [[ "$INSWARM" == "" ]]; then INSWARM=$(grep -Rwl "$DESTMEM" ./wallets_swarm/*/*.uidna | tail -n 1 | cut -f 3 -d '/'); fi
|
||||
if [[ "$INSWARM" != "" ]]; then
|
||||
REMOTENODE=$(cat ./wallets_swarm/$INSWARM/MASTERPHONE.sms)
|
||||
DESTRIB=$(cat ./wallets_swarm/$INSWARM/$INSWARM.pub)
|
||||
DESTPHONE=$INSWARM
|
||||
log "__SUB:sms_REC.sh: FOUND SWARM ($REMOTENODE) G1sms+ wallet: $DESTRIB ($INSWARM)"
|
||||
else
|
||||
# SEARCH WITH SILKAJ
|
||||
DESTRIB=$(./silkaj/silkaj id "$DESTMEM" | grep -w "$DESTMEM" | awk '{print $2}')
|
||||
log "__SUB:sms_REC.sh: OUT OFF SWARM MEMBER wallet: $DESTRIB"
|
||||
fi
|
||||
fi
|
||||
fi
|
||||
|
||||
# ADD DATES TO VIREMENTS
|
||||
if [[ "$DESTRIB" != "" ]]; then
|
||||
log "__SUB:sms_REC.sh: TRAITEMENT DU VIREMENT DE $AMOUNT $UNIT = 1ER VIREMENT de $VIR G1 vers $VIRDEST ($DESTRIB) $TIME FOIS. OK..."
|
||||
PAY=$(./shell/timeout.sh -t 20 ./silkaj/silkaj transaction --auth-scrypt -salt="$PHONE" -password="$PIN" --amount="$VIR" --output="$DESTRIB" --comment="[G1sms+] REC 1/$TIME ($PERIOD)" -y)
|
||||
if [[ "$(echo $PAY | cut -d '|' -f 1)" == "KO" || "$PAY" == "" ]]; then
|
||||
new=$(./shell/checknodes.sh "BAN")
|
||||
sms_ERROR "$PHONE" "Problème de payement avec silkaj (changement de serveur $new): $PAY";
|
||||
log "__SUB:sms_REC.sh: END ~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
|
||||
exit
|
||||
else
|
||||
cents=$(echo $(bc -l <<< "scale=0; $VIR * 100") | cut -d '.' -f 1)
|
||||
move_g1cents "$PHONE" "$DESTRIB" "$cents"
|
||||
fi
|
||||
log "__SUB:sms_REC.sh: UPDATE ./wallets/$PHONE/VIREMENTS with FUTURE PAYEMENTS? $PAY"
|
||||
|
||||
########### MAKE ./wallets/$PHONE/VIREMENTS for NEXT ONES
|
||||
if [[ -f "./wallets/$PHONE/VIREMENTS.gpg" ]]; then
|
||||
# DECYPHER FILE FOR CHANGE
|
||||
echo "${GPGPASS}" | gpg -d -q --output "./wallets/$PHONE/VIREMENTS" --yes --pinentry-mode loopback --passphrase-fd 0 "./wallets/$PHONE/VIREMENTS.gpg"
|
||||
fi
|
||||
# WRITE NEW LINES INTO AN ARRAY FILE: VIREMENTS
|
||||
boucle=$((TIME - 1))
|
||||
num=0
|
||||
while [[ boucle -gt 0 ]]; do
|
||||
$((boucle --))
|
||||
$((num ++))
|
||||
NEXT=$(date --date="$num $NEXTDATE" '+%Y%m%d')
|
||||
# ADD NEW LINE IN VIREMENTS
|
||||
echo "$NEXT $MEMBER $PHONE $VIR $DESTRIB $DESTMEM $MEMBER#$TIME#$AMOUNT#$DESTMEM $boucle " >> ./wallets/$PHONE/VIREMENTS
|
||||
|
||||
done
|
||||
# CYPHER FILE
|
||||
echo "${GPGPASS}" | gpg -q --output "./wallets/$PHONE/VIREMENTS.gpg" --yes --pinentry-mode loopback --symmetric --passphrase-fd 0 "./wallets/$PHONE/VIREMENTS"
|
||||
# EMPTY CLEAR FILE
|
||||
log "__SUB:sms_REC.sh: $(cat ./wallets/$PHONE/VIREMENTS)"
|
||||
echo "" > ./wallets/$PHONE/VIREMENTS
|
||||
###########
|
||||
|
||||
log "__SUB:sms_REC.sh: .....................................OK!!!"
|
||||
|
||||
# SEND ACK SMS
|
||||
log "__SUB:sms_REC.sh: VIREMENTS RECURRENTS $MEMBER#$TIME#$AMOUNT#$DESTMEM => $VIR G1 pour $DESTMEM (pendant $TIME $PERIOD) + AJOUT"
|
||||
mess="[G1sms+]
|
||||
Virement de $VIR G1 pour $DESTMEM (pendant $TIME $PERIOD)
|
||||
Total: $AMOUNT $UNIT
|
||||
|
||||
$MEMBER#$TIME#$AMOUNT#$DESTMEM
|
||||
$DESTRIB"
|
||||
|
||||
sms_SEND "$PHONE" "$mess"
|
||||
|
||||
log_history "$PHONE" "REC, $VIR, $DESTRIB, $DESTMEM, $PERIOD, $TIME"
|
||||
# Send DESTPHONE sms
|
||||
if [[ "$DESTPHONE" != "" ]]; then
|
||||
sms_SEND "$DESTPHONE" "[G1sms+] Bonjour $DESTMEM. Vous recev(r)ez un payement de $VIR G1 (pendant $TIME $PERIOD) de la part du portefeuille: $MEMBER $UIDNA."
|
||||
fi
|
||||
|
||||
else
|
||||
log "__SUB:sms_REC.sh: ERROR $MEMBER: $DESTMEM DESTRIB NOT FOUND"
|
||||
mess="[G1sms+] Virement annulé...
|
||||
Destinataire: $DESTMEM inconnu! Vérifiez son existence."
|
||||
sms_SEND "$PHONE" "$mess"
|
||||
fi
|
||||
|
||||
log "__SUB:sms_REC.sh: END ~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
|
||||
|
|
@ -0,0 +1,44 @@
|
|||
#!/bin/bash
|
||||
################################################################################
|
||||
# Author: Fred (support@qo-op.com)
|
||||
# Version: 0.1
|
||||
# License: AGPL-3.0 (https://choosealicense.com/licenses/agpl-3.0/)
|
||||
################################################################################
|
||||
source ./shell/init.sh
|
||||
source ./shell/functions.sh
|
||||
log "X sms_SETUNIT.sh ($1=phone, $2=unit)"
|
||||
|
||||
phone="$1"
|
||||
unit="$2"
|
||||
UNITFILE="./wallets/$phone/$phone.unit"
|
||||
|
||||
# Initialise PHONE, PIN, PUBKEY, UNIT, HIST
|
||||
sms_INIT_ACCOUNT "$phone" "NOSMS"
|
||||
|
||||
if [[ $UNKNOWN == "unknown" ]]; then
|
||||
sms_ERROR "$phone" "Porte-monnaie inconnu. Envoyez N (suivi de votre Pseudo membre) pour le créer."
|
||||
exit
|
||||
fi
|
||||
|
||||
# No unit received
|
||||
if [[ $unit == "U" || $unit == "" ]]; then
|
||||
if [[ -f "$UNITFILE" ]]; then
|
||||
unit=$(cat "$UNITFILE")
|
||||
else
|
||||
unit="$COIN";
|
||||
fi
|
||||
fi
|
||||
|
||||
echo "$unit" > "$UNITFILE"
|
||||
log "G1sms wallet new $unit... IPFS SWARM publishing..."
|
||||
ipfs_node_wallets_add
|
||||
|
||||
mess="[G1sms+]
|
||||
Unité de votre portefeuille: $unit"
|
||||
|
||||
sms_SEND "$phone" "$mess"
|
||||
|
||||
log "END sms_SETUNIT.sh"
|
||||
log "~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
|
||||
|
||||
exit
|
||||
|
|
@ -0,0 +1,104 @@
|
|||
#!/bin/bash
|
||||
################################################################################
|
||||
# Author: Fred (support@qo-op.com)
|
||||
# Version: 0.1
|
||||
# License: AGPL-3.0 (https://choosealicense.com/licenses/agpl-3.0/)
|
||||
################################################################################
|
||||
source ./shell/init.sh
|
||||
source ./shell/functions.sh
|
||||
log "__SUB:sms_VIR.sh: START ($1=phone, $2=AMOUNT, $3=VIRDEST)"
|
||||
|
||||
phone="$1"
|
||||
AMOUNT="$2"
|
||||
VIRDEST="$3"
|
||||
|
||||
# Initialise PHONE, PIN, PUBKEY, UNIT
|
||||
sms_INIT_ACCOUNT "$phone" "NOSMS"
|
||||
if [[ $MEMBER == "" ]]; then MEMBER=$UIDNA; fi
|
||||
member=$MEMBER
|
||||
if [[ "$AMOUNT" == "" ]]; then
|
||||
sms_ERROR "$phone" "Montant incorrect!!
|
||||
Ex:
|
||||
VIR 100, pour virer 100 $UNIT vers votre compte relié.
|
||||
VIR 100 $ADMINPSEUDO, pour virer 100 $UNIT au membre administrateur de ce NODE G1sms+ ;)"
|
||||
exit
|
||||
fi
|
||||
|
||||
###########################################################
|
||||
# CALCULATE if wallet have enough for VIR+PERCENT
|
||||
AMOUNT="$2"
|
||||
accounting=($(make_accounting))
|
||||
log "__SUB:sms_VIR.sh: $(declare -p accounting)"
|
||||
testmin=${accounting[0]}
|
||||
VIR=${accounting[1]}
|
||||
PERCENT=${accounting[2]}
|
||||
if [[ $testmin -eq 0 ]]; then
|
||||
sms_ERROR "$PHONE" "Solde de votre Porte-monnaie G1sms insuffisant. Minimum $VIR + $LIMIT G1! Rechargez par Cesium."
|
||||
exit
|
||||
fi
|
||||
|
||||
###########################################################
|
||||
# FIND VIRDEST into wallets, wallest-swarm OR duniter (silkaj)
|
||||
if [[ "$VIRDEST" == "" || "$VIRDEST" == "$MEMBER" ]]; then
|
||||
# VIR TO MEMBER PHONE OWNER
|
||||
DESTMEM="$MEMBER"
|
||||
DESTRIB="$MEMRIB"
|
||||
log "__SUB:sms_VIR.sh: SEND TO MEMBER related wallet!!! $DESTRIB "
|
||||
else
|
||||
log "__SUB:sms_VIR.sh: SEARCH $VIRDEST related wallet!!! $DESTRIB "
|
||||
DESTMEM="$VIRDEST"
|
||||
# SEARCH IN WALLETS
|
||||
LOCAL=$(grep -Rwl "$DESTMEM" ./wallets/*/*.uidname | tail -n 1 | cut -f 3 -d '/')
|
||||
if [[ "$LOCAL" == "" ]]; then LOCAL=$(grep -Rwl "$DESTMEM" ./wallets/*/*.uidna | tail -n 1 | cut -f 3 -d '/'); fi
|
||||
if [[ "$LOCAL" != "" ]]; then
|
||||
# LOCAL G1sms account
|
||||
DESTRIB=$(cat ./wallets/$LOCAL/$LOCAL.pub)
|
||||
DESTPHONE=$LOCAL
|
||||
log "__SUB:sms_VIR.sh: FOUND LOCAL ($MASTERPHONE) G1sms+ wallet: $DESTRIB ($LOCAL)"
|
||||
else
|
||||
# SEARCH IN WALLETS SWARM (MEMBER THEN UIDNA)
|
||||
INSWARM=$(grep -Rwl "$DESTMEM" ./wallets_swarm/*/*.uidname | tail -n 1 | cut -f 3 -d '/')
|
||||
if [[ "$INSWARM" == "" ]]; then INSWARM=$(grep -Rwl "$DESTMEM" ./wallets_swarm/*/*.uidna | tail -n 1 | cut -f 3 -d '/'); fi
|
||||
if [[ "$INSWARM" != "" ]]; then
|
||||
REMOTENODE=$(cat ./wallets_swarm/$INSWARM/MASTERPHONE.sms)
|
||||
DESTRIB=$(cat ./wallets_swarm/$INSWARM/$INSWARM.pub)
|
||||
DESTPHONE=$INSWARM
|
||||
log "__SUB:sms_VIR.sh: FOUND SWARM ($REMOTENODE) G1sms+ wallet: $DESTRIB ($INSWARM)"
|
||||
else
|
||||
# SEARCH WITH SILKAJ
|
||||
DESTRIB=$(./silkaj/silkaj id "$DESTMEM" | grep -w "$DESTMEM" | awk '{print $2}')
|
||||
log "__SUB:sms_VIR.sh: OUT OFF SWARM MEMBER wallet: $DESTRIB"
|
||||
fi
|
||||
fi
|
||||
fi
|
||||
|
||||
if [[ "$DESTRIB" != "" ]]; then
|
||||
PAY=$(./shell/timeout.sh -t 30 ./silkaj/silkaj transaction --auth-scrypt -salt="$PHONE" -password="$PIN" --amount="$VIR" --output="$DESTRIB" --comment="[G1sms+] VIR $VIR G1" -y)
|
||||
if [[ "$(echo $PAY | cut -d '|' -f 1)" != "KO" && "$PAY" != "" ]]; then
|
||||
log "__SUB:sms_VIR.sh: VIREMENT VERS $DESTMEM OK"
|
||||
mess="[G1sms+] $MEMBER
|
||||
Virement de $AMOUNT $UNIT ($VIR G1)
|
||||
vers $DESTMEM ($DESTRIB)
|
||||
OK!
|
||||
$PAY"
|
||||
sms_SEND "$PHONE" "$mess"
|
||||
log_history "$PHONE" "VIR, $VIR, $DESTRIB, $DESTMEM"
|
||||
# Send DESTPHONE sms
|
||||
if [[ "$DESTPHONE" != "" ]]; then
|
||||
sms_SEND "$DESTPHONE" "Bonjour $DESTMEM. Vous venez de recevoir un virement de $AMOUNT $UNIT ($VIR G1) de la part de $member portefeuille $UIDNA"
|
||||
fi
|
||||
cents=$(echo $(bc -l <<< "scale=0; $VIR * 100") | cut -d '.' -f 1)
|
||||
move_g1cents "$PHONE" "$DESTRIB" "$cents"
|
||||
else
|
||||
new=$(./shell/checknodes.sh "BAN")
|
||||
sms_SEND "$ADMINPHONE" "ADMIN! Problème de payement avec silkaj (changement de serveur $new): $PAY";
|
||||
fi
|
||||
else
|
||||
log "__SUB:sms_VIR.sh: ERROR $MEMBER: $DESTMEM DESTRIB NOT FOUND"
|
||||
mess="[G1sms+] Virement annulé...
|
||||
Membre: $DESTMEM inconnu! Vérifiez son existence."
|
||||
sms_SEND "$PHONE" "$mess"
|
||||
fi
|
||||
|
||||
log "__SUB:sms_VIR.sh: END ~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
|
||||
exit
|
||||
|
|
@ -0,0 +1,56 @@
|
|||
#!/bin/bash
|
||||
################################################################################
|
||||
# Author: Fred (support@qo-op.com)
|
||||
# Version: 0.1
|
||||
# License: AGPL-3.0 (https://choosealicense.com/licenses/agpl-3.0/)
|
||||
################################################################################
|
||||
# is there ADMINPSEUDO-UIDNATAIL in ./wallets_swarm/.*/*.uidna ?"
|
||||
source ./shell/init.sh
|
||||
source ./shell/functions.sh
|
||||
log "__SUB:sms_WHERE.sh: START ($1=PHONE $2=askeduidna)"
|
||||
|
||||
phone="$1"
|
||||
askeduidna="$2"
|
||||
|
||||
# Initialise PHONE, PIN, PUBKEY, UIDNA, UIDNAFILE ...
|
||||
sms_INIT_ACCOUNT "$phone" "NOSMS"
|
||||
if [[ "$UNKNOWN" == "unknown" ]]; then
|
||||
sms_ERROR "$phone" "Porte-monnaie non identifié!
|
||||
Envoyez N pour créer votre portefeuille G1sms"
|
||||
exit
|
||||
fi
|
||||
|
||||
if [[ "$askeduidna" == "" ]]; then #SELF
|
||||
if [[ -f "./wallets/.$IPFSNODEID/$IPFSNODEID.uidna" ]]; then
|
||||
nodeuidnafile="./wallets/.$IPFSNODEID/$IPFSNODEID.uidna"
|
||||
uidna=$(cat $nodeuidnafile)
|
||||
fi
|
||||
else
|
||||
nodeuidnafile=$(grep -Rwl "$askeduidna" ./wallets_swarm/.*/*.uidna)
|
||||
uidna=$(cat $nodeuidnafile)
|
||||
fi
|
||||
|
||||
if [[ -f $nodeuidnafile && "$uidna" != "" ]]; then
|
||||
ipfsnodeid=$(echo $nodeuidnafile | cut -d '/' -f 3 | cut -d '.' -f 2 )
|
||||
echo $uidna > ./wallets/$PHONE/uidna.G1TAGNODE
|
||||
echo $ipfsnodeid > ./wallets/$PHONE/ipfsid.G1TAGNODE
|
||||
log "__SUB:sms_WHERE.sh: Distributeur de G1Tag $uidna : $ipfsnodeid "
|
||||
I=$(ipfs_node_wallets_add)
|
||||
log_history $PHONE "G1TagNode, $uidna, $ipfsnodeid"
|
||||
else
|
||||
log "__SUB:sms_WHERE.sh: ERROR Distributeur de G1Tag $askeduidna inconnu ???"
|
||||
sms_ERROR "$PHONE" "Désolé. Aucun Distributeur de G1Tag : $askeduidna !!!"
|
||||
log "__SUB:sms_WHERE.sh: END ~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
|
||||
exit
|
||||
fi
|
||||
|
||||
mess="[G1sms+] $MEMBER
|
||||
Votre distributeur de G1Tag par défaut est
|
||||
$uidna ($ipfsnodeid), situé:
|
||||
$(cat ./wallets_swarm/.$ipfsnodeid/$ipfsnodeid.where)"
|
||||
|
||||
sms_SEND "$PHONE" "$mess"
|
||||
|
||||
|
||||
log "__SUB:sms_WHERE.sh: END ~~~~~~~~~~~~~~~~~~~~~~~~~~~~"
|
||||
exit
|
||||
|
|
@ -0,0 +1,164 @@
|
|||
#!/bin/bash
|
||||
################################################################################
|
||||
# Author: Fred (support@qo-op.com)
|
||||
# Version: 0.1
|
||||
# License: AGPL-3.0 (https://choosealicense.com/licenses/agpl-3.0/)
|
||||
###########################################################################################
|
||||
# LOAD MUSIC FILE IN G1TAG... + SHELL OPCODE INJECTED INTO G1TAG
|
||||
# sudo pip3 install duniterpy
|
||||
###########################################################################################
|
||||
# ipfs ls /ipns/QmY6ooFcsGXY4VSindqKMz9GvrprFXY32RrsTmqvVTYQX5
|
||||
# QmZ3RfWk1u5LEGYLHA633B5TNJy3Du27K6Fny9wcxpowGS 4 TAG_amount
|
||||
# QmXizDydPuiBd1V7JBVY5kdppShm9xdk2aoYj7c8V8Foxe 47 TAG_chain
|
||||
# QmeHHBZKtLJHr11rwXKeimwDE4i3nLMy2VPkWZsNaFasg1 4 TAG_currency
|
||||
# QmSjBDpjnoxnQT5RWRnyLxqwE3ovSRVb7xjwZoiufZAv3E 39 TAG_id
|
||||
# QmUQcSjQx2bg4cSe2rUZyQi6F8QtJFJb74fWL7D784UWf9 2 TAG_n
|
||||
# QmdbdBWv4SygqaaeWHAvABiQAa3faf4ncfSyzRnx8BDdCc 20 TAG_nanodate
|
||||
# QmbN6gNM2vjLj7yaJ6xJcySDxmuSK2eB9ZDv5dpj2bo5pM 47 TAG_nodeid
|
||||
# QmXaMzRqhEs4cQMRN18FWaCeqGmrDBfV8hTkbfQuBCXnnA 1243 TAG_publishkey.swarm.crypt
|
||||
# QmWHsRZCTSjSxnp1Qm8WcmHNNQTJwDS2ukLE7NTccc3Kp9 1304 TAG_publishkey.B.gpg
|
||||
# TAG_passenger, TAG_file is used to attach G1Tag to file.
|
||||
# ADD A PASSENGER FILE (Web2.0ID) INTO a G1Tag + Add INIT credit/debit values to live in SWARM.
|
||||
# GRAB a G1Tag CAPSULE + PUT A PASSENGER MUSIC FILE IN IT
|
||||
#### TODO USE "ipfs dag" + json
|
||||
# {
|
||||
# "type": "REC_YOUTUBE",
|
||||
# "search": "${MUSICFILE}",
|
||||
# "id": "vLXHXGoXuBU",
|
||||
# "title": "Tale Of Us - Oliver Koletzki - Miss Monique - More Artist • New Life III (DifferentSound Mix)",
|
||||
# "size": 123,
|
||||
# "debit": 10,
|
||||
# "credit": 1,
|
||||
# "file": {
|
||||
# "ld": "LDhashIPFS",
|
||||
# "sd": "SDhashIPFS",
|
||||
# "hd": "HDhashIPFS"
|
||||
# },
|
||||
# "g1tag": "RR",
|
||||
# "ipns": "J",
|
||||
# "ld": "ZEN",
|
||||
# "sd": "ZEN",
|
||||
# "hd": "EUR"
|
||||
# }
|
||||
#
|
||||
#############################################################################################################
|
||||
# ./shell/tag_LOAD_passenger.sh G1TagIPNS FileID MusicFile MASTERKEY
|
||||
JSOURCE=$1
|
||||
TUBEID=$2
|
||||
MUSICFILE=$3
|
||||
KEYFILE=$4
|
||||
# EXTENSION (Define Debit for Hosting / Credit for Reading)
|
||||
DEB=$5
|
||||
CRED=$6
|
||||
if [[ ! $DED ]]; then DED=10; fi
|
||||
if [[ ! $CRED ]]; then CRED=1; fi
|
||||
if [[ ! -f "$KEYFILE" || ! -f "$MUSICFILE" || ! -f "./g1sms.pub.key" ]]; then "Do you know what you are doing? MUSICFILE=$MUSICFILE? KEYFILE=$KEYFILE?"; exit; fi
|
||||
|
||||
#############################################
|
||||
############## INIT & root check
|
||||
NANODATE=$(date -u +%s%N)
|
||||
echo "__SUB:tag_LOAD_passenger.sh: LOAD \"$MUSICFILE\" into REC G1Tag $JSOURCE indexed by $TUBEID (using $KEYFILE)... $NANODATE"
|
||||
if [[ "$USER" != "root" ]]; then echo "__SUB:tag_LOAD_passenger.sh: Hey, $USER you must be root. 'sudo ./shell/tag_LOAD_passenger.sh ...' ?"; exit; fi
|
||||
|
||||
#############################################
|
||||
############## CHECK ipfs daemon user
|
||||
YOU=$(ps aux --sort=+utime | grep ipfs | tail -n 1 | cut -d " " -f 1)
|
||||
if [[ "$YOU" == "" || "$YOU" == "root" ]]; then echo "__SUB:tag_LOAD_passenger.sh: BAD IPFS. Aucune installation IPFS satisfaisante ici... Ciao $YOU !"; exit; fi
|
||||
IPFSNODEID=$(su $YOU -c "ipfs id -f='<id>\n'")
|
||||
|
||||
######################################################
|
||||
############## EXTRACT $JSOURCERR key, amount, nodeid
|
||||
JSOURCERR=$(su $YOU -c "ipfs cat /ipns/$JSOURCE/TAG_id | sed s/\ //g");
|
||||
if [[ "$JSOURCERR" == "" ]]; then echo "__SUB:tag_LOAD_passenger.sh: G1TAG DETRUIT. Aucun G1Tag /ipns/$JSOURCERR ici... Ciao."; exit; fi
|
||||
mkdir -p ./TAG/${JSOURCERR}; rm -f ./TAG/${JSOURCERR}/*
|
||||
echo "__SUB:tag_LOAD_passenger.sh: LOG. Hey You get a G1Tag!! GET IT now: ipfs get --output=./TAG/${JSOURCERR}/ /ipns/$JSOURCE"
|
||||
chown -R $YOU ./TAG/${JSOURCERR}/
|
||||
su $YOU -c "ipfs get --output=./TAG/${JSOURCERR}/ /ipns/$JSOURCE" 2>&1
|
||||
JSOURCEPUBLISHKEY="./TAG/${JSOURCERR}/TAG_publishkey.swarm.crypt"
|
||||
JSOURCEVALUE=$(cat ./TAG/${JSOURCERR}/TAG_amount)
|
||||
TAGNODEID=$(cat ./TAG/${JSOURCERR}/TAG_nodeid)
|
||||
TAGPASSENGER="./TAG/${JSOURCERR}/TAG_passenger" # contains HASH for PASSENGER FILE (CRYPT & PUBLISH)
|
||||
|
||||
#############################################
|
||||
# CAN IT LOAD PASSENGER ?
|
||||
if [[ ! -f $TAGPASSENGER ]]; then
|
||||
echo "__SUB:tag_LOAD_passenger.sh: G1TAG transmis pas encore transformé en REC TAG... Ciao $YOU !";
|
||||
exit
|
||||
else
|
||||
passenger=$(cat $TAGPASSENGER)
|
||||
if [[ "$passenger" != "READY" ]]; then echo "__SUB:tag_LOAD_passenger.sh: REC TAG not READY ($passenger)!"; exit; # COMMENT TO ALLOW REWRITE
|
||||
fi
|
||||
fi
|
||||
|
||||
#############################################
|
||||
# ONLY CREATOR NODE CAN LOAD G1TAG
|
||||
if [[ "$IPFSNODEID" != "$TAGNODEID" ]]; then
|
||||
echo "__SUB:tag_LOAD_passenger.sh: Ce G1Tag est géré par $TAGNODEID (vous êtes $IPFSNODEID)"
|
||||
exit
|
||||
fi
|
||||
|
||||
#############################################
|
||||
############## EXTRACT $JSOURCERR PUBLISH KEY
|
||||
if [[ -f "$KEYFILE" ]]; then
|
||||
./shell/natools.py decrypt -k "$KEYFILE" -i "$JSOURCEPUBLISHKEY" -o "/home/$YOU/.ipfs/keystore/$JSOURCERR"
|
||||
else
|
||||
echo "__SUB:tag_LOAD_passenger.sh: KO. La clef $KEYFILE fournie pour ce G1Tag $JSOURCERR est inexistante. Procurez-vous un portefeuille monnaie libre sur https://g1sms.fr"
|
||||
exit
|
||||
fi
|
||||
|
||||
#############################################
|
||||
############## G1TAG OPERATION
|
||||
NN=$(cat ./TAG/${JSOURCERR}/TAG_n); ((NN++)); echo "$NN" > "./TAG/${JSOURCERR}/TAG_n"
|
||||
|
||||
TAGTYPE="./TAG/${JSOURCERR}/TAG_type" # contains PASSENGER TYPE ("" = G1, YOUTUBE, any "REC SRC")
|
||||
TAGPASSENGERID="./TAG/${JSOURCERR}/TAG_passenger_id" # contains PASSENGER ID (depending TYPE) YoutubeID,
|
||||
|
||||
TAGPASSENGERCRYPT="./TAG/${JSOURCERR}/TAG_passenger.crypt" # contains HASH for PASSENGER FILE natools crypt with MASTERKEY
|
||||
TAGPASSENGERDEBIT="./TAG/${JSOURCERR}/TAG_passenger_debit" # Countains amount Passenger is Paying Daily to SWARM IPFS Nodes (PIN)
|
||||
TAGPASSENGERCREDIT="./TAG/${JSOURCERR}/TAG_passenger_credit" # Countains amount Node G1Tag must pay to PLAY file passenger
|
||||
TAGPASSENGERSIZE="./TAG/${JSOURCERR}/TAG_passenger_size" # contains File Size in Mo
|
||||
|
||||
echo "REC" > $TAGTYPE
|
||||
echo "$TUBEID" > $TAGPASSENGERID
|
||||
|
||||
IFILE=$(su $YOU -c "ipfs add \"${MUSICFILE}\" | tail -n 1")
|
||||
if [[ ! $IFILE ]]; then exit; fi
|
||||
echo "$IFILE" > $TAGPASSENGER
|
||||
# ONLY SWARM KEY CAN DECRYPT IPFS LINK TO FILE (TODO: Glue better)
|
||||
NODE_G1PUBKEY=$(cat "./g1sms.pub.key")
|
||||
./shell/natools.py encrypt -p "$NODE_G1PUBKEY" -i "$TAGPASSENGER" -o "$TAGPASSENGERCRYPT"
|
||||
echo "LOADED" > $TAGPASSENGER
|
||||
|
||||
echo "$DEB" > $TAGPASSENGERDEBIT
|
||||
echo "$CRED" > $TAGPASSENGERCREDIT
|
||||
|
||||
#############################################
|
||||
echo "${NANODATE}" > "./TAG/${JSOURCERR}/TAG_nanodate"
|
||||
I=$(su $YOU -c "ipfs add -qr ./TAG/${JSOURCERR} | tail -n 1")
|
||||
# RECORD TAG_chain And HASH again before publish
|
||||
echo "$I" > "./TAG/${JSOURCERR}/TAG_chain"
|
||||
I=$(su $YOU -c "ipfs add -qr ./TAG/${JSOURCERR} | tail -n 1")
|
||||
# IPNS $JSOURCERR PUBLISH
|
||||
J=$(su $YOU -c "ipfs name publish -k ${JSOURCERR} --quieter /ipfs/${I}")
|
||||
# TODO rm "/home/$YOU/.ipfs/keystore/$JSOURCERR"
|
||||
|
||||
# WRITE FILE REC INDEX IN NODE G1TAG REF.
|
||||
mkdir -p ./wallets/.$IPFSNODEID/TAG/
|
||||
echo "$TUBEID" > "./wallets/.$IPFSNODEID/TAG/${J}.youtubeid"
|
||||
|
||||
##########################
|
||||
# REFRESH SWARM
|
||||
##########################
|
||||
IWALLETS=$(su $YOU -c "ipfs add -rHq './wallets' | tail -n 1")
|
||||
|
||||
# CHAIN STATE FOR $IPFSNODEID
|
||||
echo $IWALLETS > ./wallets/.$IPFSNODEID.wallets.chain
|
||||
echo "__SUB:tag_LOAD_passenger.sh: NEW './wallets' HASH ipfs ls $IWALLETS"
|
||||
|
||||
# PUBLISH IPNS NODE WALLETS
|
||||
NODEWALLETS=$(su $YOU -c "ipfs name publish --quieter /ipfs/$IWALLETS")
|
||||
echo "__SUB:tag_LOAD_passenger.sh: YOUTUBE REC G1 TAG LOADED ($TAGPASSENGERCRYPT) <<<<<< https://youtube.com/watch?v=$TUBEID"
|
||||
echo "__SUB:tag_LOAD_passenger.sh: ipfs cat /ipns/$NODEWALLETS/.$IPFSNODEID/TAG/${J}.youtubeid"
|
||||
exit
|
||||
echo "__SUB:tag_LOAD_passenger.sh: ZEN BALANCE: $JSOURCEVALUE Zen. HEB: $DEB / PLAY: $CRED"
|
||||
exit
|
||||
|
|
@ -0,0 +1,168 @@
|
|||
#!/bin/bash
|
||||
################################################################################
|
||||
# Author: Fred (support@qo-op.com)
|
||||
# Version: 0.2020
|
||||
# License: AGPL-3.0 (https://choosealicense.com/licenses/agpl-3.0/)
|
||||
###########################################################################################
|
||||
# tag_OP.sh OPERATION ON G1TAG...
|
||||
# sudo pip3 install duniterpy
|
||||
###########################################################################################
|
||||
# ipfs ls /ipns/QmY6ooFcsGXY4VSindqKMz9GvrprFXY32RrsTmqvVTYQX5
|
||||
# QmZ3RfWk1u5LEGYLHA633B5TNJy3Du27K6Fny9wcxpowGS 4 TAG_amount
|
||||
# QmXizDydPuiBd1V7JBVY5kdppShm9xdk2aoYj7c8V8Foxe 47 TAG_chain
|
||||
# QmeHHBZKtLJHr11rwXKeimwDE4i3nLMy2VPkWZsNaFasg1 4 TAG_currency
|
||||
# QmSjBDpjnoxnQT5RWRnyLxqwE3ovSRVb7xjwZoiufZAv3E 39 TAG_id
|
||||
# QmUQcSjQx2bg4cSe2rUZyQi6F8QtJFJb74fWL7D784UWf9 2 TAG_n
|
||||
# QmdbdBWv4SygqaaeWHAvABiQAa3faf4ncfSyzRnx8BDdCc 20 TAG_nanodate
|
||||
# QmbN6gNM2vjLj7yaJ6xJcySDxmuSK2eB9ZDv5dpj2bo5pM 47 TAG_nodeid
|
||||
# QmXaMzRqhEs4cQMRN18FWaCeqGmrDBfV8hTkbfQuBCXnnA 1243 TAG_publishkey.swarm.crypt
|
||||
# QmWHsRZCTSjSxnp1Qm8WcmHNNQTJwDS2ukLE7NTccc3Kp9 1304 TAG_publishkey.B.gpg
|
||||
# ...
|
||||
# TAG_passenger, TAG_file is used to attach G1Tag to file.
|
||||
#
|
||||
# TRANSFERT ZEN FROM G1Tag to G1Tag
|
||||
|
||||
# G1Tag J References IPNS G1 Tag link
|
||||
JSOURCE=$1
|
||||
JDEST=$2
|
||||
# Zen Amount to transfert
|
||||
VALUE=$3
|
||||
# Needed to Open ipfs publish Key
|
||||
KEYFILE=$4
|
||||
|
||||
############################################
|
||||
############## INIT & root check
|
||||
NANODATE=$(date -u +%s%N)
|
||||
echo "__SUB:tag_OP.sh: TRANSFER from $JSOURCE (1) to $JDEST (2) G1Tag = $VALUE (3) using \"$KEYFILE\" (4)... GO... $NANODATE"
|
||||
if [[ "$USER" != "root" ]]; then echo "__SUB:tag_OP.sh: Hey, $USER you must at least be admin of your system. sudo -s ?"; exit; fi
|
||||
|
||||
#############################################
|
||||
############## CHECK ipfs daemon user
|
||||
YOU=$(ps aux --sort=+utime | grep ipfs | tail -n 1 | cut -d " " -f 1)
|
||||
if [[ "$YOU" == "" || "$YOU" == "root" ]]; then echo "__SUB:tag_OP.sh: BAD IPFS. Aucune installation IPFS satisfaisante ici... Ciao $YOU !"; exit; fi
|
||||
IPFSNODEID=$(su $YOU -c "ipfs id -f='<id>\n'")
|
||||
|
||||
#############################################
|
||||
############## SOURCE EXTRACTION
|
||||
JSOURCERR=$(su $YOU -c "ipfs cat /ipns/$JSOURCE/TAG_id | sed s/\ //g");
|
||||
#############################################
|
||||
############## GOOD or BAD ?
|
||||
if [[ "$JSOURCERR" == "" ]]; then echo "__SUB:tag_OP.sh: G1TAG DETRUIT. Aucun G1Tag /ipns/$JSOURCERR ici... Ciao."; exit; fi
|
||||
echo "__SUB:tag_OP.sh: LOG. SOURCE G1Tag OK!! GREAT... Retrieving it all: ipfs get --output=./TAG/${JSOURCERR}/ /ipns/$JSOURCE"
|
||||
mkdir -p ./TAG/${JSOURCERR}; rm -f ./TAG/${JSOURCERR}/*
|
||||
chown -R $YOU ./TAG/${JSOURCERR}/
|
||||
su $YOU -c "ipfs get --output=./TAG/${JSOURCERR}/ /ipns/$JSOURCE"
|
||||
JSOURCEPUBLISHKEY="./TAG/${JSOURCERR}/TAG_publishkey.swarm.crypt"
|
||||
JSOURCEVALUE=$(cat ./TAG/${JSOURCERR}/TAG_amount);
|
||||
|
||||
#############################################
|
||||
############## No JDEST, then return $JSOURCEVALUE
|
||||
if [[ "$JDEST" == "" ]]; then echo "__SUB:tag_OP.sh: OK. G1Tag $JSOURCE VALUE = $JSOURCEVALUE Zen"; exit; fi
|
||||
|
||||
#############################################
|
||||
############## TEST IF $VALUE IS AVAILABLE
|
||||
FINALSOURCE=$( echo "${JSOURCEVALUE} - ${VALUE}" | bc -l )
|
||||
if [[ $FINALSOURCE -lt 0 ]]; then echo "__SUB:tag_OP.sh: KO. La valeur de ce G1Tag ne peut pas être : $FINALSOURCE Zen... Ciao $YOU !"; exit; fi
|
||||
|
||||
#############################################
|
||||
############## EXTRACT $JSOURCERR PUBLISH KEY
|
||||
if [[ -f $KEYFILE && ! -f "/home/$YOU/.ipfs/keystore/$JSOURCERR" ]]; then
|
||||
./shell/natools.py decrypt -k "$KEYFILE" -i "$JSOURCEPUBLISHKEY" -o "/home/$YOU/.ipfs/keystore/$JSOURCERR"
|
||||
else
|
||||
if [[ ! -f $KEYFILE ]]; then
|
||||
echo "__SUB:tag_OP.sh: KO. La clef de dévérouillage pour $JSOURCERR est inexistante. Contact: https://g1sms.fr"
|
||||
fi
|
||||
fi
|
||||
|
||||
#############################################
|
||||
############## DESTINATION EXTRACTION
|
||||
JDESTRR=$(su $YOU -c "ipfs cat /ipns/$JDEST/TAG_id | sed s/\ //g");
|
||||
if [[ "$JDESTRR" == "" ]]; then echo "__SUB:tag_OP.sh: BAD G1TAG. Aucun G1Tag /ipns/$JDESTRR ici... Ciao."; exit; fi
|
||||
mkdir -p ./TAG/${JDESTRR}; rm -f ./TAG/${JDESTRR}/*
|
||||
echo "__SUB:tag_OP.sh: LOG. Hey You get a G1Tag!! GREAT... ipfs get --output=./TAG/${JDESTRR}/ /ipns/$JDEST"
|
||||
chown -R $YOU ./TAG/${JDESTRR}/
|
||||
su $YOU -c "ipfs get --output=./TAG/${JDESTRR}/ /ipns/$JDEST"
|
||||
JDESTPUBLISHKEY="./TAG/${JDESTRR}/TAG_publishkey.swarm.crypt"
|
||||
JDESTVALUE=$(cat ./TAG/${JDESTRR}/TAG_amount);
|
||||
FINALDEST=$(echo "${JDESTVALUE} + ${VALUE}" | bc -l)
|
||||
# EXTRACT $JSOURCERR PUBLISH KEY to "/home/$YOU/.ipfs/keystore/JSOURCE"
|
||||
# EXTRACT PUBLISH KEY
|
||||
if [[ -f $KEYFILE && ! -f "/home/$YOU/.ipfs/keystore/$JDESTRR" ]]; then
|
||||
./shell/natools.py decrypt -k "$KEYFILE" -i "$JDESTPUBLISHKEY" -o "/home/$YOU/.ipfs/keystore/$JDESTRR"
|
||||
else
|
||||
if [[ ! -f $KEYFILE ]]; then
|
||||
echo "__SUB:tag_OP.sh: KO. La clef de dévérouillage pour $JDESTRR est inexistante. Contact: https://g1sms.fr"
|
||||
fi
|
||||
fi
|
||||
|
||||
######################################################################################################
|
||||
if [[ -f "/home/$YOU/.ipfs/keystore/$JDESTRR" && -f "/home/$YOU/.ipfs/keystore/$JSOURCERR" ]]; then
|
||||
# IF PUBLISH key for BOTH G1TAG exists
|
||||
#############################################
|
||||
############## SOURCE OPERATION
|
||||
NN=$(cat ./TAG/${JSOURCERR}/TAG_n); ((NN++)); echo "$NN" > "./TAG/${JSOURCERR}/TAG_n"
|
||||
#############################################
|
||||
# Destroy B Access ?!!
|
||||
#rm -f ./TAG/${JSOURCERR}/TAG_publishkey.B.gpg
|
||||
echo "$FINALSOURCE" > "./TAG/${JSOURCERR}/TAG_amount"
|
||||
echo "${NANODATE}" > "./TAG/${JSOURCERR}/TAG_nanodate" # TODO: ACTIVATE NANODATE CONTROL / NODES MEDIANTIME
|
||||
echo "${IPFSNODEID}" > "./TAG/${JSOURCERR}/TAG_writerid"
|
||||
|
||||
if [[ "$JSOURCE" == "$JDEST" ]]; then
|
||||
# PUT "READY" IN TAG_passenger (can now be loaded with a file), now actual IPFSNODEID is creator
|
||||
echo "READY" > "./TAG/${JSOURCERR}/TAG_passenger"
|
||||
echo "${IPFSNODEID}" > "./TAG/${JSOURCERR}/TAG_nodeid"
|
||||
echo "__SUB:tag_OP.sh: ${IPFSNODEID} NODE created REC TAG. ${JSOURCERR}. READY to LOAD_passenger now!!"
|
||||
fi
|
||||
|
||||
SOURCENODEID=$(cat "./TAG/${JSOURCERR}/TAG_nodeid")
|
||||
I=$(su $YOU -c "ipfs add -qr ./TAG/${JSOURCERR} | tail -n 1")
|
||||
# RECORD TAG_chain And HASH again
|
||||
echo "$I" > "./TAG/${JSOURCERR}/TAG_chain"
|
||||
I=$(su $YOU -c "ipfs add -qr ./TAG/${JSOURCERR} | tail -n 1")
|
||||
# IPNS $JSOURCERR PUBLISH
|
||||
J=$(su $YOU -c "ipfs name publish -k ${JSOURCERR} --quieter /ipfs/${I}")
|
||||
# CLEAN IPFS keystore
|
||||
if [[ "${SOURCENODEID}" != "${IPFSNODEID}" ]]; then
|
||||
rm -f "/home/$YOU/.ipfs/keystore/$JSOURCERR"
|
||||
fi
|
||||
echo "__SUB:tag_OP.sh: G1Tag $JSOURCERR value ($FINALSOURCE) :: su $YOU -c \"ipfs cat /ipns/$JSOURCE/TAG_amount\""
|
||||
|
||||
if [[ "$JSOURCE" != "$JDEST" ]]; then
|
||||
#############################################
|
||||
############## DESTINATION OPERATION
|
||||
NN=$(cat ./TAG/${JDESTRR}/TAG_n); ((NN++)); echo "$NN" > "./TAG/${JDESTRR}/TAG_n"
|
||||
#############################################
|
||||
# Destroy B Access ?!!
|
||||
#rm -f ./TAG/${JDESTRR}/TAG_publishkey.B.gpg
|
||||
echo "${FINALDEST}" > "./TAG/${JDESTRR}/TAG_amount"
|
||||
##############################################################################################################################
|
||||
if [[ $FINALSOURCE -eq 0 ]]; then
|
||||
echo "OK. G1Tag ${JSOURCERR} is empty destroying it!!";
|
||||
rm -f "./TAG/${JDESTRR}/TAG_id";
|
||||
fi
|
||||
##############################################################################################################################
|
||||
echo "${NANODATE}" > "./TAG/${JDESTRR}/TAG_nanodate"
|
||||
echo "${IPFSNODEID}" > "./TAG/${JDESTRR}/TAG_writerid"
|
||||
DESTNODEID=$(cat "./TAG/${JDESTRR}/TAG_nodeid")
|
||||
I=$(su $YOU -c "ipfs add -qr ./TAG/${JDESTRR} | tail -n 1")
|
||||
# RECORD TAG_chain And HASH again
|
||||
echo "$I" > "./TAG/${JDESTRR}/TAG_chain"
|
||||
I=$(su $YOU -c "ipfs add -qr ./TAG/${JDESTRR} | tail -n 1")
|
||||
# IPNS $JDESTRR PUBLISH
|
||||
J=$(su $YOU -c "ipfs name publish -k ${JDESTRR} --quieter /ipfs/${I}")
|
||||
if [[ "${DESTNODEID}" != "${IPFSNODEID}" ]]; then
|
||||
rm -f "/home/$YOU/.ipfs/keystore/$JDESTRR"
|
||||
fi
|
||||
echo "__SUB:tag_OP.sh: G1Tag $JDESTRR value ($FINALDEST) :: su $YOU -c \"ipfs cat /ipns/$JDEST/TAG_amount\""
|
||||
fi
|
||||
|
||||
echo "__SUB:tag_OP.sh: DONE. G1Tag balance updated:
|
||||
$JSOURCERR (/ipns/$JSOURCE) : $JSOURCEVALUE => $FINALSOURCE
|
||||
$JDESTRR (/ipns/$JSDEST) : $JDESTVALUE) => $FINALDEST"
|
||||
|
||||
else
|
||||
echo "__SUB:tag_OP.sh: NO OPERATION DONE"
|
||||
|
||||
fi
|
||||
######################################################################################################
|
||||
|
|
@ -0,0 +1,68 @@
|
|||
#!/bin/bash
|
||||
################################################################################
|
||||
# Author: Fred (support@qo-op.com)
|
||||
# Version: 0.1
|
||||
# License: AGPL-3.0 (https://choosealicense.com/licenses/agpl-3.0/)
|
||||
###########################################################################################
|
||||
# Find and PLAY (cat) passenger File OF G1Tag / REC TAG
|
||||
# sudo pip3 install duniterpy
|
||||
# READERID is PHONE or IPFSNODEID (G1 ./wallets/* )
|
||||
# JSOURCE is G1Tag IPNS link with PASSENGER
|
||||
###########################################################################################
|
||||
READERID=$1
|
||||
JSOURCE=$2
|
||||
KEYFILE="./g1sms.priv.key"
|
||||
NODE_G1PUBKEY=$(cat "./g1sms.pub.key")
|
||||
|
||||
if [[ ! $READERID || ! $JSOURCE || ! -f "$KEYFILE" || ! $NODE_G1PUBKEY ]]; then "Something is wrong! Do you know what you are doing?"; exit; fi
|
||||
|
||||
NODEG1TAG=$(cat "./wallets_swarm/.$READERID/TAG/$READERID") # Contains IPNS link to Node G1Tag
|
||||
if [[ ! $NODEG1TAG ]]; then
|
||||
# INIT NODE G1TAG WITH 1000 zen
|
||||
echo "__SUB:tag_PLAY_passenger.sh: $READERID ne possède pas de G1Tag sudo ./shell/sms_G1TAG.sh \"$READERID\" \"10\" \"1\" \"NODE\" \"$READERID\" "
|
||||
exit
|
||||
fi
|
||||
|
||||
#############################################
|
||||
############## INIT & root check
|
||||
NANODATE=$(date -u +%s%N)
|
||||
echo "__SUB:tag_PLAY_passenger.sh: $READERID IS READING $JSOURCE"
|
||||
|
||||
#############################################
|
||||
############## CHECK ipfs daemon user
|
||||
YOU=$(ps aux --sort=+utime | grep ipfs | tail -n 1 | cut -d " " -f 1)
|
||||
if [[ "$USER" != "root" ]]; then echo "__SUB:tag_PLAY_passenger.sh: Hey, $USER you must able to be root for now (try if sudo access is ok)"; fi
|
||||
if [[ "$YOU" == "" || "$YOU" == "root" ]]; then echo "__SUB:tag_PLAY_passenger.sh: BAD IPFS. Aucune installation IPFS satisfaisante ici... Ciao $USER !"; exit; fi
|
||||
IPFSNODEID=$(su $YOU -c "ipfs id -f='<id>\n'")
|
||||
|
||||
#############################################
|
||||
JSOURCERR=$(su $YOU -c "ipfs cat /ipns/$JSOURCE/TAG_id | sed s/\ //g");
|
||||
if [[ "$JSOURCERR" == "" ]]; then echo "__SUB:tag_PLAY_passenger.sh: G1TAG DETRUIT. Aucun G1Tag /ipns/$JSOURCERR ici... Ciao."; exit; fi
|
||||
mkdir -p ./TAG/${JSOURCERR}; rm -f ./TAG/${JSOURCERR}/*
|
||||
echo "__SUB:tag_PLAY_passenger.sh: FOUND G1Tag... GETTING IT: ipfs get --output=./TAG/${JSOURCERR}/ /ipns/$JSOURCE"
|
||||
chown -R $YOU ./TAG/${JSOURCERR}/
|
||||
su $YOU -c "ipfs get --output=./TAG/${JSOURCERR}/ /ipns/$JSOURCE"
|
||||
JSOURCEPUBLISHKEY="./TAG/${JSOURCERR}/TAG_publishkey.swarm.crypt"
|
||||
|
||||
TAGZEN=$(cat "./TAG/${JSOURCERR}/TAG_amount");
|
||||
DEB=$(cat "./TAG/${JSOURCERR}/TAG_passenger_debit")
|
||||
CRED=$(cat "./TAG/${JSOURCERR}/TAG_passenger_credit")
|
||||
|
||||
##############################################
|
||||
# MAKE TRANSACTIONS
|
||||
NODEZEN=$(cat "./wallets/$READERID/$READERID.g1cents")
|
||||
uidna=$(cat "./wallets/$READERID/$READERID.uidna")
|
||||
if [[ $ZEN -gt $CRED ]]; then
|
||||
REZ=$((TAGZEN + CRED))
|
||||
|
||||
#echo "$REZ" > "./TAG/${JSOURCERR}/TAG_amount"
|
||||
# TODO READER NEEDS ITS G1TAG
|
||||
#./shell/tag_OP.sh "$READERIDTAG" "J2TAG" "$CRED" $KEYFILE
|
||||
else
|
||||
echo "Désolé ;( $READERID vous manquez de ZEN ($ZEN) pour vous payer la lecture de $JSOURCE ($CRED)"
|
||||
echo "Rechargez avec un VIREMENT vers $uidna"
|
||||
fi
|
||||
|
||||
|
||||
# READ PASSENGER
|
||||
|
||||
|
|
@ -0,0 +1,250 @@
|
|||
#!/bin/bash
|
||||
################################################################################
|
||||
# Author: Fred (support@qo-op.com)
|
||||
# Version: 0.1
|
||||
# License: AGPL-3.0 (https://choosealicense.com/licenses/agpl-3.0/)
|
||||
###########################################################################################
|
||||
###########################################################################################
|
||||
echo "__SUB:tag_READ.sh: QRCODE READER : START"
|
||||
source ./shell/init.sh
|
||||
source ./shell/functions.sh
|
||||
|
||||
# DOUCHETTE ES TU LA?
|
||||
if [ ! $G1TX ]; then ./shell/parle.sh "Branchez votre lecteur de QR code!"; exit; fi
|
||||
|
||||
# TABLEAU MEMOIRE DE SCAN
|
||||
declare -a act
|
||||
declare -a obj
|
||||
declare -a val
|
||||
./shell/parle.sh "Lecteur de G1 Tag. OK. Prêt"
|
||||
|
||||
cat /dev/ttyACM0 | while read line; do
|
||||
lon=${#line}
|
||||
pref=$(echo $line | cut -d ":" -f 1)
|
||||
qrvalue=$(echo $line | cut -d ":" -f 2)
|
||||
log "__SUB:tag_READ.sh: SCAN /dev/ttyACM0 ($lon) :: $line"
|
||||
|
||||
case $pref in
|
||||
RJ)
|
||||
./shell/parle.sh "R J"
|
||||
R=$(echo $qrvalue | cut -d '#' -f 1)
|
||||
J=$(echo $qrvalue | cut -d '#' -f 2)
|
||||
log "__SUB:tag_READ.sh: Lecture G1Tag $R $J"
|
||||
#
|
||||
ID=$(su $YOU -c "ipfs cat /ipns/$J/TAG_id");
|
||||
if [[ "$ID" == "" ]]; then
|
||||
./shell/parle.sh "G1 Tag déjà capturé, veuillez le détruire!";
|
||||
sms_SEND "$ADMINPHONE" "ADMIN! FRAUDE G1Tag RJ $R $J"
|
||||
# TODO: ENQUETER auprès du CREATEUR de ce G1 Tag !!
|
||||
continue
|
||||
fi
|
||||
RR=$(echo $ID | sed s/\ //g)
|
||||
FID=$(echo $ID | awk '{print toupper($1)}')
|
||||
RVALUE=$(su $YOU -c "ipfs cat /ipns/$J/TAG_amount");
|
||||
CURRENCY=$(su $YOU -c "ipfs cat /ipns/$J/TAG_currency" | awk '{print tolower($1)}')
|
||||
if [[ "$CURRENCY" == "zen" ]]; then CUR="zène"; else CUR=$CURRENCY; fi # Correction du défaut de prononciation.
|
||||
PASSENGER=$(su $YOU -c "ipfs cat /ipns/$J/TAG_passenger");
|
||||
if [[ "$PASSENGER" != "" ]]; then
|
||||
./shell/parle.sh "Rec Tag Machine $PASSENGER! Valeur $RVALUE $CUR";
|
||||
else
|
||||
G1VAL=$(bc -l <<< "scale=2; $RVALUE / 100" | cut -d '.' -f 1)
|
||||
log "__SUB:tag_READ.sh: G1Tag $FID. Valeur $RVALUE $CURRENCY = $G1VAL G1"
|
||||
./shell/parle.sh "G1 Tag $FID. Valeur $RVALUE $CUR convertible en $G1VAL June"
|
||||
fi
|
||||
cmd="RJ"
|
||||
CASHBACK=""
|
||||
val+=("$RVALUE")
|
||||
;;
|
||||
|
||||
BJ)
|
||||
./shell/parle.sh "B J"
|
||||
BB=$(echo $qrvalue | cut -d '#' -f 1)
|
||||
J=$(echo $qrvalue | cut -d '#' -f 2)
|
||||
log "__SUB:tag_READ.sh: Ouverture G1Tag $BB $J"
|
||||
#
|
||||
ID=$(su $YOU -c "ipfs cat /ipns/$J/TAG_id");
|
||||
FID=$(echo $ID | awk '{print toupper($1)}')
|
||||
if [[ "$ID" == "" ]]; then
|
||||
./shell/parle.sh "G1 Tag inconnu! veuillez le détruire!";
|
||||
# sms_SEND "$ADMINPHONE" "ADMIN! FRAUDE G1Tag BJ $B $J"
|
||||
# TODO: ENQUETER auprès du CREATEUR de ce G1 Tag !!
|
||||
continue
|
||||
fi
|
||||
RR=$(echo $ID | sed s/\ //g)
|
||||
BVALUE=$(su $YOU -c "ipfs cat /ipns/$J/TAG_amount")
|
||||
CURRENCY=$(su $YOU -c "ipfs cat /ipns/$J/TAG_currency" | awk '{print tolower($1)}')
|
||||
if [[ "$CURRENCY" == "zen" ]]; then CUR="zène"; else CUR=$CURRENCY; fi # Correction du défaut de prononciation.
|
||||
PASSENGER=$(su $YOU -c "ipfs cat /ipns/$J/TAG_passenger");
|
||||
# DIG PUBLISHING KEY
|
||||
if [[ -f /home/$YOU/.ipfs/keystore/$RR ]]; then
|
||||
log "__SUB:tag_READ.sh: Clef de publication IPFS $RR déjà présente"
|
||||
else
|
||||
rm /tmp/TAG_publishkey.B.gpg
|
||||
su $YOU -c "ipfs get -o /tmp/ /ipns/$J/TAG_publishkey.B.gpg"
|
||||
# CHECK IF OK
|
||||
gpg -d --output /tmp/ipns.key --pinentry-mode=loopback --passphrase $BB /tmp/TAG_publishkey.B.gpg
|
||||
if [[ ! -f /tmp/ipns.key ]]; then
|
||||
./shell/parle.sh "Erreur. Problème de déchiffrage PGP ${FID}! Vérifiez vos logs";
|
||||
log "__SUB:tag_READ.sh: ERROR! gpg -d --output /tmp/ipns.key --pinentry-mode=loopback --passphrase $BB /tmp/TAG_publishkey.B.gpg"
|
||||
continue
|
||||
fi
|
||||
mv /tmp/ipns.key /home/$YOU/.ipfs/keystore/$RR
|
||||
log "__SUB:tag_READ.sh: Récupération de la clef de publication $RR"
|
||||
./shell/parle.sh "Récupération clef de publication du G1 Tag ${FID}"
|
||||
fi
|
||||
if [[ "$PASSENGER" != "" ]]; then
|
||||
log "__SUB:tag_READ.sh: !!!! REC Tag = $BVALUE $CURRENCY"
|
||||
./shell/parle.sh "Rec Tag Machine! Valeur $BVALUE $CUR";
|
||||
else
|
||||
log "__SUB:tag_READ.sh: Ce G1 Tag contient $BVALUE $CURRENCY"
|
||||
./shell/parle.sh "Ce G1 Tag contient $BVALUE $CUR"
|
||||
fi
|
||||
cmd="BJ"
|
||||
val+=("$BVALUE")
|
||||
;;
|
||||
|
||||
*)
|
||||
if [[ $lon -eq 44 ]]; then
|
||||
./shell/parle.sh "Portefeuille G1?"
|
||||
J=$qrvalue
|
||||
if [[ "$J" != "${obj[0]}" ]]; then
|
||||
VALUE=$(./shell/timeout.sh -t 15 ./silkaj/silkaj amount $J)
|
||||
|
||||
if [[ "$(echo $VALUE | cut -d ':' -f 1)" != "Error" && "$VALUE" != "" ]]; then
|
||||
log "__SUB:tag_READ.sh: Ce compte monnaie libre contient $VALUE G1"
|
||||
./shell/parle.sh "Ce compte monnaie libre contient $VALUE G1"
|
||||
CASHBACK="$J"
|
||||
cmd="G1"
|
||||
val+=("$VALUE")
|
||||
else
|
||||
log "__SUB:tag_READ.sh: ERREUR QR code illisible. longueur $J = ${#J}"
|
||||
if [[ "$VALUE" == "" ]]; then
|
||||
DUNITER=$(./shell/checknodes.sh 'BAN')
|
||||
echo "TIMEOUT. CHANGE SILKAJ SERVER: $DUNITER"
|
||||
./shell/parle.sh "Temps dépassé. Changement de serveur $DUNITER"
|
||||
CASHBACK=""
|
||||
else
|
||||
./shell/parle.sh "QR code inconnu."
|
||||
CASHBACK=""
|
||||
fi
|
||||
fi
|
||||
else
|
||||
./shell/parle.sh "Ce compte monnaie libre contient ${val[0]} G1"
|
||||
fi
|
||||
else
|
||||
./shell/parle.sh "QR code de type inconnu"
|
||||
fi
|
||||
|
||||
;;
|
||||
|
||||
esac
|
||||
|
||||
###############################################################
|
||||
# APRES G1 CASHBACK : G1 Tag BJ WRITE => ENCAISSEMENT
|
||||
if [[ "${cmd}" == "BJ" && "$CASHBACK" != "" && -f /home/$YOU/.ipfs/keystore/${RR} ]]; then
|
||||
./shell/parle.sh "Encaissement du G1 Tag"
|
||||
log "__SUB:tag_READ.sh: G1 tag de $BVALUE G1 ! /ipns/$J Virement vers $CASHBACK? "
|
||||
|
||||
./shell/parle.sh "vers portefeuille G1"
|
||||
# ipfs get G1Tag vers ./TAG/${RR}
|
||||
mkdir -p ./TAG/${RR}; rm -f ./TAG/${RR}/*; chown -R $YOU ./TAG/${RR}/
|
||||
log "__SUB:tag_READ.sh: ipfs get --output=./TAG/${RR} /ipns/$J"
|
||||
su $YOU -c "ipfs get --output=./TAG/${RR} /ipns/$J"
|
||||
|
||||
if [[ $(cat ./TAG/${RR}/TAG_passenger) != "" ]]; then ./shell/parle.sh "Impossible à encaisser. REC Tag ${FID}. $(cat ./TAG/${RR}/TAG_passenger) de Valeur $BVALUE "; continue; fi
|
||||
|
||||
# Make Silkaj TX
|
||||
G1VAL=$(bc -l <<< "scale=2; $BVALUE / 100" | cut -d '.' -f 1)
|
||||
log "__SUB:tag_READ.sh: Silkaj TX $SWARM_G1AUTHFILE ($G1VAL) -> $CASHBACK"
|
||||
PAY=$(./silkaj/silkaj transaction --auth-file -file="$SWARM_G1AUTHFILE" --amount=$G1VAL --output=$CASHBACK --comment="[G1sms+] CAPTURE G1Tag $RR" -y)
|
||||
|
||||
log "__SUB:tag_READ.sh: Silkaj output = $PAY"
|
||||
if [[ "$(echo $PAY | cut -d '|' -f 1)" == "KO" ]]; then
|
||||
new=$(./shell/checknodes.sh "BAN")
|
||||
sms_ERROR "$ADMINPHONE" "Il est survenu un problème avec un virement. Retour silkaj: $PAY ... $new";
|
||||
./shell/parle.sh "Erreur de virement. Changement de serveur Duniter. Veuillez recommencer"
|
||||
else
|
||||
# ENCAISSEMENT G1Tag
|
||||
./shell/parle.sh "Transfert du Tag ${FID} de $G1VAL G1 vers portefeuille OK"
|
||||
# CAPTURE / DESTRUCTION du G1 Tag
|
||||
echo "0" > "./TAG/${RR}/TAG_amount"
|
||||
echo "${J}" > "./TAG/${RR}/TAG_ipns"
|
||||
|
||||
# Iterate
|
||||
if [[ -f ./TAG/${RR}/TAG_n ]]; then NN=$(cat ./TAG/${RR}/TAG_n); ((NN++)); else NN=0; fi
|
||||
|
||||
# TAG_actions
|
||||
echo "$NN" > "./TAG/${RR}/TAG_n"
|
||||
echo "${NANODATE}" > "./TAG/${RR}/TAG_nanodate"
|
||||
echo "${IPFSNODEID}" > "./TAG/${RR}/TAG_writerid"
|
||||
|
||||
# EMPTY G1TAG ID AND REMOVE PUBLISHKEYS
|
||||
echo "" > "./TAG/${RR}/TAG_id"
|
||||
rm -f ./TAG/TAG_publishkey.*
|
||||
|
||||
log "__SUB:tag_READ.sh: Destruction G1Tag TAG_id $NN.${NANODATE} (par NODE ${IPFSNODEID}) => Value = 0"
|
||||
I=$(su $YOU -c "ipfs add -qr ./TAG/${RR} | tail -n 1")
|
||||
# TAG_chain
|
||||
echo "$I" > "./TAG/${RR}/TAG_chain"
|
||||
I=$(su $YOU -c "ipfs add -qr ./TAG/${RR} | tail -n 1")
|
||||
# IPNS $RR PUBLISH
|
||||
J=$(su $YOU -c "ipfs name publish -k ${RR} --quieter /ipfs/${I}")
|
||||
|
||||
log "__SUB:tag_READ.sh: Destruction de ce G1 Tag publish -k ${RR} --quieter /ipfs/${I} :: ipfs ls /ipns/$J"
|
||||
./shell/parle.sh "${FID} G1 Tag vide. Merci de détruire ce G1 Tag!"
|
||||
|
||||
# CLEAN IPFS keystore: remove NOT created NODE keys
|
||||
SOURCENODEID=$(cat "./TAG/${RR}/TAG_nodeid")
|
||||
if [[ "${SOURCENODEID}" != "${IPFSNODEID}" ]]; then
|
||||
rm -f /home/$YOU/.ipfs/keystore/${RR}
|
||||
fi
|
||||
fi
|
||||
else
|
||||
# AJOUT MEMOIRE SCAN
|
||||
./shell/parle.sh "Mémorisation"
|
||||
act+=("$cmd")
|
||||
obj+=("$J")
|
||||
fi
|
||||
|
||||
|
||||
# FLUSH MEMOIRE 2 SCAN
|
||||
if [[ ${#act[@]} -eq 2 ]]; then
|
||||
echo "${act[@]}"
|
||||
echo "${obj[@]}"
|
||||
echo "${val[@]}"
|
||||
###############################################################
|
||||
# PRESENTATION RJ puis BJ différents Tag WRITE = TRANSFERT G1 TAG
|
||||
if [[ "${act[0]}" == "RJ" && "${act[1]}" == "BJ" && "${obj[0]}" != "${obj[1]}" ]]; then
|
||||
PASSENGER=$(su $YOU -c "ipfs cat /ipns/${obj[1]}/TAG_passenger");
|
||||
if [[ "$PASSENGER" != "" ]]; then
|
||||
./shell/parle.sh "Rec Tag Machine non transférable!";
|
||||
else
|
||||
log "__SUB:tag_READ.sh: Transfert de G1 Tag à G1 Tag. $BVALUE $CUR"
|
||||
./shell/parle.sh "Transfert de ${val[1]} $CUR vers le G1 Tag ${FID}"
|
||||
log "__SUB:tag_READ.sh: $(./shell/tag_OP.sh ${obj[1]} ${obj[0]} ${val[1]} $SWARM_G1AUTHFILE)"
|
||||
fi
|
||||
CASHBACK=""
|
||||
fi
|
||||
###############################################################
|
||||
# PRESENTATION BJ identiques TRANSFORMATION G1 TAG en REC TAG
|
||||
if [[ "${act[0]}" == "BJ" && "${act[1]}" == "BJ" && "${obj[0]}" == "${obj[1]}" ]]; then
|
||||
PASSENGER=$(su $YOU -c "ipfs cat /ipns/${obj[0]}/TAG_passenger");
|
||||
if [[ "$PASSENGER" != "" ]]; then
|
||||
./shell/parle.sh "Déjà Rec Tag Machine!";
|
||||
else
|
||||
log "__SUB:tag_READ.sh: Transformation du G1 Tag en Rec Tag. ${val[0]} = ${val[1]}"
|
||||
./shell/parle.sh "Transformation du G1 Tag ${val[0]} $CUR en Rec Tag chargé de ${FID}..."
|
||||
log "__SUB:tag_READ.sh: $(./shell/tag_OP.sh ${obj[0]} ${obj[0]} 0 $SWARM_G1AUTHFILE)"
|
||||
fi
|
||||
CASHBACK=""
|
||||
fi
|
||||
|
||||
act=()
|
||||
obj=()
|
||||
val=()
|
||||
./shell/parle.sh "Nouveau cycle de lecture."
|
||||
fi
|
||||
|
||||
./shell/parle.sh "Flasher un QR code"
|
||||
|
||||
done
|
||||
|
|
@ -0,0 +1,286 @@
|
|||
#!/bin/bash
|
||||
################################################################################
|
||||
# Author: Fred (support@qo-op.com)
|
||||
# Version: 0.1
|
||||
# License: AGPL-3.0 (https://choosealicense.com/licenses/agpl-3.0/)
|
||||
###########################################################################################
|
||||
###########################################################################################
|
||||
# Lit les données reçues depuis un lecteur de QR Code branché en USB/SERIE (/dev/ttyACM0)
|
||||
# Interpète les G1QRcodes et les G1Tag (R/W)
|
||||
# Saisie du montant à transférer par pavé numérique
|
||||
###########################################################################################
|
||||
echo "__SUB:tag_READ_X.sh: QRCODE READER : START"
|
||||
source ./shell/init.sh
|
||||
source ./shell/functions.sh
|
||||
|
||||
MY_PATH="`dirname \"$0\"`" # relative
|
||||
MY_PATH="`( cd \"$MY_PATH\" && pwd )`" # absolutized and normalized
|
||||
function log () {
|
||||
echo "$line
|
||||
$1" >> /tmp/tag_READ_X.log
|
||||
}
|
||||
|
||||
SWARM_G1AUTHFILE="${MY_PATH}/../g1sms.priv.key"
|
||||
if [ ! -f $SWARM_G1AUTHFILE ]; then echo "ERREUR CLEF DECHIFFRAGE!"; exit; fi
|
||||
# TODO G1TAG: USE CREATOR NODE KEY FILE INSTEAD OF SWARM_G1AUTHFILE SWARM KEY
|
||||
|
||||
# DOUCHETTE ES TU LA?
|
||||
if [ ! $G1TX ]; then echo "Branchez votre lecteur de QR code!"; exit; fi
|
||||
./shell/tools/4LETTER.scroll.py "G1TX START"
|
||||
./shell/tools/4LETTER.clock.py &
|
||||
clockpid=$!
|
||||
# TABLEAU MEMOIRE DE SCAN
|
||||
declare -a act
|
||||
declare -a obj
|
||||
declare -a val
|
||||
|
||||
cat /dev/ttyACM0 | while read line; do
|
||||
kill $clockpid
|
||||
|
||||
lon=${#line}
|
||||
pref=$(echo $line | cut -d ":" -f 1)
|
||||
qrvalue=$(echo $line | cut -d ":" -f 2)
|
||||
log "__SUB:tag_READ_X.sh: SCAN /dev/ttyACM0 ($lon) :: $line"
|
||||
|
||||
case $pref in
|
||||
RJ)
|
||||
R=$(echo $qrvalue | cut -d '#' -f 1)
|
||||
J=$(echo $qrvalue | cut -d '#' -f 2)
|
||||
log "__SUB:tag_READ_X.sh: Lecture G1Tag $R $J"
|
||||
# IPFS READ
|
||||
ID=$(su $YOU -c "ipfs cat /ipns/$J/TAG_id");
|
||||
if [[ "$ID" == "" ]]; then
|
||||
./shell/tools/4LETTER.scroll.py ">> BAD G1TAG <<"
|
||||
continue
|
||||
fi
|
||||
# Get First R Tag name word and remove space for RR
|
||||
FID=$(echo $ID | awk '{print toupper($1)}')
|
||||
RR=$(echo $ID | sed s/\ //g)
|
||||
|
||||
./shell/tools/4LETTER.scroll.py "${#act[@]} $FID > "
|
||||
RVALUE=$(su $YOU -c "ipfs cat /ipns/$J/TAG_amount");
|
||||
CURRENCY=$(su $YOU -c "ipfs cat /ipns/$J/TAG_currency" | awk '{print tolower($1)}')
|
||||
|
||||
PASSENGER=$(su $YOU -c "ipfs cat /ipns/$J/TAG_passenger");
|
||||
if [[ "$PASSENGER" != "" ]]; then
|
||||
./shell/tools/4LETTER.scroll.py "G1TAG PASSENGER $RVALUE ZEN"
|
||||
else
|
||||
G1VAL=$(bc -l <<< "scale=2; $RVALUE / 100" | cut -d '.' -f 1)
|
||||
log "__SUB:tag_READ_X.sh: G1Tag $FID. Valeur $RVALUE $CURRENCY = $G1VAL G1"
|
||||
./shell/tools/4LETTER.scroll.py "$RVALUE ZEN *** $G1VAL G1"
|
||||
fi
|
||||
cmd="RJ"
|
||||
CASHBACK=""
|
||||
val+=("$RVALUE")
|
||||
;;
|
||||
|
||||
BJ)
|
||||
BB=$(echo $qrvalue | cut -d '#' -f 1)
|
||||
J=$(echo $qrvalue | cut -d '#' -f 2)
|
||||
log "__SUB:tag_READ_X.sh: Ouverture G1Tag $BB $J"
|
||||
#
|
||||
ID=$(su $YOU -c "ipfs cat /ipns/$J/TAG_id");
|
||||
if [[ "$ID" == "" ]]; then
|
||||
./shell/tools/4LETTER.scroll.py ">> BAD G1TAG <<"
|
||||
continue
|
||||
fi
|
||||
FID=$(echo $ID | awk '{print toupper($1)}')
|
||||
RR=$(echo $ID | sed s/\ //g)
|
||||
|
||||
./shell/tools/4LETTER.scroll.py "${#act[@]} $FID TX >>"
|
||||
BVALUE=$(su $YOU -c "ipfs cat /ipns/$J/TAG_amount")
|
||||
CURRENCY=$(su $YOU -c "ipfs cat /ipns/$J/TAG_currency" | awk '{print tolower($1)}')
|
||||
|
||||
PASSENGER=$(su $YOU -c "ipfs cat /ipns/$J/TAG_passenger");
|
||||
# DIG PUBLISHING KEY
|
||||
if [[ -f /home/$YOU/.ipfs/keystore/$RR ]]; then
|
||||
log "__SUB:tag_READ_X.sh: Clef de publication IPFS $RR déjà présente"
|
||||
else
|
||||
rm /tmp/TAG_publishkey.B.gpg
|
||||
su $YOU -c "ipfs get -o /tmp/ /ipns/$J/TAG_publishkey.B.gpg"
|
||||
./shell/tools/4LETTER.scroll.py "** GPG **"
|
||||
gpg -d --output /tmp/ipns.key --pinentry-mode=loopback --passphrase $BB /tmp/TAG_publishkey.B.gpg
|
||||
# CHECK IF OK
|
||||
if [[ ! -f /tmp/ipns.key ]]; then
|
||||
./shell/tools/4LETTER.scroll.py ">> BAD GPG KEY <<"
|
||||
continue
|
||||
fi
|
||||
mv /tmp/ipns.key /home/$YOU/.ipfs/keystore/$RR
|
||||
log "__SUB:tag_READ_X.sh: Récupération de la clef de publication $RR"
|
||||
fi
|
||||
if [[ "$PASSENGER" != "" ]]; then
|
||||
log "__SUB:tag_READ_X.sh: !!!! $FID REC Tag = $BVALUE $CURRENCY"
|
||||
./shell/tools/4LETTER.scroll.py "G1TAG PASSENGER $BVALUE ZEN"
|
||||
else
|
||||
G1VAL=$(bc -l <<< "scale=2; $BVALUE / 100" | cut -d '.' -f 1)
|
||||
log "__SUB:tag_READ_X.sh: Ce G1 Tag $FID contient $BVALUE $CURRENCY"
|
||||
./shell/tools/4LETTER.scroll.py "$BVALUE ZEN *** $G1VAL G1 MAX"
|
||||
fi
|
||||
cmd="BJ"
|
||||
val+=("$BVALUE")
|
||||
;;
|
||||
|
||||
*)
|
||||
if [[ $lon -eq 44 ]]; then
|
||||
./shell/tools/4LETTER.scroll.py "PORTEFEUILLE G1 >>>>>>>> ${#act[@]}" &
|
||||
J=$qrvalue
|
||||
if [[ "$J" != "${obj[0]}" ]]; then
|
||||
VALUE=$(./shell/timeout.sh -t 25 ./silkaj/silkaj amount $J)
|
||||
|
||||
if [[ "$(echo $VALUE | cut -d ':' -f 1)" != "Error" && "$VALUE" != "" ]]; then
|
||||
log "__SUB:tag_READ_X.sh: Ce compte monnaie libre contient $VALUE G1"
|
||||
NOPOINT=$(echo $VALUE | cut -d '.' -f 1)
|
||||
./shell/tools/4LETTER.scroll.py " $NOPOINT G1 *** $NOPOINT G1 "
|
||||
CASHBACK="$J"
|
||||
cmd="G1"
|
||||
val+=("$VALUE")
|
||||
else
|
||||
if [[ "$VALUE" == "" ]]; then
|
||||
DUNITER=$(./shell/checknodes.sh 'BAN')
|
||||
log "__SUB:tag_READ_X.sh: ERREUR TIMEOUT. CHANGE SILKAJ SERVER: $DUNITER"
|
||||
./shell/tools/4LETTER.scroll.py "ERREUR TIMEOUT SILKAJ"
|
||||
./shell/timeout.sh -t 1 ./shell/tools/4LETTER.spinner.py
|
||||
CASHBACK=""
|
||||
else
|
||||
log "__SUB:tag_READ_X.sh: ERREUR QRCODE ILLISIBLE. longueur $J = ${#J}"
|
||||
./shell/tools/4LETTER.scroll.py "ERREUR QRCODE INCONNU"
|
||||
./shell/timeout.sh -t 1 ./shell/tools/4LETTER.spinner.py
|
||||
CASHBACK=""
|
||||
fi
|
||||
fi
|
||||
else
|
||||
./shell/tools/4LETTER.scroll.py " 2 X "
|
||||
fi
|
||||
else
|
||||
./shell/tools/4LETTER.scroll.py "ERREUR QRCODE INCONNU"
|
||||
fi
|
||||
|
||||
;;
|
||||
|
||||
esac
|
||||
|
||||
###############################################################
|
||||
# APRES G1 CASHBACK : G1 Tag BJ WRITE => ENCAISSEMENT
|
||||
if [[ "${cmd}" == "BJ" && "$CASHBACK" != "" && -f /home/$YOU/.ipfs/keystore/${RR} ]]; then
|
||||
./shell/tools/4LETTER.scroll.py "ZEN -> G1"
|
||||
log "__SUB:tag_READ_X.sh: G1 tag de $BVALUE G1 ! /ipns/$J Virement vers $CASHBACK? "
|
||||
|
||||
./shell/tools/4LETTER.spinner.py &
|
||||
spinnerpid=$!
|
||||
|
||||
# ipfs get G1Tag vers ./TAG/${RR}
|
||||
mkdir -p ./TAG/${RR}; rm -f ./TAG/${RR}/*; chown -R $YOU ./TAG/${RR}/
|
||||
log "__SUB:tag_READ_X.sh: ipfs get --output=./TAG/${RR} /ipns/$J"
|
||||
su $YOU -c "ipfs get --output=./TAG/${RR} /ipns/$J"
|
||||
|
||||
if [[ $(cat ./TAG/${RR}/TAG_passenger) != "" ]]; then ./shell/tools/4LETTER.scroll.py "IMPOSSIBLE TAG PASSENGER $BVALUE ZEN"; continue; fi
|
||||
|
||||
# Make Silkaj TX
|
||||
G1VAL=$(bc -l <<< "scale=2; $BVALUE / 100" | cut -d '.' -f 1)
|
||||
log "__SUB:tag_READ_X.sh: Silkaj TX $SWARM_G1AUTHFILE ($G1VAL) -> $CASHBACK"
|
||||
PAY=$(./silkaj/silkaj transaction --auth-file -file="$SWARM_G1AUTHFILE" --amount=$G1VAL --output=$CASHBACK --comment="[G1sms+] G1Tag $RR ZEN -> G1" -y)
|
||||
|
||||
log "__SUB:tag_READ_X.sh: Silkaj output = $PAY"
|
||||
# Stop 1LETTER.spinner.py
|
||||
kill $spinnerpid
|
||||
|
||||
if [[ "$(echo $PAY | cut -d '|' -f 1)" == "KO" && "$PAY" != "" ]]; then
|
||||
new=$(./shell/checknodes.sh "BAN")
|
||||
sms_ERROR "$ADMINPHONE" "Il est survenu un problème avec un virement. Retour silkaj: $PAY ... $new";
|
||||
./shell/tools/4LETTER.scroll.py "ERREUR SILKAJ ERREUR"
|
||||
else
|
||||
# ENCAISSEMENT G1Tag
|
||||
./shell/tools/4LETTER.scroll.py "VIR ${FID} $G1VAL G1 -> OK "
|
||||
# CAPTURE / DESTRUCTION du G1 Tag
|
||||
echo "0" > "./TAG/${RR}/TAG_amount"
|
||||
echo "${J}" > "./TAG/${RR}/TAG_ipns"
|
||||
|
||||
# Iterate
|
||||
if [[ -f ./TAG/${RR}/TAG_n ]]; then NN=$(cat ./TAG/${RR}/TAG_n); ((NN++)); else NN=0; fi
|
||||
|
||||
# TAG_actions
|
||||
echo "$NN" > "./TAG/${RR}/TAG_n"
|
||||
echo "${NANODATE}" > "./TAG/${RR}/TAG_nanodate"
|
||||
echo "${IPFSNODEID}" > "./TAG/${RR}/TAG_writerid"
|
||||
|
||||
# EMPTY G1TAG ID AND REMOVE PUBLISHKEYS
|
||||
echo "" > "./TAG/${RR}/TAG_id"
|
||||
rm -f ./TAG/TAG_publishkey.*
|
||||
|
||||
log "__SUB:tag_READ_X.sh: Destruction G1Tag TAG_id $NN.${NANODATE} (par NODE ${IPFSNODEID}) => Value = 0"
|
||||
I=$(su $YOU -c "ipfs add -qr ./TAG/${RR} | tail -n 1")
|
||||
# TAG_chain
|
||||
echo "$I" > "./TAG/${RR}/TAG_chain"
|
||||
I=$(su $YOU -c "ipfs add -qr ./TAG/${RR} | tail -n 1")
|
||||
# IPNS $RR PUBLISH
|
||||
J=$(su $YOU -c "ipfs name publish -k ${RR} --quieter /ipfs/${I}")
|
||||
|
||||
log "__SUB:tag_READ_X.sh: Destruction de ce G1 Tag publish -k ${RR} --quieter /ipfs/${I} :: ipfs ls /ipns/$J"
|
||||
./shell/tools/4LETTER.scroll.py "DETRUIRE G1TAG ${FID}"
|
||||
|
||||
# CLEAN IPFS keystore: remove NOT created NODE keys
|
||||
SOURCENODEID=$(cat "./TAG/${RR}/TAG_nodeid")
|
||||
if [[ "${SOURCENODEID}" != "${IPFSNODEID}" ]]; then
|
||||
rm -f /home/$YOU/.ipfs/keystore/${RR}
|
||||
fi
|
||||
fi
|
||||
else
|
||||
# AJOUT MEMOIRE SCAN
|
||||
./shell/timeout.sh -t 1 ./shell/tools/4LETTER.spinner.py
|
||||
act+=("$cmd")
|
||||
obj+=("$J")
|
||||
fi
|
||||
|
||||
|
||||
# FLUSH MEMOIRE 2 SCAN
|
||||
if [[ ${#act[@]} -eq 2 ]]; then
|
||||
echo "${act[@]}"
|
||||
echo "${obj[@]}"
|
||||
echo "${val[@]}"
|
||||
###############################################################
|
||||
# PRESENTATION RJ puis BJ différents Tag WRITE = TRANSFERT G1 TAG
|
||||
if [[ "${act[0]}" == "RJ" && "${act[1]}" == "BJ" && "${obj[0]}" != "${obj[1]}" ]]; then
|
||||
PASSENGER=$(su $YOU -c "ipfs cat /ipns/${obj[1]}/TAG_passenger");
|
||||
if [[ "$PASSENGER" != "" ]]; then
|
||||
./shell/tools/4LETTER.scroll.py "IMPOSSIBLE TAG PASSENGER";
|
||||
else
|
||||
###########################################################
|
||||
# READ KEYBOARD VALUE !!! 4 DIGIT REMOVING LEADING 0
|
||||
COMBIEN=$(./shell/tools/matrixKeypad.py | sed 's/^0*//')
|
||||
if [[ $COMBIEN -le ${val[1]} ]]; then
|
||||
COMBIENZEN=$(bc -l <<< "$COMBIEN * 100")
|
||||
log "__SUB:tag_READ_X.sh: Transfert de G1 Tag à G1 Tag. $COMBIEN"
|
||||
./shell/tools/4LETTER.scroll.py "G1TAG ${FID} -> TX $COMBIENZEN ZEN *** $COMBIEN G1"
|
||||
log "__SUB:tag_READ_X.sh: ./shell/tag_OP.sh ${obj[1]} ${obj[0]} $COMBIENZEN $SWARM_G1AUTHFILE"
|
||||
./shell/tag_OP.sh ${obj[1]} ${obj[0]} $COMBIENZEN "$SWARM_G1AUTHFILE"
|
||||
else
|
||||
./shell/tools/4LETTER.scroll.py "ERREUR $COMBIEN > VALEUR DE ${FID} *** ${val[1]} ZEN"
|
||||
fi
|
||||
fi
|
||||
CASHBACK=""
|
||||
fi
|
||||
###############################################################
|
||||
# PRESENTATION BJ identiques TRANSFORMATION G1 TAG en REC TAG
|
||||
if [[ "${act[0]}" == "BJ" && "${act[1]}" == "BJ" && "${obj[0]}" == "${obj[1]}" ]]; then
|
||||
PASSENGER=$(su $YOU -c "ipfs cat /ipns/${obj[0]}/TAG_passenger");
|
||||
if [[ "$PASSENGER" != "" ]]; then
|
||||
./shell/tools/4LETTER.scroll.py "DEJA TAG PASSENGER";
|
||||
else
|
||||
log "__SUB:tag_READ_X.sh: Transformation du G1 Tag en Rec Tag. ${val[0]} = ${val[1]}"
|
||||
./shell/tools/4LETTER.scroll.py "TRASNFORMATION G1TAG ${val[0]} ZEN EN PASSENGER ${FID}";
|
||||
log "__SUB:tag_READ_X.sh: $(./shell/tag_OP.sh ${obj[0]} ${obj[0]} 0 $SWARM_G1AUTHFILE)"
|
||||
fi
|
||||
CASHBACK=""
|
||||
fi
|
||||
|
||||
act=()
|
||||
obj=()
|
||||
val=()
|
||||
# END OF 2-PASS READ
|
||||
./shell/timeout.sh -t 2 ./shell/tools/4LETTER.spinner.py
|
||||
fi
|
||||
|
||||
./shell/tools/4LETTER.blink.py
|
||||
./shell/tools/4LETTER.clock.py &
|
||||
clockpid=$!
|
||||
done
|
||||
|
|
@ -0,0 +1,300 @@
|
|||
#!/bin/bash
|
||||
################################################################################
|
||||
# Author: Fred (support@qo-op.com)
|
||||
# Version: 0.1
|
||||
# License: AGPL-3.0 (https://choosealicense.com/licenses/agpl-3.0/)
|
||||
###########################################################################################
|
||||
###########################################################################################
|
||||
# Lit les données reçues depuis un lecteur de QR Code branché en USB/SERIE (/dev/ttyACM0)
|
||||
# Interpète les G1QRcodes et les G1Tag (R/W)
|
||||
# Saisie du montant à transférer par pavé numérique
|
||||
###########################################################################################
|
||||
echo "__SUB:tag_READ_XY.sh: QRCODE READER : START"
|
||||
function log () {
|
||||
echo "$line
|
||||
$1" >> /tmp/tag_READ_XY.log
|
||||
}
|
||||
source ./shell/init.sh
|
||||
source ./shell/functions.sh
|
||||
##############################################
|
||||
# NODE ENVIRONEMENT DETECTION
|
||||
##############################################
|
||||
YOU=$(ps auxf --sort=+utime | grep -w ipfs | grep -v -E 'color=auto|grep' | tail -n 1 | cut -d " " -f 1);
|
||||
IPFSNODEID=$(su $YOU -c "ipfs id -f='<id>\n'")
|
||||
NODE_UIDNA=$(cat "./wallets/.$IPFSNODEID/_uidna")
|
||||
|
||||
MY_PATH="`dirname \"$0\"`" # relative
|
||||
MY_PATH="`( cd \"$MY_PATH\" && pwd )`" # absolutized and normalized
|
||||
|
||||
SWARM_G1PUBKEY=$(cat "${GPATH}/g1sms.pub.key")
|
||||
SWARM_G1AUTHFILE="${GPATH}/g1sms.priv.key"
|
||||
if [[ ! -f $SWARM_G1AUTHFILE ]]; then echo "ERREUR CLEF DECHIFFRAGE!"; exit; fi
|
||||
|
||||
## INIT NODE G1 PUB & PRIV KEY
|
||||
NODE_G1PUBKEY=$(cat "${GPATH}/g1sms.preoni.pub.key")
|
||||
NODE_G1AUTHFILE="${GPATH}/g1sms.preoni.priv.key"
|
||||
|
||||
|
||||
if [[ ! -e "/dev/ttyACM0" ]]; then echo "Branchez votre lecteur de QR code!"; exit; fi
|
||||
##############################################
|
||||
|
||||
# DOUCHETTE ES TU LA?
|
||||
./shell/tools/4LETTER.scroll.py "G1TX START"
|
||||
./shell/tools/4LETTER.clock.py &
|
||||
clockpid=$!
|
||||
|
||||
# TABLEAU MEMOIRE DE SCAN
|
||||
declare -a act
|
||||
declare -a obj
|
||||
declare -a val
|
||||
|
||||
cat /dev/ttyACM0 | while read line; do
|
||||
kill $clockpid
|
||||
|
||||
lon=${#line}
|
||||
pref=$(echo $line | cut -d ":" -f 1)
|
||||
qrvalue=$(echo $line | cut -d ":" -f 2)
|
||||
log "__SUB:tag_READ_X.sh: SCAN /dev/ttyACM0 ($lon) :: $line"
|
||||
|
||||
case $pref in
|
||||
RJ)
|
||||
R=$(echo $qrvalue | cut -d '#' -f 1)
|
||||
J=$(echo $qrvalue | cut -d '#' -f 2)
|
||||
log "__SUB:tag_READ_X.sh: Lecture G1Tag $R $J"
|
||||
# IPFS READ
|
||||
ID=$(su $YOU -c "ipfs cat /ipns/$J/TAG_id");
|
||||
if [[ "$ID" == "" ]]; then
|
||||
./shell/tools/4LETTER.scroll.py ">> BAD G1TAG <<"
|
||||
continue
|
||||
fi
|
||||
# Get First R Tag name word and remove space for RR
|
||||
FID=$(echo $ID | awk '{print toupper($1)}')
|
||||
RR=$(echo $ID | sed s/\ //g)
|
||||
|
||||
./shell/tools/4LETTER.scroll.py "${#act[@]} $FID > "
|
||||
RVALUE=$(su $YOU -c "ipfs cat /ipns/$J/TAG_amount");
|
||||
CURRENCY=$(su $YOU -c "ipfs cat /ipns/$J/TAG_currency" | awk '{print tolower($1)}')
|
||||
|
||||
PASSENGER=$(su $YOU -c "ipfs cat /ipns/$J/TAG_passenger");
|
||||
if [[ "$PASSENGER" != "" ]]; then
|
||||
./shell/tools/4LETTER.scroll.py "G1TAG PASSENGER $RVALUE ZEN"
|
||||
else
|
||||
G1VAL=$(bc -l <<< "scale=2; $RVALUE / 100" | cut -d '.' -f 1)
|
||||
log "__SUB:tag_READ_X.sh: G1Tag $FID. Valeur $RVALUE $CURRENCY = $G1VAL G1"
|
||||
./shell/tools/4LETTER.scroll.py "$RVALUE ZEN *** $G1VAL G1"
|
||||
fi
|
||||
cmd="RJ"
|
||||
CASHBACK=""
|
||||
val+=("$RVALUE")
|
||||
;;
|
||||
|
||||
BJ)
|
||||
BB=$(echo $qrvalue | cut -d '#' -f 1)
|
||||
J=$(echo $qrvalue | cut -d '#' -f 2)
|
||||
log "__SUB:tag_READ_X.sh: Ouverture G1Tag $BB $J"
|
||||
#
|
||||
ID=$(su $YOU -c "ipfs cat /ipns/$J/TAG_id");
|
||||
if [[ "$ID" == "" ]]; then
|
||||
./shell/tools/4LETTER.scroll.py ">> BAD G1TAG <<"
|
||||
continue
|
||||
fi
|
||||
FID=$(echo $ID | awk '{print toupper($1)}')
|
||||
RR=$(echo $ID | sed s/\ //g)
|
||||
|
||||
./shell/tools/4LETTER.scroll.py "${#act[@]} $FID TX >>"
|
||||
BVALUE=$(su $YOU -c "ipfs cat /ipns/$J/TAG_amount")
|
||||
CURRENCY=$(su $YOU -c "ipfs cat /ipns/$J/TAG_currency" | awk '{print tolower($1)}')
|
||||
|
||||
PASSENGER=$(su $YOU -c "ipfs cat /ipns/$J/TAG_passenger");
|
||||
# DIG PUBLISHING KEY
|
||||
if [[ -f /home/$YOU/.ipfs/keystore/$RR ]]; then
|
||||
log "__SUB:tag_READ_X.sh: Clef de publication IPFS $RR déjà présente"
|
||||
else
|
||||
rm /tmp/TAG_publishkey.B.gpg
|
||||
su $YOU -c "ipfs get -o /tmp/ /ipns/$J/TAG_publishkey.B.gpg"
|
||||
./shell/tools/4LETTER.scroll.py "** GPG **"
|
||||
gpg -d --output /tmp/ipns.key --pinentry-mode=loopback --passphrase $BB /tmp/TAG_publishkey.B.gpg
|
||||
# CHECK IF OK
|
||||
if [[ ! -f /tmp/ipns.key ]]; then
|
||||
./shell/tools/4LETTER.scroll.py ">> BAD GPG KEY <<"
|
||||
continue
|
||||
fi
|
||||
mv /tmp/ipns.key /home/$YOU/.ipfs/keystore/$RR
|
||||
log "__SUB:tag_READ_X.sh: Récupération de la clef de publication $RR"
|
||||
fi
|
||||
if [[ "$PASSENGER" != "" ]]; then
|
||||
log "__SUB:tag_READ_X.sh: !!!! $FID REC Tag = $BVALUE $CURRENCY"
|
||||
./shell/tools/4LETTER.scroll.py "G1TAG PASSENGER $BVALUE ZEN"
|
||||
else
|
||||
G1VAL=$(bc -l <<< "scale=2; $BVALUE / 100" | cut -d '.' -f 1)
|
||||
log "__SUB:tag_READ_X.sh: Ce G1 Tag $FID contient $BVALUE $CURRENCY"
|
||||
./shell/tools/4LETTER.scroll.py "$BVALUE ZEN *** $G1VAL G1 MAX"
|
||||
fi
|
||||
cmd="BJ"
|
||||
val+=("$BVALUE")
|
||||
;;
|
||||
|
||||
*)
|
||||
if [[ $lon -eq 44 ]]; then
|
||||
./shell/tools/4LETTER.scroll.py "PORTEFEUILLE G1 >>>>>>>> ${#act[@]}" &
|
||||
J=$qrvalue
|
||||
if [[ "$J" != "${obj[0]}" ]]; then
|
||||
VALUE=$(./shell/timeout.sh -t 25 ./silkaj/silkaj amount $J)
|
||||
|
||||
if [[ "$(echo $VALUE | cut -d ':' -f 1)" != "Error" && "$VALUE" != "" ]]; then
|
||||
log "__SUB:tag_READ_X.sh: Ce compte monnaie libre contient $VALUE G1"
|
||||
NOPOINT=$(echo $VALUE | cut -d '.' -f 1)
|
||||
./shell/tools/4LETTER.scroll.py " $NOPOINT G1 *** $NOPOINT G1 "
|
||||
CASHBACK="$J"
|
||||
cmd="G1"
|
||||
val+=("$VALUE")
|
||||
else
|
||||
if [[ "$VALUE" == "" ]]; then
|
||||
DUNITER=$(./shell/checknodes.sh 'BAN')
|
||||
log "__SUB:tag_READ_X.sh: ERREUR TIMEOUT. CHANGE SILKAJ SERVER: $DUNITER"
|
||||
./shell/tools/4LETTER.scroll.py "ERREUR TIMEOUT SILKAJ"
|
||||
./shell/timeout.sh -t 1 ./shell/tools/4LETTER.spinner.py
|
||||
CASHBACK=""
|
||||
else
|
||||
log "__SUB:tag_READ_X.sh: ERREUR QRCODE ILLISIBLE. longueur $J = ${#J}"
|
||||
./shell/tools/4LETTER.scroll.py "ERREUR QRCODE INCONNU"
|
||||
./shell/timeout.sh -t 1 ./shell/tools/4LETTER.spinner.py
|
||||
CASHBACK=""
|
||||
fi
|
||||
fi
|
||||
else
|
||||
./shell/tools/4LETTER.scroll.py " 2 X "
|
||||
fi
|
||||
else
|
||||
./shell/tools/4LETTER.scroll.py "ERREUR QRCODE INCONNU"
|
||||
fi
|
||||
|
||||
;;
|
||||
|
||||
esac
|
||||
|
||||
###############################################################
|
||||
# APRES G1 CASHBACK : G1 Tag BJ WRITE => ENCAISSEMENT
|
||||
if [[ "${cmd}" == "BJ" && "$CASHBACK" != "" && -f /home/$YOU/.ipfs/keystore/${RR} ]]; then
|
||||
./shell/tools/4LETTER.scroll.py "ZEN -> G1"
|
||||
log "__SUB:tag_READ_X.sh: G1 tag de $BVALUE G1 ! /ipns/$J Virement vers $CASHBACK? "
|
||||
|
||||
./shell/tools/4LETTER.spinner.py &
|
||||
spinnerpid=$!
|
||||
|
||||
# ipfs get G1Tag vers ./TAG/${RR}
|
||||
mkdir -p ./TAG/${RR}; rm -f ./TAG/${RR}/*; chown -R $YOU ./TAG/${RR}/
|
||||
log "__SUB:tag_READ_X.sh: ipfs get --output=./TAG/${RR} /ipns/$J"
|
||||
su $YOU -c "ipfs get --output=./TAG/${RR} /ipns/$J"
|
||||
|
||||
if [[ $(cat ./TAG/${RR}/TAG_passenger) != "" ]]; then ./shell/tools/4LETTER.scroll.py "IMPOSSIBLE TAG PASSENGER $BVALUE ZEN"; continue; fi
|
||||
|
||||
# Make Silkaj TX
|
||||
G1VAL=$(bc -l <<< "scale=2; $BVALUE / 100" | cut -d '.' -f 1)
|
||||
log "__SUB:tag_READ_X.sh: Silkaj TX $SWARM_G1AUTHFILE ($G1VAL) -> $CASHBACK"
|
||||
PAY=$(./silkaj/silkaj transaction --auth-file -file="$SWARM_G1AUTHFILE" --amount=$G1VAL --output=$CASHBACK --comment="[G1sms+] G1Tag $RR ZEN -> G1" -y)
|
||||
|
||||
log "__SUB:tag_READ_X.sh: Silkaj output = $PAY"
|
||||
# Stop 1LETTER.spinner.py
|
||||
kill $spinnerpid
|
||||
|
||||
if [[ "$(echo $PAY | cut -d '|' -f 1)" == "KO" && "$PAY" != "" ]]; then
|
||||
new=$(./shell/checknodes.sh "BAN")
|
||||
sms_ERROR "$ADMINPHONE" "Il est survenu un problème avec un virement. Retour silkaj: $PAY ... $new";
|
||||
./shell/tools/4LETTER.scroll.py "ERREUR SILKAJ ERREUR"
|
||||
else
|
||||
# ENCAISSEMENT G1Tag
|
||||
./shell/tools/4LETTER.scroll.py "VIR ${FID} $G1VAL G1 -> OK "
|
||||
# CAPTURE / DESTRUCTION du G1 Tag
|
||||
echo "0" > "./TAG/${RR}/TAG_amount"
|
||||
echo "${J}" > "./TAG/${RR}/TAG_ipns"
|
||||
|
||||
# Iterate
|
||||
if [[ -f ./TAG/${RR}/TAG_n ]]; then NN=$(cat ./TAG/${RR}/TAG_n); ((NN++)); else NN=0; fi
|
||||
|
||||
# TAG_actions
|
||||
echo "$NN" > "./TAG/${RR}/TAG_n"
|
||||
echo "${NANODATE}" > "./TAG/${RR}/TAG_nanodate"
|
||||
echo "${IPFSNODEID}" > "./TAG/${RR}/TAG_writerid"
|
||||
|
||||
# EMPTY G1TAG ID AND REMOVE PUBLISHKEYS
|
||||
echo "" > "./TAG/${RR}/TAG_id"
|
||||
rm -f ./TAG/TAG_publishkey.*
|
||||
|
||||
log "__SUB:tag_READ_X.sh: Destruction G1Tag TAG_id $NN.${NANODATE} (par NODE ${IPFSNODEID}) => Value = 0"
|
||||
I=$(su $YOU -c "ipfs add -qr ./TAG/${RR} | tail -n 1")
|
||||
# TAG_chain
|
||||
echo "$I" > "./TAG/${RR}/TAG_chain"
|
||||
I=$(su $YOU -c "ipfs add -qr ./TAG/${RR} | tail -n 1")
|
||||
# IPNS $RR PUBLISH
|
||||
J=$(su $YOU -c "ipfs name publish -k ${RR} --quieter /ipfs/${I}")
|
||||
|
||||
log "__SUB:tag_READ_X.sh: Destruction de ce G1 Tag publish -k ${RR} --quieter /ipfs/${I} :: ipfs ls /ipns/$J"
|
||||
./shell/tools/4LETTER.scroll.py "DETRUIRE G1TAG ${FID}"
|
||||
|
||||
# CLEAN IPFS keystore: remove NOT created NODE keys
|
||||
SOURCENODEID=$(cat "./TAG/${RR}/TAG_nodeid")
|
||||
if [[ "${SOURCENODEID}" != "${IPFSNODEID}" ]]; then
|
||||
rm -f /home/$YOU/.ipfs/keystore/${RR}
|
||||
fi
|
||||
fi
|
||||
else
|
||||
# AJOUT MEMOIRE SCAN
|
||||
./shell/timeout.sh -t 1 ./shell/tools/4LETTER.spinner.py
|
||||
act+=("$cmd")
|
||||
obj+=("$J")
|
||||
fi
|
||||
|
||||
|
||||
# FLUSH MEMOIRE 2 SCAN
|
||||
if [[ ${#act[@]} -eq 2 ]]; then
|
||||
echo "${act[@]}"
|
||||
echo "${obj[@]}"
|
||||
echo "${val[@]}"
|
||||
###############################################################
|
||||
# PRESENTATION RJ puis BJ différents Tag WRITE = TRANSFERT G1 TAG
|
||||
if [[ "${act[0]}" == "RJ" && "${act[1]}" == "BJ" && "${obj[0]}" != "${obj[1]}" ]]; then
|
||||
PASSENGER=$(su $YOU -c "ipfs cat /ipns/${obj[1]}/TAG_passenger");
|
||||
if [[ "$PASSENGER" != "" ]]; then
|
||||
./shell/tools/4LETTER.scroll.py "IMPOSSIBLE TAG PASSENGER";
|
||||
else
|
||||
###########################################################
|
||||
# READ KEYBOARD VALUE !!! 4 DIGIT REMOVING LEADING 0
|
||||
COMBIEN=$(./shell/tools/matrixKeypad.py | sed 's/^0*//')
|
||||
if [[ $COMBIEN -le ${val[1]} ]]; then
|
||||
COMBIENZEN=$(bc -l <<< "$COMBIEN * 100")
|
||||
log "__SUB:tag_READ_X.sh: Transfert de G1 Tag à G1 Tag. $COMBIEN"
|
||||
./shell/tools/4LETTER.scroll.py "G1TAG ${FID} -> TX $COMBIENZEN ZEN *** $COMBIEN G1"
|
||||
log "__SUB:tag_READ_X.sh: ./shell/tag_OP.sh ${obj[1]} ${obj[0]} $COMBIENZEN $SWARM_G1AUTHFILE"
|
||||
./shell/tag_OP.sh ${obj[1]} ${obj[0]} $COMBIENZEN "$SWARM_G1AUTHFILE"
|
||||
else
|
||||
./shell/tools/4LETTER.scroll.py "ERREUR $COMBIEN > VALEUR DE ${FID} *** ${val[1]} ZEN"
|
||||
fi
|
||||
fi
|
||||
CASHBACK=""
|
||||
fi
|
||||
###############################################################
|
||||
# PRESENTATION BJ identiques TRANSFORMATION G1 TAG en REC TAG
|
||||
if [[ "${act[0]}" == "BJ" && "${act[1]}" == "BJ" && "${obj[0]}" == "${obj[1]}" ]]; then
|
||||
PASSENGER=$(su $YOU -c "ipfs cat /ipns/${obj[0]}/TAG_passenger");
|
||||
if [[ "$PASSENGER" != "" ]]; then
|
||||
./shell/tools/4LETTER.scroll.py "DEJA TAG PASSENGER";
|
||||
else
|
||||
log "__SUB:tag_READ_X.sh: Transformation du G1 Tag en Rec Tag. ${val[0]} = ${val[1]}"
|
||||
./shell/tools/4LETTER.scroll.py "TRASNFORMATION G1TAG ${val[0]} ZEN EN PASSENGER ${FID}";
|
||||
log "__SUB:tag_READ_X.sh: $(./shell/tag_OP.sh ${obj[0]} ${obj[0]} 0 $SWARM_G1AUTHFILE)"
|
||||
fi
|
||||
CASHBACK=""
|
||||
fi
|
||||
|
||||
act=()
|
||||
obj=()
|
||||
val=()
|
||||
# END OF 2-PASS READ
|
||||
./shell/timeout.sh -t 2 ./shell/tools/4LETTER.spinner.py
|
||||
fi
|
||||
|
||||
./shell/tools/4LETTER.blink.py
|
||||
./shell/tools/4LETTER.clock.py &
|
||||
clockpid=$!
|
||||
done
|
||||
|
|
@ -0,0 +1,91 @@
|
|||
#!/bin/bash
|
||||
#
|
||||
# The Bash shell script executes a command with a time-out.
|
||||
# Upon time-out expiration SIGTERM (15) is sent to the process. If the signal
|
||||
# is blocked, then the subsequent SIGKILL (9) terminates it.
|
||||
#
|
||||
# Based on the Bash documentation example.
|
||||
|
||||
# Hello Chet,
|
||||
# please find attached a "little easier" :-) to comprehend
|
||||
# time-out example. If you find it suitable, feel free to include
|
||||
# anywhere: the very same logic as in the original examples/scripts, a
|
||||
# little more transparent implementation to my taste.
|
||||
#
|
||||
# Dmitry V Golovashkin <Dmitry.Golovashkin@sas.com>
|
||||
|
||||
scriptName="${0##*/}"
|
||||
|
||||
declare -i DEFAULT_TIMEOUT=9
|
||||
declare -i DEFAULT_INTERVAL=1
|
||||
declare -i DEFAULT_DELAY=1
|
||||
|
||||
# Timeout.
|
||||
declare -i timeout=DEFAULT_TIMEOUT
|
||||
# Interval between checks if the process is still alive.
|
||||
declare -i interval=DEFAULT_INTERVAL
|
||||
# Delay between posting the SIGTERM signal and destroying the process by SIGKILL.
|
||||
declare -i delay=DEFAULT_DELAY
|
||||
|
||||
function printUsage() {
|
||||
cat <<EOF
|
||||
|
||||
Synopsis
|
||||
$scriptName [-t timeout] [-i interval] [-d delay] command
|
||||
Execute a command with a time-out.
|
||||
Upon time-out expiration SIGTERM (15) is sent to the process. If SIGTERM
|
||||
signal is blocked, then the subsequent SIGKILL (9) terminates it.
|
||||
|
||||
-t timeout
|
||||
Number of seconds to wait for command completion.
|
||||
Default value: $DEFAULT_TIMEOUT seconds.
|
||||
|
||||
-i interval
|
||||
Interval between checks if the process is still alive.
|
||||
Positive integer, default value: $DEFAULT_INTERVAL seconds.
|
||||
|
||||
-d delay
|
||||
Delay between posting the SIGTERM signal and destroying the
|
||||
process by SIGKILL. Default value: $DEFAULT_DELAY seconds.
|
||||
|
||||
As of today, Bash does not support floating point arithmetic (sleep does),
|
||||
therefore all delay/time values must be integers.
|
||||
EOF
|
||||
}
|
||||
|
||||
# Options.
|
||||
while getopts ":t:i:d:" option; do
|
||||
case "$option" in
|
||||
t) timeout=$OPTARG ;;
|
||||
i) interval=$OPTARG ;;
|
||||
d) delay=$OPTARG ;;
|
||||
*) printUsage; exit 1 ;;
|
||||
esac
|
||||
done
|
||||
shift $((OPTIND - 1))
|
||||
|
||||
# $# should be at least 1 (the command to execute), however it may be strictly
|
||||
# greater than 1 if the command itself has options.
|
||||
if (($# == 0 || interval <= 0)); then
|
||||
printUsage
|
||||
exit 1
|
||||
fi
|
||||
|
||||
# kill -0 pid Exit code indicates if a signal may be sent to $pid process.
|
||||
(
|
||||
((t = timeout))
|
||||
|
||||
while ((t > 0)); do
|
||||
sleep $interval
|
||||
kill -0 $$ || exit 0
|
||||
((t -= interval))
|
||||
done
|
||||
|
||||
# Be nice, post SIGTERM first.
|
||||
# The 'exit 0' below will be executed if any preceeding command fails.
|
||||
kill -s SIGTERM $$ && kill -0 $$ || exit 0
|
||||
sleep $delay
|
||||
kill -s SIGKILL $$
|
||||
) 2> /dev/null &
|
||||
|
||||
exec "$@"
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
import time
|
||||
import fourletterphat
|
||||
|
||||
fourletterphat.clear()
|
||||
|
||||
fourletterphat.print_str("SCAN")
|
||||
fourletterphat.set_blink(fourletterphat.HT16K33_BLINK_HALFHZ)
|
||||
fourletterphat.show()
|
||||
time.sleep(1)
|
||||
fourletterphat.set_blink(fourletterphat.HT16K33_BLINK_OFF)
|
||||
fourletterphat.print_str("CODE")
|
||||
fourletterphat.show()
|
||||
time.sleep(0.5)
|
||||
|
|
@ -0,0 +1,3 @@
|
|||
#!/usr/bin/env python
|
||||
import fourletterphat
|
||||
fourletterphat.clear()
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
import time
|
||||
import fourletterphat
|
||||
|
||||
while True:
|
||||
fourletterphat.clear()
|
||||
|
||||
str_time = time.strftime("%H%M")
|
||||
|
||||
# Display the time
|
||||
fourletterphat.print_number_str(str_time)
|
||||
|
||||
# Blink the middle decimal point
|
||||
# int(time.time() % 2) will alternate 1 0 1 0
|
||||
# which we can use to directly set the point
|
||||
fourletterphat.set_decimal(1, int(time.time() % 2))
|
||||
|
||||
fourletterphat.show()
|
||||
time.sleep(0.1)
|
||||
|
|
@ -0,0 +1,20 @@
|
|||
#!/usr/bin/env python
|
||||
import sys
|
||||
import fourletterphat
|
||||
|
||||
# if bad number of arguments...
|
||||
if len(sys.argv) != 2:
|
||||
|
||||
# display command usage
|
||||
print("""
|
||||
Usage:
|
||||
python 4LETTER.scroll.py "message a afficher"
|
||||
""")
|
||||
|
||||
# exit with status code error
|
||||
exit(1)
|
||||
|
||||
# Get message from arguments
|
||||
message = sys.argv[1]
|
||||
fourletterphat.scroll_print( message )
|
||||
|
||||
|
|
@ -0,0 +1,15 @@
|
|||
#!/usr/bin/env python
|
||||
|
||||
import time
|
||||
import fourletterphat as flp
|
||||
|
||||
spinner = ["|", "/", "-", "\\"]
|
||||
|
||||
while True:
|
||||
for i in range(4):
|
||||
for s in spinner:
|
||||
s = s * 4
|
||||
flp.clear()
|
||||
flp.print_str(s)
|
||||
flp.show()
|
||||
time.sleep(0.1)
|
||||
|
|
@ -0,0 +1,332 @@
|
|||
#!/bin/bash
|
||||
###########################################################
|
||||
# FORK of pishrink.sh
|
||||
# SHRINK IMAGE OF YOUR RASPIAN PI SD CARD
|
||||
#
|
||||
# + TODO: THIS SCRIPT RESET IPFS / G1 Keys / SWARM config
|
||||
# AND RUN CONFIG on FIRST IMG BOOT in /etc/rc.local
|
||||
###########################################################
|
||||
version="v0.1.3"
|
||||
|
||||
CURRENT_DIR=$(pwd)
|
||||
SCRIPTNAME="${0##*/}"
|
||||
LOGFILE=${CURRENT_DIR}/${SCRIPTNAME%.*}.log
|
||||
|
||||
function info() {
|
||||
echo "$SCRIPTNAME: $1..."
|
||||
}
|
||||
|
||||
function error() {
|
||||
echo -n "$SCRIPTNAME: ERROR occured in line $1: "
|
||||
shift
|
||||
echo "$@"
|
||||
}
|
||||
|
||||
function cleanup() {
|
||||
if losetup "$loopback" &>/dev/null; then
|
||||
losetup -d "$loopback"
|
||||
fi
|
||||
if [ "$debug" = true ]; then
|
||||
local old_owner=$(stat -c %u:%g "$src")
|
||||
chown "$old_owner" "$LOGFILE"
|
||||
fi
|
||||
|
||||
}
|
||||
|
||||
function logVariables() {
|
||||
if [ "$debug" = true ]; then
|
||||
echo "Line $1" >> "$LOGFILE"
|
||||
shift
|
||||
local v var
|
||||
for var in "$@"; do
|
||||
eval "v=\$$var"
|
||||
echo "$var: $v" >> "$LOGFILE"
|
||||
done
|
||||
fi
|
||||
}
|
||||
|
||||
function checkFilesystem() {
|
||||
info "Checking filesystem"
|
||||
e2fsck -pf "$loopback"
|
||||
(( $? < 4 )) && return
|
||||
|
||||
info "Filesystem error detected!"
|
||||
|
||||
info "Trying to recover corrupted filesystem"
|
||||
e2fsck -y "$loopback"
|
||||
(( $? < 4 )) && return
|
||||
|
||||
if [[ $repair == true ]]; then
|
||||
info "Trying to recover corrupted filesystem - Phase 2"
|
||||
e2fsck -fy -b 32768 "$loopback"
|
||||
(( $? < 4 )) && return
|
||||
fi
|
||||
error $LINENO "Filesystem recoveries failed. Giving up..."
|
||||
exit -9
|
||||
|
||||
}
|
||||
|
||||
help() {
|
||||
local help
|
||||
read -r -d '' help << EOM
|
||||
Usage: $0 [-sdrzh] imagefile.img [newimagefile.img]
|
||||
|
||||
-s: Don't expand filesystem when image is booted the first time
|
||||
-d: Write debug messages in a debug log file
|
||||
-r: Use advanced filesystem repair option if the normal one fails
|
||||
-z: Gzip compress image after shrinking
|
||||
EOM
|
||||
echo "$help"
|
||||
exit -1
|
||||
}
|
||||
|
||||
usage() {
|
||||
echo "Usage: $0 [-sdrpzh] imagefile.img [newimagefile.img]"
|
||||
echo ""
|
||||
echo " -s: Skip autoexpand"
|
||||
echo " -d: Debug mode on"
|
||||
echo " -r: Use advanced repair options"
|
||||
echo " -z: Gzip compress image after shrinking"
|
||||
echo " -h: display help text"
|
||||
exit -1
|
||||
}
|
||||
|
||||
should_skip_autoexpand=false
|
||||
debug=false
|
||||
repair=false
|
||||
gzip_compress=false
|
||||
|
||||
while getopts ":sdrzh" opt; do
|
||||
case "${opt}" in
|
||||
s) should_skip_autoexpand=true ;;
|
||||
d) debug=true;;
|
||||
r) repair=true;;
|
||||
z) gzip_compress=true;;
|
||||
h) help;;
|
||||
*) usage ;;
|
||||
esac
|
||||
done
|
||||
shift $((OPTIND-1))
|
||||
|
||||
if [ "$debug" = true ]; then
|
||||
info "Creating log file $LOGFILE"
|
||||
rm "$LOGFILE" &>/dev/null
|
||||
exec 1> >(stdbuf -i0 -o0 -e0 tee -a "$LOGFILE" >&1)
|
||||
exec 2> >(stdbuf -i0 -o0 -e0 tee -a "$LOGFILE" >&2)
|
||||
fi
|
||||
|
||||
echo "${0##*/} $version"
|
||||
|
||||
#Args
|
||||
src="$1"
|
||||
img="$1"
|
||||
|
||||
#Usage checks
|
||||
if [[ -z "$img" ]]; then
|
||||
usage
|
||||
fi
|
||||
if [[ ! -f "$img" ]]; then
|
||||
error $LINENO "$img is not a file..."
|
||||
exit -2
|
||||
fi
|
||||
if (( EUID != 0 )); then
|
||||
error $LINENO "You need to be running as root."
|
||||
exit -3
|
||||
fi
|
||||
|
||||
#Check that what we need is installed
|
||||
for command in parted losetup tune2fs md5sum e2fsck resize2fs; do
|
||||
command -v $command >/dev/null 2>&1
|
||||
if (( $? != 0 )); then
|
||||
error $LINENO "$command is not installed."
|
||||
exit -4
|
||||
fi
|
||||
done
|
||||
|
||||
#Copy to new file if requested
|
||||
if [ -n "$2" ]; then
|
||||
info "Copying $1 to $2..."
|
||||
cp --reflink=auto --sparse=always "$1" "$2"
|
||||
if (( $? != 0 )); then
|
||||
error $LINENO "Could not copy file..."
|
||||
exit -5
|
||||
fi
|
||||
old_owner=$(stat -c %u:%g "$1")
|
||||
chown "$old_owner" "$2"
|
||||
img="$2"
|
||||
fi
|
||||
|
||||
# cleanup at script exit
|
||||
trap cleanup ERR EXIT
|
||||
|
||||
#Gather info
|
||||
info "Gatherin data"
|
||||
beforesize=$(ls -lh "$img" | cut -d ' ' -f 5)
|
||||
parted_output=$(parted -ms "$img" unit B print | tail -n 1)
|
||||
partnum=$(echo "$parted_output" | cut -d ':' -f 1)
|
||||
partstart=$(echo "$parted_output" | cut -d ':' -f 2 | tr -d 'B')
|
||||
loopback=$(losetup -f --show -o "$partstart" "$img")
|
||||
tune2fs_output=$(tune2fs -l "$loopback")
|
||||
currentsize=$(echo "$tune2fs_output" | grep '^Block count:' | tr -d ' ' | cut -d ':' -f 2)
|
||||
blocksize=$(echo "$tune2fs_output" | grep '^Block size:' | tr -d ' ' | cut -d ':' -f 2)
|
||||
|
||||
logVariables $LINENO tune2fs_output currentsize blocksize
|
||||
|
||||
#Check if we should make pi expand rootfs on next boot
|
||||
if [ "$should_skip_autoexpand" = false ]; then
|
||||
#Make pi expand rootfs on next boot
|
||||
mountdir=$(mktemp -d)
|
||||
mount "$loopback" "$mountdir"
|
||||
|
||||
if [ "$(md5sum "$mountdir/etc/rc.local" | cut -d ' ' -f 1)" != "0542054e9ff2d2e0507ea1ffe7d4fc87" ]; then
|
||||
echo "Creating new /etc/rc.local"
|
||||
mv "$mountdir/etc/rc.local" "$mountdir/etc/rc.local.bak"
|
||||
#####Do not touch the following lines#####
|
||||
cat <<\EOF1 > "$mountdir/etc/rc.local"
|
||||
#!/bin/bash
|
||||
do_expand_rootfs() {
|
||||
ROOT_PART=$(mount | sed -n 's|^/dev/\(.*\) on / .*|\1|p')
|
||||
|
||||
PART_NUM=${ROOT_PART#mmcblk0p}
|
||||
if [ "$PART_NUM" = "$ROOT_PART" ]; then
|
||||
echo "$ROOT_PART is not an SD card. Don't know how to expand"
|
||||
return 0
|
||||
fi
|
||||
|
||||
# Get the starting offset of the root partition
|
||||
PART_START=$(parted /dev/mmcblk0 -ms unit s p | grep "^${PART_NUM}" | cut -f 2 -d: | sed 's/[^0-9]//g')
|
||||
[ "$PART_START" ] || return 1
|
||||
# Return value will likely be error for fdisk as it fails to reload the
|
||||
# partition table because the root fs is mounted
|
||||
fdisk /dev/mmcblk0 <<EOF
|
||||
p
|
||||
d
|
||||
$PART_NUM
|
||||
n
|
||||
p
|
||||
$PART_NUM
|
||||
$PART_START
|
||||
|
||||
p
|
||||
w
|
||||
EOF
|
||||
|
||||
cat <<EOF > /etc/rc.local &&
|
||||
#!/bin/sh
|
||||
echo "Expanding /dev/$ROOT_PART"
|
||||
resize2fs /dev/$ROOT_PART
|
||||
rm -f /etc/rc.local; cp -f /etc/rc.local.bak /etc/rc.local; /etc/rc.local
|
||||
|
||||
EOF
|
||||
reboot
|
||||
exit
|
||||
}
|
||||
raspi_config_expand() {
|
||||
/usr/bin/env raspi-config --expand-rootfs
|
||||
if [[ $? != 0 ]]; then
|
||||
return -1
|
||||
else
|
||||
rm -f /etc/rc.local; cp -f /etc/rc.local.bak /etc/rc.local; /etc/rc.local
|
||||
reboot
|
||||
exit
|
||||
fi
|
||||
}
|
||||
raspi_config_expand
|
||||
echo "WARNING: Using backup expand..."
|
||||
sleep 5
|
||||
do_expand_rootfs
|
||||
echo "ERROR: Expanding failed..."
|
||||
sleep 5
|
||||
rm -f /etc/rc.local; cp -f /etc/rc.local.bak /etc/rc.local; /etc/rc.local
|
||||
exit 0
|
||||
EOF1
|
||||
#####End no touch zone#####
|
||||
chmod +x "$mountdir/etc/rc.local"
|
||||
fi
|
||||
umount "$mountdir"
|
||||
else
|
||||
echo "Skipping autoexpanding process..."
|
||||
fi
|
||||
|
||||
#Make sure filesystem is ok
|
||||
checkFilesystem
|
||||
|
||||
if ! minsize=$(resize2fs -P "$loopback"); then
|
||||
rc=$?
|
||||
error $LINENO "resize2fs failed with rc $rc"
|
||||
exit -10
|
||||
fi
|
||||
minsize=$(cut -d ':' -f 2 <<< "$minsize" | tr -d ' ')
|
||||
logVariables $LINENO minsize
|
||||
if [[ $currentsize -eq $minsize ]]; then
|
||||
error $LINENO "Image already shrunk to smallest size"
|
||||
exit -11
|
||||
fi
|
||||
|
||||
#Add some free space to the end of the filesystem
|
||||
extra_space=$(($currentsize - $minsize))
|
||||
logVariables $LINENO extra_space
|
||||
for space in 5000 1000 100; do
|
||||
if [[ $extra_space -gt $space ]]; then
|
||||
minsize=$(($minsize + $space))
|
||||
break
|
||||
fi
|
||||
done
|
||||
logVariables $LINENO minsize
|
||||
|
||||
#Shrink filesystem
|
||||
info "Shrinking filesystem"
|
||||
resize2fs -p "$loopback" $minsize
|
||||
if [[ $? != 0 ]]; then
|
||||
error $LINENO "resize2fs failed"
|
||||
mount "$loopback" "$mountdir"
|
||||
mv "$mountdir/etc/rc.local.bak" "$mountdir/etc/rc.local"
|
||||
umount "$mountdir"
|
||||
losetup -d "$loopback"
|
||||
exit -12
|
||||
fi
|
||||
sleep 1
|
||||
|
||||
#Shrink partition
|
||||
partnewsize=$(($minsize * $blocksize))
|
||||
newpartend=$(($partstart + $partnewsize))
|
||||
logVariables $LINENO partnewsize newpartend
|
||||
if ! parted -s -a minimal "$img" rm "$partnum"; then
|
||||
rc=$?
|
||||
error $LINENO "parted failed with rc $rc"
|
||||
exit -13
|
||||
fi
|
||||
|
||||
if ! parted -s "$img" unit B mkpart primary "$partstart" "$newpartend"; then
|
||||
rc=$?
|
||||
error $LINENO "parted failed with rc $rc"
|
||||
exit -14
|
||||
fi
|
||||
|
||||
#Truncate the file
|
||||
info "Shrinking image"
|
||||
if ! endresult=$(parted -ms "$img" unit B print free); then
|
||||
rc=$?
|
||||
error $LINENO "parted failed with rc $rc"
|
||||
exit -15
|
||||
fi
|
||||
|
||||
endresult=$(tail -1 <<< "$endresult" | cut -d ':' -f 2 | tr -d 'B')
|
||||
logVariables $LINENO endresult
|
||||
if ! truncate -s "$endresult" "$img"; then
|
||||
rc=$?
|
||||
error $LINENO "trunate failed with rc $rc"
|
||||
exit -16
|
||||
fi
|
||||
|
||||
if [[ $gzip_compress == true ]]; then
|
||||
info "Gzipping the shrunk image"
|
||||
if [[ ! $(gzip -f9 "$img") ]]; then
|
||||
img=$img.gz
|
||||
fi
|
||||
fi
|
||||
|
||||
aftersize=$(ls -lh "$img" | cut -d ' ' -f 5)
|
||||
logVariables $LINENO aftersize
|
||||
|
||||
info "Shrunk $img from $beforesize to $aftersize"
|
||||
|
|
@ -0,0 +1,64 @@
|
|||
#!/usr/bin/env python3
|
||||
|
||||
"""
|
||||
CopyLeft 2019 Pascal Engélibert
|
||||
|
||||
This program is free software: you can redistribute it and/or modify
|
||||
it under the terms of the GNU Affero General Public License as published by
|
||||
the Free Software Foundation, either version 3 of the License, or
|
||||
(at your option) any later version.
|
||||
|
||||
This program is distributed in the hope that it will be useful,
|
||||
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
GNU Affero General Public License for more details.
|
||||
|
||||
You should have received a copy of the GNU Affero General Public License
|
||||
along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
"""
|
||||
|
||||
import sys
|
||||
from duniterpy.key import SigningKey
|
||||
|
||||
def getargv(arg, default=""):
|
||||
if arg in sys.argv and len(sys.argv) > sys.argv.index(arg)+1:
|
||||
return sys.argv[sys.argv.index(arg)+1]
|
||||
else:
|
||||
return default
|
||||
|
||||
if __name__ == "__main__":
|
||||
|
||||
if "--help" in sys.argv or not "-i" in sys.argv or not "-o" in sys.argv:
|
||||
print("""Duniter MiniTools: Mass Keygen
|
||||
CopyLeft 2019 Pascal Engélibert
|
||||
|
||||
Usage:
|
||||
python3 keygen.py -i <input_file> -o <output_file>
|
||||
Format: CSV ; Separator: tab
|
||||
""")
|
||||
exit()
|
||||
|
||||
infile = open(getargv("-i"), "r")
|
||||
outfile = open(getargv("-o"), "w")
|
||||
|
||||
i = 0
|
||||
while True:
|
||||
line = infile.readline()
|
||||
if line == "":
|
||||
break
|
||||
i += 1
|
||||
if "\n" in line:
|
||||
line = line[:len(line)-1]
|
||||
|
||||
cols = line.split("\t")
|
||||
while "" in cols:
|
||||
cols.remove("")
|
||||
if len(cols) < 2:
|
||||
print("Error (line "+str(i)+"): less than 2 columns! (at least 2 expected)")
|
||||
break
|
||||
|
||||
key = SigningKey.from_credentials(cols[0], cols[1])
|
||||
outfile.write(cols[0]+"\t"+cols[1]+"\t"+key.pubkey+"\n")
|
||||
|
||||
infile.close()
|
||||
outfile.close()
|
||||
|
|
@ -0,0 +1,85 @@
|
|||
#!/usr/bin/env python3
|
||||
|
||||
import os, sys, duniterpy.key, libnacl.sign
|
||||
|
||||
def getargv(arg:str, default:str="", n:int=1, args:list=sys.argv) -> str:
|
||||
if arg in args and len(args) > args.index(arg)+n:
|
||||
return args[args.index(arg)+n]
|
||||
else:
|
||||
return default
|
||||
|
||||
def read_data(data_path, b=True):
|
||||
if data_path == "-":
|
||||
if b:
|
||||
return sys.stdin.read().encode()
|
||||
else:
|
||||
return sys.stdin.read()
|
||||
else:
|
||||
if b:
|
||||
return open(os.path.expanduser(data_path), "rb").read()
|
||||
else:
|
||||
return open(os.path.expanduser(data_path), "r").read()
|
||||
|
||||
def write_data(data, result_path):
|
||||
(sys.stdout if result_path == "-" else open(os.path.expanduser(result_path), "wb")).write(data)
|
||||
|
||||
def encrypt(data, pubkey):
|
||||
return duniterpy.key.PublicKey(pubkey).encrypt_seal(data)
|
||||
|
||||
def decrypt(data, privkey):
|
||||
return duniterpy.key.SigningKey.from_seedhex(privkey).decrypt_seal(data)
|
||||
|
||||
def sign(data, privkey):
|
||||
return duniterpy.key.SigningKey.from_seedhex(privkey).sign(data)
|
||||
|
||||
def verify(data, pubkey):
|
||||
try:
|
||||
return libnacl.sign.Verifier(duniterpy.key.PublicKey(pubkey).hex_pk()).verify(data)
|
||||
except ValueError:
|
||||
exit(1)
|
||||
|
||||
def show_help():
|
||||
print("""Usage:
|
||||
python3 natools.py <command> [options]
|
||||
|
||||
Commands:
|
||||
encrypt Encrypt data
|
||||
decrypt Decrypt data
|
||||
sign Sign data
|
||||
verify Verify data
|
||||
|
||||
Options:
|
||||
-i <path> Input file path (default: -)
|
||||
-k <path> Privkey file path (default: authfile.key)
|
||||
-p <str> Pubkey (base58)
|
||||
-o <path> Output file path (default: -)
|
||||
|
||||
Note: "-" means stdin or stdout.
|
||||
""")
|
||||
|
||||
if __name__ == "__main__":
|
||||
|
||||
if "--help" in sys.argv:
|
||||
show_help()
|
||||
exit()
|
||||
|
||||
data_path = getargv("-i", "-")
|
||||
privkey_path = getargv("-k", "authfile.key")
|
||||
pubkey = getargv("-p")
|
||||
result_path = getargv("-o", "-")
|
||||
|
||||
try:
|
||||
if sys.argv[1] == "encrypt":
|
||||
write_data(encrypt(read_data(data_path), pubkey), result_path)
|
||||
elif sys.argv[1] == "decrypt":
|
||||
write_data(decrypt(read_data(data_path), read_data(privkey_path, False)), result_path)
|
||||
elif sys.argv[1] == "sign":
|
||||
write_data(sign(read_data(data_path), read_data(privkey_path, False)), result_path)
|
||||
elif sys.argv[1] == "verify":
|
||||
write_data(verify(read_data(data_path), pubkey), result_path)
|
||||
else:
|
||||
show_help()
|
||||
except Exception as e:
|
||||
sys.stderr.write("Error: ", e, "\n")
|
||||
show_help()
|
||||
exit(1)
|
||||
|
|
@ -0,0 +1,42 @@
|
|||
#!/usr/bin/env python3
|
||||
import sys
|
||||
from duniterpy.key import SigningKey
|
||||
|
||||
|
||||
def generate_public_key(salt: str, password: str) -> str:
|
||||
"""
|
||||
Return public key from credentials
|
||||
|
||||
:param salt: Salt passphrase, using quotes if space in it
|
||||
:param password: Password
|
||||
"""
|
||||
# Create key object
|
||||
# key = SigningKey(salt, password)
|
||||
key = SigningKey.from_credentials(salt, password)
|
||||
# SigningKey.save_private_key("private.key", "./")
|
||||
return key.pubkey
|
||||
|
||||
if __name__ == '__main__':
|
||||
|
||||
# if bad number of arguments...
|
||||
if len(sys.argv) != 3:
|
||||
|
||||
# display command usage
|
||||
print("""
|
||||
Usage:
|
||||
python gen_pubkey.py salt password
|
||||
""")
|
||||
|
||||
# exit with status code error
|
||||
exit(1)
|
||||
|
||||
# capture arguments
|
||||
_salt = sys.argv[1]
|
||||
_password = sys.argv[2]
|
||||
|
||||
# display the public key
|
||||
print(generate_public_key(_salt, _password))
|
||||
|
||||
# exit with status code ok
|
||||
exit(0)
|
||||
|
||||
|
|
@ -0,0 +1,32 @@
|
|||
import asyncio
|
||||
import json
|
||||
import sys
|
||||
from duniterpy.api.client import Client
|
||||
|
||||
ES_CORE_ENDPOINT = "ES_CORE_API g1.data.duniter.fr 443"
|
||||
ES_USER_ENDPOINT = "ES_USER_API g1.data.duniter.fr 443"
|
||||
|
||||
async def main():
|
||||
"""
|
||||
Main code (synchronous requests)
|
||||
"""
|
||||
# Create Client from endpoint string in Duniter format
|
||||
client = Client(ES_USER_ENDPOINT)
|
||||
|
||||
# Get entry
|
||||
# pubkey = input("\nEnter a public key to get the user profile: ")
|
||||
# pubkey = "DsEx1pS33vzYZg4MroyBV9hCw98j1gtHEhwiZ5tK7ech"
|
||||
pubkey = sys.argv[1]
|
||||
|
||||
# Get the profil of a public key (direct REST GET request)
|
||||
# print("\nGET user/profile/{0}/_source:".format(pubkey))
|
||||
# response = await client.get('tx/history/{0}'.format(pubkey.strip(' \n')))
|
||||
response = await client.get('user/profile/{0}/_source'.format(pubkey.strip(' \n')))
|
||||
print(json.dumps(response))
|
||||
|
||||
# Close client aiohttp session
|
||||
await client.close()
|
||||
|
||||
# Latest duniter-python-api is asynchronous and you have to use asyncio, an asyncio loop and a "as" on the data.
|
||||
# ( https://docs.python.org/3/library/asyncio.html )
|
||||
asyncio.get_event_loop().run_until_complete(main())
|
||||
|
|
@ -0,0 +1,54 @@
|
|||
#!/usr/bin/env python3
|
||||
import asyncio
|
||||
import getpass
|
||||
import sys
|
||||
import silkaj.money, silkaj.tx, silkaj.auth
|
||||
from duniterpy.key import SigningKey
|
||||
|
||||
# CONFIG #######################################
|
||||
|
||||
# You can either use a complete defined endpoint : [NAME_OF_THE_API] [DOMAIN] [IPv4] [IPv6] [PORT]
|
||||
# or the simple definition : [NAME_OF_THE_API] [DOMAIN] [PORT]
|
||||
# Here we use the secure BASIC_MERKLED_API (BMAS)
|
||||
BMAS_ENDPOINT = "BMAS g1.duniter.org 443"
|
||||
|
||||
# Version of the transaction document
|
||||
TRANSACTION_VERSION = 10
|
||||
|
||||
################################################
|
||||
|
||||
|
||||
def sendTransaction(sender_keys, receiver_pubkey, amount, comment):
|
||||
sender_amount = silkaj.money.get_amount_from_pubkey(sender_keys.pubkey)[0]
|
||||
assert sender_amount >= amount, "not enough money"
|
||||
silkaj.tx.generate_and_send_transaction(sender_keys.hex_seed().decode(), sender_keys.pubkey, amount, [receiver_pubkey], comment)
|
||||
|
||||
|
||||
if __name__ == '__main__':
|
||||
"""
|
||||
Main code
|
||||
"""
|
||||
# if bad number of arguments...
|
||||
if len(sys.argv) != 6:
|
||||
|
||||
# display command usage
|
||||
print("""
|
||||
Usage:
|
||||
./g1_send_transaction.py phone pin dest amount comment
|
||||
""")
|
||||
|
||||
# exit with status code error
|
||||
exit(1)
|
||||
|
||||
# capture arguments
|
||||
_salt = sys.argv[1]
|
||||
_password = sys.argv[2]
|
||||
_dest = sys.argv[3]
|
||||
_amount = sys.argv[4]
|
||||
_comment = sys.argv[5]
|
||||
|
||||
# create keys from credentials
|
||||
sender_keys = SigningKey(_salt, _password)
|
||||
pubkey_from = sender_keys.pubkey
|
||||
|
||||
print("txstatus = sendTransaction(sender_keys, _dest, _amount, _comment)")
|
||||
|
|
@ -0,0 +1,41 @@
|
|||
#! /usr/bin/python
|
||||
import fourletterphat
|
||||
from matrixKeypad_RPi_GPIO import keypad
|
||||
from time import sleep
|
||||
|
||||
# Initialize the keypad class
|
||||
kp = keypad()
|
||||
|
||||
fourletterphat.print_str(" G1?")
|
||||
fourletterphat.show()
|
||||
|
||||
def digit():
|
||||
# Loop while waiting for a keypress
|
||||
r = None
|
||||
while r == None:
|
||||
r = kp.getKey()
|
||||
return r
|
||||
|
||||
#print ("Please enter a 4 digit code: ")
|
||||
|
||||
# Getting digit 1, printing it, then sleep to allow the next digit press.
|
||||
d1 = digit()
|
||||
#print (d1)
|
||||
sleep(0.25)
|
||||
|
||||
d2 = digit()
|
||||
#print (d2)
|
||||
sleep(0.25)
|
||||
|
||||
d3 = digit()
|
||||
#print (d3)
|
||||
sleep(0.25)
|
||||
|
||||
d4 = digit()
|
||||
#print (d4)
|
||||
|
||||
# printing out the assembled 4 digit code.
|
||||
print "%s%s%s%s"%(d1,d2,d3,d4)
|
||||
fourletterphat.clear()
|
||||
fourletterphat.scroll_print("OK %s%s%s%s"%(d1,d2,d3,d4))
|
||||
sleep(2)
|
||||
|
|
@ -0,0 +1,102 @@
|
|||
# #####################################################
|
||||
# Python Library for 3x4 matrix keypad using
|
||||
# 7 of the avialable GPIO pins on the Raspberry Pi.
|
||||
#
|
||||
# This could easily be expanded to handle a 4x4 but I
|
||||
# don't have one for testing. The KEYPAD constant
|
||||
# would need to be updated. Also the setting/checking
|
||||
# of the colVal part would need to be expanded to
|
||||
# handle the extra column.
|
||||
#
|
||||
# Written by Chris Crumpacker
|
||||
# May 2013
|
||||
#
|
||||
# main structure is adapted from Bandono's
|
||||
# matrixQPI which is wiringPi based.
|
||||
# https://github.com/bandono/matrixQPi?source=cc
|
||||
# #####################################################
|
||||
|
||||
import RPi.GPIO as GPIO
|
||||
|
||||
class keypad():
|
||||
# CONSTANTS
|
||||
KEYPAD = [
|
||||
[1,2,3],
|
||||
[4,5,6],
|
||||
[7,8,9],
|
||||
["*",0,"#"]
|
||||
]
|
||||
|
||||
ROW = [18,23,24,25]
|
||||
COLUMN = [5,6,13]
|
||||
|
||||
def __init__(self):
|
||||
GPIO.setmode(GPIO.BCM)
|
||||
|
||||
def getKey(self):
|
||||
|
||||
# Set all columns as output low
|
||||
for j in range(len(self.COLUMN)):
|
||||
GPIO.setup(self.COLUMN[j], GPIO.OUT)
|
||||
GPIO.output(self.COLUMN[j], GPIO.LOW)
|
||||
|
||||
# Set all rows as input
|
||||
for i in range(len(self.ROW)):
|
||||
GPIO.setup(self.ROW[i], GPIO.IN, pull_up_down=GPIO.PUD_UP)
|
||||
|
||||
# Scan rows for pushed key/button
|
||||
# A valid key press should set "rowVal" between 0 and 3.
|
||||
rowVal = -1
|
||||
for i in range(len(self.ROW)):
|
||||
tmpRead = GPIO.input(self.ROW[i])
|
||||
if tmpRead == 0:
|
||||
rowVal = i
|
||||
|
||||
# if rowVal is not 0 thru 3 then no button was pressed and we can exit
|
||||
if rowVal <0 or rowVal >3:
|
||||
self.exit()
|
||||
return
|
||||
|
||||
# Convert columns to input
|
||||
for j in range(len(self.COLUMN)):
|
||||
GPIO.setup(self.COLUMN[j], GPIO.IN, pull_up_down=GPIO.PUD_DOWN)
|
||||
|
||||
# Switch the i-th row found from scan to output
|
||||
GPIO.setup(self.ROW[rowVal], GPIO.OUT)
|
||||
GPIO.output(self.ROW[rowVal], GPIO.HIGH)
|
||||
|
||||
# Scan columns for still-pushed key/button
|
||||
# A valid key press should set "colVal" between 0 and 2.
|
||||
colVal = -1
|
||||
for j in range(len(self.COLUMN)):
|
||||
tmpRead = GPIO.input(self.COLUMN[j])
|
||||
if tmpRead == 1:
|
||||
colVal=j
|
||||
|
||||
# if colVal is not 0 thru 2 then no button was pressed and we can exit
|
||||
if colVal <0 or colVal >2:
|
||||
self.exit()
|
||||
return
|
||||
|
||||
# Return the value of the key pressed
|
||||
self.exit()
|
||||
return self.KEYPAD[rowVal][colVal]
|
||||
|
||||
def exit(self):
|
||||
# Reinitialize all rows and columns as input at exit
|
||||
for i in range(len(self.ROW)):
|
||||
GPIO.setup(self.ROW[i], GPIO.IN, pull_up_down=GPIO.PUD_UP)
|
||||
for j in range(len(self.COLUMN)):
|
||||
GPIO.setup(self.COLUMN[j], GPIO.IN, pull_up_down=GPIO.PUD_UP)
|
||||
|
||||
if __name__ == '__main__':
|
||||
# Initialize the keypad class
|
||||
kp = keypad()
|
||||
|
||||
# Loop while waiting for a keypress
|
||||
digit = None
|
||||
while digit == None:
|
||||
digit = kp.getKey()
|
||||
|
||||
# Print the result
|
||||
print digit
|
||||
Binary file not shown.
Loading…
Reference in New Issue