default offer category = CD/DVD

Remove 3.7 definition...

.env.template

@@ -1,3 +1,10 @@
-dunikey=""		# Chemin du fichier de trousseau Ḡ1 de l'émetteur, au format PubSec
-pod="https://g1.data.duniter.fr"	# Noeud Cecium+ utilisé pour l'envoi du message
-#pod="https://data.gchange.fr"		# Noeud Gchange utilisé pour l'envoi du message
+# Chemin de la clé privé Ḡ1 de l'émetteur, au format PubSec
+DUNIKEY=
+
+# Noeud Duniter
+NODE=https://g1.librelois.fr/gva
+
+# Adresse du pod Cesium ou Gchange à utiliser
+POD=https://g1.data.le-sou.org
+#POD=https://g1.data.duniter.fr
+#POD=https://data.gchange.fr

.gitignore

@@ -1 +1,5 @@
 .env
+__pycache__
+
+*.dunikey
+not4U

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+    "python.pythonPath": "/usr/bin/python3.9"
+}

README.md

@@ -1,53 +1,82 @@
-# Utilisation de la messagerie Cesium+/Gchange
-## Réception/Envoi/Suppression de messages
+# Client CLI for Cesium+/Ḡchange pod
+## Installation
+
+Linux:
+```
+bash setup.sh
+```
+
+Autre:
+```
+Débrouillez-vous.
+```
 
 ## Utilisation
 
-```
-chmod u+x readmsg.sh sendmsg.sh deletemsg.sh
-```
-Par défaut utilise l'émetteur, le fichier de trousseau ainsi que le noeud Cesium+ indiqué dans le fichier `.env`.
-Si non renseigné ni dans le fichier `.env` ni en argument de la commande, alors ils seront demandés interactivement.
+*Python 3.9 minimum*
+
+Renseignez optionnellement le fichier **.env** (Généré lors de la première tentative d'execution, ou à copier depuis .env.template).
 
-### Lecture des messages
 ```
-./readmsg.sh
+./jaklis.py -h
 ```
 
-_Options_:
 ```
-    -r,--recipient <pubkey>	Uses <pubkey> as recipient of the messages.
-    -k,--key <key>		Path <key> to the pubsec keychain file of the issuer.
-    -n,--number <number>	Display the <number> lasts messages from Cesium (tail-like format)
-    -o,--outbox			Read outbox messages instead of inbox
-    -h,--help			Display this help
+usage: jaklis.py [-h] [-v] [-k KEY] [-n NODE] {read,send,delete,get,set,erase,stars,unstars,getoffer,setoffer,deleteoffer,pay,history,balance,id,idBalance} ...
+
+Client CLI pour Cesium+ et Ḡchange
+
+optional arguments:
+  -h, --help            show this help message and exit
+  -v, --version         Affiche la version actuelle du programme
+  -k KEY, --key KEY     Chemin vers mon trousseau de clé (PubSec)
+  -n NODE, --node NODE  Adresse du noeud Cesium+, Gchange ou Duniter à utiliser
+
+Commandes de jaklis:
+  {read,send,delete,get,set,erase,stars,unstars,getoffer,setoffer,deleteoffer,pay,history,balance,id,idBalance}
+    read                Lecture des messages
+    send                Envoi d'un message
+    delete              Supression d'un message
+    get                 Voir un profile Cesium+
+    set                 Configurer son profile Cesium+
+    erase               Effacer son profile Cesium+
+    stars               Voir les étoiles d'un profile / Noter un profile (option -s NOTE)
+    unstars             Supprimer un star
+    getoffer            Obtenir les informations d'une annonce gchange
+    setoffer            Créer une annonce gchange
+    deleteoffer         Supprimer une annonce gchange
+    pay                 Payer en Ḡ1
+    history             Voir l'historique des transactions d'un compte Ḡ1
+    balance             Voir le solde d'un compte Ḡ1
+    id                  Voir l'identité d'une clé publique/username
+    idBalance           Voir l'identité d'une clé publique/username et son solde
 ```
 
-### Envoi de messages
+Utilisez `./jaklis CMD -h` où `CMD` est la commande souhaité pour obtenir l'aide détaillé de cette commande.
+
+### Exemples:
+
+Lire les 10 derniers messages de mon compte indiqué dans le fichier `.env` (par defaut 3 messages):
 ```
-./sendmsg.sh
+./jaklis read -n10
 ```
 
-_Options_:
+Envoyer un message à la clé publique `Do99s6wQR2JLfhirPdpAERSjNbmjjECzGxHNJMiNKT3P` avec un fichier de trousseau particulier:
 ```
-    -t				Test mode: Uses the "test.txt" file as well as the same recipient as the sender.
-    -f,--file <file>		Read the file <file> with title in first line and content in rest of the file for the message.
-    -r,--recipient <pubkey>	Uses <pubkey> as recipient of the message.
-    -i,--issuer <pubkey>	Uses <pubkey> as issuer of the message (Could be remove in future version by calculating pubkey from privatekey).
-    -k,--key <key>		Path <key> to the pubsec keychain file of the issuer.
-    -h,--help			Display this help
+./jaklis.py -k /home/saucisse/mon_fichier_de_trousseau.dunikey send -d Do99s6wQR2JLfhirPdpAERSjNbmjjECzGxHNJMiNKT3P -t "Objet du message" -m "Corps de mon message"
 ```
 
-### Suppression de messages
+Noter 4 étoiles le profile `S9EJbjbaGPnp26VuV6fKjR7raE1YkNhUGDgoydHvAJ1` sur gchange:
 ```
-./deletemsg.sh
+./jaklis.py -n https://data.gchange.fr like -p S9EJbjbaGPnp26VuV6fKjR7raE1YkNhUGDgoydHvAJ1 -s 4
 ```
 
-_Options_:
+Paramétrer mon profile Cesium+:
 ```
-    -id,--id <ID du message>	Delete the message with ID <id>.
-    -i,--issuer <pubkey>	Uses <pubkey> as issuer of the message.
-    -k,--key <key>		Path <key> to the pubsec keychain file of the issuer.
-    -o,--outbox			Delete outbox messages instead of inbox
-    -h,--help			Display this help
+./jaklis.py set -n "Sylvain Durif" -v "Bugarach" -a "42 route de Vénus" -d "Christ cosmique" -pos 48.539927 2.6608169 -s https://www.creationmonetaire.info -A mon_avatar.png
+```
+
+Effacer mon profile Gchange:
+```
+./jaklis.py -n https://data.gchange.fr erase
 ```

deletemsg.sh

@@ -1,70 +0,0 @@
-#!/bin/bash
-
-# ###
-# Supprimer un message Cesium+
-# ###
-
-[[ ! -f .env ]] && cp .env.template .env
-source .env
-
-REGEX_PUBKEYS="[a-zA-Z0-9]{42,44}"
-
-# Help display
-helpOpt() {
-    echo -e "Cesium+ messages deleting
-    Default: ID in interactive mode.
-    Advice: Fill your .env file for more fun.
-    Example: $0 <ID du message>
-
-    \rOptions:
-    -id,--id <ID du message>\tDelete the message with ID <id>.
-    -k,--key <key>\t\tPath <key> to the pubsec keychain file of the issuer.
-    -o,--outbox\t\t\tDelete outbox messages instead of inbox
-    -h,--help\t\t\tDisplay this help"
-}
-
-# Parse options
-declare -a args=($@)
-for ((i=0; i<${#args[*]}; ++i))
-do
-    case ${args[$i]} in
-		-o|--outbox) type=outbox;;
-        -id|--id) id="${args[$i+1]}"
-            [[ -z $id ]] && echo "Veuillez préciser un ID de message." && exit 1;;
-        -k|--key) dunikey="${args[$i+1]}"
-            [[ -z $dunikey ]] && echo "Veuillez préciser un fichier de trousseau." && exit 1;;
-        -h|--help) helpOpt && exit 0;;
-        *) [[ "${args[$i]}" == "-"* ]] && echo "Option inconnue." && exit 1;;
-    esac
-done
-
-if [[ -z $dunikey ]]; then
-    read -p "Fichier de trousseau: " dunikey
-fi
-issuer=$(./natools.py pk -f pubsec -k $dunikey)
-
-if [[ -z $type ]]; then
-    type="inbox"
-fi
-[[ -z $id ]] && id=$1
-if [[ -z $id ]]; then
-    read -p "ID de message: " ID
-fi
-
-[[ -z $(grep -Eo $REGEX_PUBKEYS <<<$issuer) ]] && echo "Le format de la clé publique de l'émetteur est invalide." && exit 1
-
-times=$(date -u +'%s')
-
-# Fabrication du hash
-hashBrut="{\"version\":2,\"index\":\"message\",\"type\":\"$type\",\"id\":\"$id\",\"issuer\":\"$issuer\",\"time\":$times}"
-hash=$(echo -n "$hashBrut" | sha256sum | cut -d ' ' -f1 | awk '{ print toupper($0) }')
-
-# Fabrication de la signature
-signature=$(echo -n "$hash" | ./natools.py sign -f pubsec -k $dunikey --noinc -O 64)
-
-document="{\"hash\":\"$hash\",\"signature\":\"$signature\",${hashBrut:1}"
-jq . <<<$document
-
-# Envoi du document
-curl -s -X POST "$pod/history/delete" -d "$document"
-echo

dunikey.pubsec

@@ -0,0 +1,2 @@
+pub: HTkEecgbtBd3aZiJJYuUjGwLB7r3Ud232TG4BwLDdB3J
+sec: 36fT3if1YGLwmhSS89F8vQ6QpmhWmhcLdQyHHmSgxJpbYSxq7C37sDmPKZykmGrE8zmeUxdyAiY256H852p3Lfor

jaklis.py

@@ -0,0 +1,262 @@
+#!/usr/bin/env python3
+
+import argparse, sys, os, getpass, string, random
+from os.path import join, dirname
+from shutil import copyfile
+from dotenv import load_dotenv
+from duniterpy.key import SigningKey
+
+__version__ = "0.0.4"
+
+MY_PATH = os.path.realpath(os.path.dirname(sys.argv[0])) + '/'
+
+# Get variables environment
+if not os.path.isfile(MY_PATH + '.env'):
+    copyfile(MY_PATH + ".env.template",MY_PATH +  ".env")
+dotenv_path = join(dirname(__file__),MY_PATH +  '.env')
+load_dotenv(dotenv_path)
+
+# Parse arguments
+parser = argparse.ArgumentParser(description="Client CLI pour Cesium+ et Ḡchange")
+parser.add_argument('-v', '--version', action='store_true', help="Affiche la version actuelle du programme")
+parser.add_argument('-k', '--key', help="Chemin vers mon trousseau de clé (PubSec)")
+parser.add_argument('-n', '--node', help="Adresse du noeud Cesium+, Gchange ou Duniter à utiliser")
+
+subparsers = parser.add_subparsers(title="Commandes de jaklis", dest="cmd")
+read_cmd = subparsers.add_parser('read', help="Lecture des messages")
+send_cmd = subparsers.add_parser('send', help="Envoi d'un message")
+delete_cmd = subparsers.add_parser('delete', help="Supression d'un message")
+getProfile_cmd = subparsers.add_parser('get', help="Voir un profile Cesium+")
+setProfile_cmd = subparsers.add_parser('set', help="Configurer son profile Cesium+")
+eraseProfile_cmd = subparsers.add_parser('erase', help="Effacer son profile Cesium+")
+stars_cmd = subparsers.add_parser('stars', help="Voir les étoiles d'un profile / Noter un profile (option -s NOTE)")
+unstars_cmd = subparsers.add_parser('unstars', help="Supprimer un star")
+getoffer_cmd = subparsers.add_parser('getoffer', help="Obtenir les informations d'une annonce gchange")
+setoffer_cmd = subparsers.add_parser('setoffer', help="Créer une annonce gchange")
+deleteoffer_cmd = subparsers.add_parser('deleteoffer', help="Supprimer une annonce gchange")
+pay_cmd = subparsers.add_parser('pay', help="Payer en Ḡ1")
+history_cmd = subparsers.add_parser('history', help="Voir l'historique des transactions d'un compte Ḡ1")
+balance_cmd = subparsers.add_parser('balance', help="Voir le solde d'un compte Ḡ1")
+id_cmd = subparsers.add_parser('id', help="Voir l'identité d'une clé publique/username")
+id_balance_cmd = subparsers.add_parser('idBalance', help="Voir l'identité d'une clé publique/username et son solde")
+currentUd = subparsers.add_parser('currentUd', help="Affiche la montant actuel du dividende Universel")
+
+# Messages management
+read_cmd.add_argument('-n', '--number',type=int, default=3, help="Affiche les NUMBER derniers messages")
+read_cmd.add_argument('-j', '--json', action='store_true', help="Sort au format JSON")
+read_cmd.add_argument('-o', '--outbox', action='store_true', help="Lit les messages envoyés")
+
+send_cmd.add_argument('-d', '--destinataire', required=True, help="Destinataire du message")
+send_cmd.add_argument('-t', '--titre', help="Titre du message à envoyer")
+send_cmd.add_argument('-m', '--message', help="Message à envoyer")
+send_cmd.add_argument('-f', '--fichier', help="Envoyer le message contenu dans le fichier 'FICHIER'")
+send_cmd.add_argument('-o', '--outbox', action='store_true', help="Envoi le message sur la boite d'envoi")
+
+delete_cmd.add_argument('-i', '--id', action='append', nargs='+', required=True, help="ID(s) du/des message(s) à supprimer")
+delete_cmd.add_argument('-o', '--outbox', action='store_true', help="Suppression d'un message envoyé")
+
+# Profiles management
+setProfile_cmd.add_argument('-n', '--name', help="Nom du profile")
+setProfile_cmd.add_argument('-d', '--description', help="Description du profile")
+setProfile_cmd.add_argument('-v', '--ville', help="Ville du profile")
+setProfile_cmd.add_argument('-a', '--adresse', help="Adresse du profile")
+setProfile_cmd.add_argument('-pos', '--position', nargs=2, help="Points géographiques (lat + lon)")
+setProfile_cmd.add_argument('-s', '--site', help="Site web du profile")
+setProfile_cmd.add_argument('-A', '--avatar', help="Chemin vers mon avatar en PNG")
+
+getProfile_cmd.add_argument('-p', '--profile', help="Nom du profile")
+getProfile_cmd.add_argument('-a', '--avatar', action='store_true', help="Récupérer également l'avatar au format raw base64")
+
+# Likes management
+stars_cmd.add_argument('-p', '--profile', help="Profile cible")
+stars_cmd.add_argument('-n', '--number', type=int, help="Nombre d'étoile")
+unstars_cmd.add_argument('-p', '--profile', help="Profile à dénoter")
+
+# Offers management
+getoffer_cmd.add_argument('-i', '--id', help="Annonce cible à récupérer")
+setoffer_cmd.add_argument('-t', '--title', help="Titre de l'annonce à créer")
+setoffer_cmd.add_argument('-d', '--description', help="Description de l'annonce à créer")
+setoffer_cmd.add_argument('-c', '--category', help="Categorie de l'annonce à créer")
+setoffer_cmd.add_argument('-l', '--localisation', nargs=2, help="Localisation de l'annonce à créer (lat + lon)")
+setoffer_cmd.add_argument('-p', '--picture', help="Image de l'annonce à créer")
+setoffer_cmd.add_argument('-ci', '--city', help="Ville de l'annonce à créer")
+setoffer_cmd.add_argument('-pr', '--price', help="Prix de l'annonce à créer")
+deleteoffer_cmd.add_argument('-i', '--id', help="Annonce cible à supprimer")
+
+# GVA usage
+pay_cmd.add_argument('-p', '--pubkey', help="Destinataire du paiement")
+pay_cmd.add_argument('-a', '--amount', type=float, help="Montant de la transaction")
+pay_cmd.add_argument('-c', '--comment',  default="", help="Commentaire de la transaction")
+pay_cmd.add_argument('-m', '--mempool', action='store_true', help="Utilise les sources en Mempool")
+pay_cmd.add_argument('-v', '--verbose', action='store_true', help="Affiche le résultat JSON de la transaction")
+
+history_cmd.add_argument('-p', '--pubkey', help="Clé publique du compte visé")
+history_cmd.add_argument('-n', '--number',type=int, default=10, help="Affiche les NUMBER dernières transactions")
+history_cmd.add_argument('-j', '--json',  action='store_true', help="Affiche le résultat en format JSON")
+history_cmd.add_argument('--nocolors',  action='store_true', help="Affiche le résultat en noir et blanc")
+
+balance_cmd.add_argument('-p', '--pubkey', help="Clé publique du compte visé")
+balance_cmd.add_argument('-m', '--mempool', action='store_true', help="Utilise les sources en Mempool")
+id_cmd.add_argument('-p', '--pubkey', help="Clé publique du compte visé")
+id_cmd.add_argument('-u', '--username', help="Username du compte visé")
+id_balance_cmd.add_argument('-p', '--pubkey', help="Pubkey du compte visé")
+currentUd.add_argument('-p', '--pubkey', help="Pubkey du compte visé")
+
+
+args = parser.parse_args()
+cmd = args.cmd
+
+if args.version:
+  print(__version__)
+  sys.exit(0)
+
+if not cmd:
+    parser.print_help()
+    sys.exit(1)
+
+def createTmpDunikey():
+    # Generate pseudo-random nonce
+    nonce=[]
+    for _ in range(32):
+        nonce.append(random.choice(string.ascii_letters + string.digits))
+    nonce = ''.join(nonce)
+    keyPath = "/tmp/secret.dunikey-" + nonce
+
+    key = SigningKey.from_credentials(getpass.getpass("Identifiant: "), getpass.getpass("Mot de passe: "), None)
+    key.save_pubsec_file(keyPath)
+    
+    return keyPath
+
+# Check if we need dunikey
+try:
+    pubkey = args.pubkey
+except:
+    pubkey = False
+try:
+    profile = args.profile
+except:
+    profile = False
+
+if cmd in ('history','balance','get','id','idBalance') and (pubkey or profile):
+    noNeedDunikey = True
+    keyPath = False
+    try:
+        dunikey = args.pubkey
+    except:
+        dunikey = args.profile
+else:
+    noNeedDunikey = False
+    if args.key:
+        dunikey = args.key
+        keyPath = False
+    else:
+        dunikey = os.getenv('DUNIKEY')
+        if not dunikey:
+            keyPath = createTmpDunikey()
+            dunikey = keyPath
+        else:
+            keyPath = False
+    if not os.path.isfile(dunikey):
+        HOME = os.getenv("HOME")
+        dunikey = HOME + dunikey
+        if not os.path.isfile(dunikey):
+            sys.stderr.write('Le fichier de trousseau {0} est introuvable.\n'.format(dunikey))
+            sys.exit(1)
+
+
+# Construct CesiumPlus object
+if cmd in ("read","send","delete","set","get","erase","stars","unstars","getoffer","setoffer","deleteoffer"):
+    from lib.cesium import CesiumPlus
+
+    if args.node:
+        pod = args.node
+    else:
+        pod = os.getenv('POD')
+    if not pod:
+        pod="https://g1.data.le-sou.org"
+
+    cesium = CesiumPlus(dunikey, pod, noNeedDunikey)
+
+    # Messaging
+    if cmd == "read":
+        cesium.read(args.number, args.outbox, args.json)
+    elif cmd == "send":
+        if args.fichier:
+            with open(args.fichier, 'r') as f:
+                msgT = f.read()
+                titre = msgT.splitlines(True)[0].replace('\n', '')
+                msg = ''.join(msgT.splitlines(True)[1:])
+                if args.titre:
+                    titre = args.titre
+                    msg = msgT
+        elif args.titre and args.message:
+            titre = args.titre
+            msg = args.message
+        else:
+            titre = input("Indiquez le titre du message: ")
+            msg = input("Indiquez le contenu du message: ")
+
+        cesium.send(titre, msg, args.destinataire, args.outbox)
+
+    elif cmd == "delete":
+        cesium.delete(args.id[0], args.outbox)
+
+    # Profiles
+    elif cmd == "set":
+        cesium.set(args.name, args.description, args.ville, args.adresse, args.position, args.site, args.avatar)
+    elif cmd == "get":
+        cesium.get(args.profile, args.avatar)
+    elif cmd == "erase":
+        cesium.erase()
+
+    # Stars
+    elif cmd == "stars":
+        if args.number or args.number == 0:
+            cesium.like(args.number, args.profile)
+        else:
+            cesium.readLikes(args.profile)
+    elif cmd == "unstars":
+        cesium.unLike(args.profile)
+
+    # Offers
+    elif cmd == "getoffer":
+        cesium.getOffer(args.id)
+    elif cmd == "setoffer":
+        cesium.setOffer(args.title, args.description, args.city, args.localisation, args.category, args.price, args.picture)
+    elif cmd == "deleteoffer":
+        cesium.deleteOffer(args.id)
+
+# Construct GVA object
+elif cmd in ("pay","history","balance","id","idBalance","currentUd"):
+    from lib.gva import GvaApi
+
+    if args.node:
+        node = args.node
+    else:
+        node = os.getenv('NODE')
+    if not node:
+        node="https://g1.librelois.fr/gva"
+
+    if args.pubkey:
+        destPubkey = args.pubkey
+    else:
+        destPubkey = False
+
+    gva = GvaApi(dunikey, node, destPubkey, noNeedDunikey)
+
+    if cmd == "pay":
+        gva.pay(args.amount, args.comment, args.mempool, args.verbose)
+    elif cmd == "history":
+        gva.history(args.json, args.nocolors, args.number)
+    elif cmd == "balance":
+        gva.balance(args.mempool)
+    elif cmd == "id":
+        gva.id(args.pubkey, args.username)
+    elif cmd == "idBalance":
+        gva.idBalance(args.pubkey)
+    elif cmd == "currentUd":
+        gva.currentUd()
+
+
+if keyPath:
+    os.remove(keyPath)

lib/cesium.py

@@ -0,0 +1,120 @@
+import re, string, random, base64
+from lib.cesiumCommon import CesiumCommon, PUBKEY_REGEX
+from lib.messaging import ReadFromCesium, SendToCesium, DeleteFromCesium
+from lib.profiles import Profiles
+from lib.stars import ReadLikes, SendLikes, UnLikes
+from lib.offers import Offers
+
+class CesiumPlus(CesiumCommon):
+
+    #################### Messaging ####################
+
+    def read(self, nbrMsg, outbox, isJSON):
+        readCesium = ReadFromCesium(self.dunikey,  self.pod)
+        jsonMsg = readCesium.sendDocument(nbrMsg, outbox)
+        if isJSON:
+            jsonFormat = readCesium.jsonMessages(jsonMsg, nbrMsg, outbox)
+            print(jsonFormat)
+        else:
+            readCesium.readMessages(jsonMsg, nbrMsg, outbox)
+
+    def send(self, title, msg, recipient, outbox):
+        sendCesium = SendToCesium(self.dunikey, self.pod)
+        sendCesium.recipient = recipient
+
+        # Generate pseudo-random nonce
+        nonce=[]
+        for _ in range(32):
+            nonce.append(random.choice(string.ascii_letters + string.digits))
+        sendCesium.nonce = base64.b64decode(''.join(nonce))
+
+        finalDoc = sendCesium.configDoc(sendCesium.encryptMsg(title), sendCesium.encryptMsg(msg))       # Configure JSON document to send
+        sendCesium.sendDocument(finalDoc, outbox)                                                       # Send final signed document
+
+    def delete(self, idsMsgList, outbox):
+        deleteCesium = DeleteFromCesium(self.dunikey,  self.pod)
+        # deleteCesium.issuer = recipient
+        for idMsg in idsMsgList:
+            finalDoc = deleteCesium.configDoc(idMsg, outbox)
+            deleteCesium.sendDocument(finalDoc, idMsg)
+
+    #################### Profiles ####################
+
+    def set(self, name=None, description=None, ville=None, adresse=None, position=None, site=None, avatar=None):
+        setProfile = Profiles(self.dunikey,  self.pod)
+        document = setProfile.configDocSet(name, description, ville, adresse, position, site, avatar)
+        result = setProfile.sendDocument(document,'set')
+
+        print(result)
+        return result
+    
+    def get(self, profile=None, avatar=None):
+        getProfile = Profiles(self.dunikey,  self.pod, self.noNeedDunikey)
+        if not profile:
+            profile = self.pubkey
+        if not re.match(PUBKEY_REGEX, profile) or len(profile) > 45:
+            scope = 'title'
+        else:
+            scope = '_id'
+        
+        document = getProfile.configDocGet(profile, scope, avatar)
+        resultJSON = getProfile.sendDocument(document, 'get')
+        result = getProfile.parseJSON(resultJSON)
+
+        print(result)
+
+    def erase(self):
+        eraseProfile = Profiles(self.dunikey,  self.pod)
+        document = eraseProfile.configDocErase()
+        result = eraseProfile.sendDocument(document,'erase')
+
+        print(result)
+
+    #################### Likes ####################
+
+    def readLikes(self, profile=False):
+        likes = ReadLikes(self.dunikey,  self.pod, self.noNeedDunikey)
+        document = likes.configDoc(profile)
+        result = likes.sendDocument(document)
+        result = likes.parseResult(result)
+
+        print(result)
+
+    def like(self, stars, profile=False):
+        likes = SendLikes(self.dunikey,  self.pod)
+        document = likes.configDoc(profile, stars)
+        if document:
+            likes.sendDocument(document, profile)
+
+    def unLike(self, pubkey, silent=False):
+        likes = UnLikes(self.dunikey,  self.pod)
+        idLike = likes.checkLike(pubkey)
+        if idLike:
+            document = likes.configDoc(idLike)
+            likes.sendDocument(document, silent)
+
+    #################### Offer ####################
+
+    def setOffer(self, title=None, description=None, city=None, localisation=None, category=None, price=None, picture=None):
+        setOffer = Offers(self.dunikey,  self.pod)
+        document = setOffer.configDocSet(title, description, city, localisation, category, price, picture)
+        result = setOffer.sendDocumentSet(document,'set')
+
+        # print(result)
+        return result
+    
+    def getOffer(self, id, avatar=None):
+        getOffer = Offers(self.dunikey,  self.pod, self.noNeedDunikey)
+        
+        resultJSON = getOffer.sendDocumentGet(id, 'get')
+        # print(resultJSON)
+        result = getOffer.parseJSON(resultJSON)
+
+        print(result)
+
+    def deleteOffer(self, id):
+        eraseOffer = Offers(self.dunikey,  self.pod)
+        document = eraseOffer.configDocErase(id)
+        result = eraseOffer.sendDocumentSet(document,'delete', id)
+
+        print(result)

lib/cesiumCommon.py

@@ -0,0 +1,51 @@
+import sys, re, json
+from hashlib import sha256
+from lib.natools import fmt, sign, get_privkey
+
+PUBKEY_REGEX = "(?![OIl])[1-9A-Za-z]{42,45}"
+
+def pp_json(json_thing, sort=True, indents=4):
+    # Print beautifull JSON
+    if type(json_thing) is str:
+        print(json.dumps(json.loads(json_thing), sort_keys=sort, indent=indents))
+    else:
+        print(json.dumps(json_thing, sort_keys=sort, indent=indents))
+    return None
+
+class CesiumCommon:
+    def __init__(self, dunikey, pod, noNeedDunikey=False):
+        self.pod = pod
+        self.noNeedDunikey = noNeedDunikey
+        # Get my pubkey from my private key
+        try:
+            self.dunikey = dunikey
+            if not dunikey:
+                raise ValueError("Dunikey is empty")
+        except:
+            sys.stderr.write("Please fill the path to your private key (PubSec)\n")
+            sys.exit(1)
+
+        if noNeedDunikey:
+            self.pubkey = self.dunikey
+        else:
+            self.pubkey = get_privkey(dunikey, "pubsec").pubkey
+
+        if not re.match(PUBKEY_REGEX, self.pubkey) or len(self.pubkey) > 45:
+            sys.stderr.write("La clé publique n'est pas au bon format.\n")
+            sys.exit(1)
+
+    def signDoc(self, document):
+        # Generate hash of document
+        hashDoc = sha256(document.encode()).hexdigest().upper()
+
+        # Generate signature of document
+        signature = fmt["64"](sign(hashDoc.encode(), get_privkey(self.dunikey, "pubsec"))[:-len(hashDoc.encode())]).decode()
+
+        # Build final document
+        data = {}
+        data['hash'] = hashDoc
+        data['signature'] = signature
+        signJSON = json.dumps(data)
+        finalJSON = {**json.loads(signJSON), **json.loads(document)}
+
+        return json.dumps(finalJSON)

lib/crypt.py

@@ -0,0 +1,31 @@
+#!/usr/bin/env python3
+
+import base64, base58, sys, string, random
+from natools import get_privkey, box_decrypt, box_encrypt, fmt
+
+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
+
+cmd = sys.argv[1]
+
+dunikey = getargv("-k", "private.dunikey")
+msg = getargv("-m", "test")
+pubkey = getargv("-p")
+
+def decrypt(msg):
+    msg64 = base64.b64decode(msg)
+    return box_decrypt(msg64, get_privkey(dunikey, "pubsec"), pubkey).decode()
+
+def encrypt(msg):
+    return fmt["64"](box_encrypt(msg.encode(), get_privkey(dunikey, "pubsec"), pubkey)).decode()
+
+if cmd == 'decrypt':
+    clear = decrypt(msg)
+    print(clear)
+elif cmd == 'encrypt':
+    clear = encrypt(msg)
+    print(clear)
+

lib/currentUd.py

@@ -0,0 +1,40 @@
+#!/usr/bin/env python3
+
+import sys, re, os.path, json, ast
+from termcolor import colored
+from lib.natools import fmt, sign, get_privkey
+from gql import gql, Client
+from gql.transport.aiohttp import AIOHTTPTransport
+
+class currentUd:
+
+    def __init__(self, node):
+        # Define Duniter GVA node
+        transport = AIOHTTPTransport(url=node)
+        self.client = Client(transport=transport, fetch_schema_from_transport=True)
+
+    def sendDoc(self):
+        # Build UD generation document
+        queryBuild = gql(
+            """
+            query {
+                currentUd {
+                    amount
+                }
+            }
+        """
+        )
+        paramsBuild = {
+        }
+
+        # Send UD document
+        try:
+            udValue = self.client.execute(queryBuild, variable_values=paramsBuild)
+        except Exception as e:
+            message = ast.literal_eval(str(e))["message"]
+            sys.stderr.write("Echec de récupération du DU:\n" + message + "\n")
+            sys.exit(1)
+            
+        udValueFinal = udValue['currentUd']['amount']
+    
+        return udValueFinal

lib/gva.py

@@ -0,0 +1,76 @@
+from lib.currentUd import currentUd
+import sys, re
+from lib.natools import get_privkey
+from lib.gvaPay import Transaction, PUBKEY_REGEX
+from lib.gvaHistory import History
+from lib.gvaBalance import Balance
+from lib.gvaID import Id
+
+class GvaApi():
+    def __init__(self, dunikey, node, pubkey, noNeedDunikey=False):
+        self.noNeedDunikey = noNeedDunikey
+        self.dunikey = dunikey
+        self.node = node
+        if noNeedDunikey:
+            self.pubkey = self.dunikey
+        else:
+            self.pubkey = get_privkey(dunikey, "pubsec").pubkey
+
+        if pubkey:
+            self.destPubkey = pubkey
+        else:
+            self.destPubkey = self.pubkey
+
+        try:
+            if not re.match(PUBKEY_REGEX, self.pubkey) or len(self.pubkey) > 45:
+                raise ValueError("La clé publique n'est pas au bon format.")
+        except:
+            sys.stderr.write("La clé publique n'est pas au bon format.\n")
+            raise
+
+        try:
+            if not re.match(PUBKEY_REGEX, self.destPubkey) or len(self.destPubkey) > 45:
+                raise ValueError("La clé publique n'est pas au bon format.")
+        except:
+            sys.stderr.write("La clé publique n'est pas au bon format.\n")
+            raise
+
+    #################### Payments ####################
+
+    def pay(self, amount, comment, mempool, verbose):
+        gva = Transaction(self.dunikey, self.node, self.destPubkey, amount, comment, mempool, verbose)
+        gva.genDoc()
+        gva.checkTXDoc()
+        gva.signDoc()
+        return gva.sendTXDoc()
+
+    def history(self, isJSON=False, noColors=False, number=10):
+        gva = History(self.dunikey, self.node, self.destPubkey)
+        gva.sendDoc(number)
+        transList = gva.parseHistory()
+
+        if isJSON:
+            transJson = gva.jsonHistory(transList)
+            print(transJson)
+        else:
+            gva.printHistory(transList, noColors)
+    
+    def balance(self, useMempool):
+        gva = Balance(self.dunikey, self.node, self.destPubkey, useMempool)
+        balanceValue = gva.sendDoc()
+        print(balanceValue)
+    
+    def id(self, pubkey, username):
+        gva = Id(self.dunikey, self.node, pubkey, username)
+        result = gva.sendDoc()
+        print(result)
+
+    def idBalance(self, pubkey):
+        gva = Id(self.dunikey, self.node, pubkey)
+        result = gva.sendDoc(True)
+        print(result)
+    
+    def currentUd(self):
+        gva = currentUd(self.node)
+        result = gva.sendDoc()
+        print(result)

lib/gvaBalance.py

@@ -0,0 +1,53 @@
+#!/usr/bin/env python3
+
+import sys, re, os.path, json, ast
+from termcolor import colored
+from lib.natools import fmt, sign, get_privkey
+from gql import gql, Client
+from gql.transport.aiohttp import AIOHTTPTransport
+
+PUBKEY_REGEX = "(?![OIl])[1-9A-Za-z]{42,45}"
+
+class Balance:
+
+    def __init__(self, dunikey, node, pubkey, useMempool=False):
+        self.dunikey = dunikey
+        self.pubkey = pubkey if pubkey else get_privkey(dunikey, "pubsec").pubkey
+        self.useMempool = useMempool
+        if not re.match(PUBKEY_REGEX, self.pubkey) or len(self.pubkey) > 45:
+            sys.stderr.write("La clé publique n'est pas au bon format.\n")
+            sys.exit(1)
+
+        # Define Duniter GVA node
+        transport = AIOHTTPTransport(url=node)
+        self.client = Client(transport=transport, fetch_schema_from_transport=True)
+
+    def sendDoc(self):
+        # Build balance generation document
+        queryBuild = gql(
+            """
+            query ($pubkey: PkOrScriptGva!){
+                balance(script: $pubkey) {
+                    amount
+                }
+            }
+        """
+        )
+        paramsBuild = {
+            "pubkey": self.pubkey
+        }
+
+        # Send balance document
+        try:
+            balanceResult = self.client.execute(queryBuild, variable_values=paramsBuild)
+        except Exception as e:
+            message = ast.literal_eval(str(e))["message"]
+            sys.stderr.write("Echec de récupération du solde:\n" + message + "\n")
+            sys.exit(1)
+            
+        if (balanceResult['balance'] == None): balanceValue = 'null'
+        else:
+            balanceValue = balanceResult['balance']['amount']/100
+
+        # print(balanceValue)
+        return balanceValue

lib/gvaHistory.py

@@ -0,0 +1,272 @@
+#!/usr/bin/env python3
+
+import sys, re, os.path, json, ast, time, hashlib
+from datetime import datetime
+from duniterpy.key import base58
+from termcolor import colored
+from lib.natools import fmt, sign, get_privkey
+from gql import gql, Client
+from gql.transport.aiohttp import AIOHTTPTransport
+
+PUBKEY_REGEX = "(?![OIl])[1-9A-Za-z]{42,45}"
+
+class History:
+
+    def __init__(self, dunikey, node, pubkey):
+        self.dunikey = dunikey
+        self.pubkey = pubkey if pubkey else get_privkey(dunikey, "pubsec").pubkey
+        self.node = node
+        if not re.match(PUBKEY_REGEX, self.pubkey) or len(self.pubkey) > 45:
+            sys.stderr.write("La clé publique n'est pas au bon format.\n")
+            sys.exit(1)
+
+        # Define Duniter GVA node
+        transport = AIOHTTPTransport(url=node)
+        self.client = Client(transport=transport, fetch_schema_from_transport=True)
+
+    def sendDoc(self, number):
+        # Build history generation document
+        queryBuild = gql(
+            """
+            query ($pubkey: PubKeyGva!, $script: PkOrScriptGva!, $number: Int!){
+                txsHistoryBc(
+                    script: $script
+                    pagination: { pageSize: $number, ord: DESC }
+                ) {
+                    both {
+                        pageInfo {
+                            hasPreviousPage
+                            hasNextPage
+                        }
+                        edges {
+                            direction
+                            node {
+                                currency
+                                issuers
+                                outputs
+                                comment
+                                writtenTime
+                            }
+                        }
+                    }
+                }
+                txsHistoryMp(pubkey: $pubkey) {
+                    receiving {
+                        currency
+                        issuers
+                        comment
+                        outputs
+                        receivedTime
+                    }
+                    receiving {
+                        currency
+                        issuers
+                        comment
+                        outputs
+                        receivedTime
+                    }
+                }
+                balance(script: $script) {
+                    amount
+                    base
+                }
+                node {
+                    peer {
+                        currency
+                    }
+                }
+                currentUd {
+                    amount
+                    base
+                }
+            }
+        """
+        )
+        paramsBuild = {
+            "pubkey": self.pubkey,
+            "number": number,
+            "script": f"SIG({self.pubkey})",
+        }
+
+        # Send history document
+        try:
+            self.historyDoc = self.client.execute(queryBuild, variable_values=paramsBuild)
+        except Exception as e:
+            message = ast.literal_eval(str(e))["message"]
+            sys.stderr.write("Echec de récupération de l'historique:\n" + message + "\n")
+            sys.exit(1)
+
+
+    def parseHistory(self):
+        trans = []
+        i = 0
+
+        currentBase = int(self.historyDoc['currentUd']['base'])
+        self.UD = self.historyDoc['currentUd']['amount']/100
+
+
+        # Parse transactions in blockchain
+        resBc = []
+        resBc = self.historyDoc['txsHistoryBc']['both']['edges']
+        for j, transaction in enumerate(resBc):
+            # print(transaction)
+            direction = resBc[j]['direction']
+            transaction = resBc[j]['node']
+            output = transaction['outputs'][0]
+            outPubkey = output.split("SIG(")[1].replace(')','')
+            # if direction == 'RECEIVED' or self.pubkey != outPubkey:
+            trans.append(i)
+            trans[i] = []
+            trans[i].append(direction)
+            trans[i].append(transaction['writtenTime'])
+            if direction == 'SENT':
+                trans[i].append(outPubkey)
+                amount = int('-' + output.split(':')[0])
+            else:
+                trans[i].append(transaction['issuers'][0])
+                amount = int(output.split(':')[0])
+            base = int(output.split(':')[1])
+            applyBase = base-currentBase
+            amount = round(amount*pow(10,applyBase)/100, 2)
+            # if referential == 'DU': amount = round(amount/UD, 2)
+            trans[i].append(amount)
+            trans[i].append(round(amount/self.UD, 2))
+            trans[i].append(transaction['comment'])
+            trans[i].append(base)
+            i += 1
+
+        # Parse transactions in mempool
+        for direction in self.historyDoc['txsHistoryMp']:
+            resBc = []
+            resBc = self.historyDoc['txsHistoryMp'][direction]
+            for j, transaction in enumerate(resBc):
+                # print(transaction)
+                transaction = resBc[j]
+                output = transaction['outputs'][0]
+                outPubkey = output.split("SIG(")[1].replace(')','')
+                # if direction == 'RECEIVING' or self.pubkey != outPubkey:
+                trans.append(i)
+                trans[i] = []
+                trans[i].append(direction)
+                trans[i].append(int(time.time()))
+                if direction == 'SENDING':
+                    trans[i].append(outPubkey)
+                    amount = int('-' + output.split(':')[0])
+                else:
+                    trans[i].append(transaction['issuers'][0])
+                    amount = int(output.split(':')[0])
+                base = int(output.split(':')[1])
+                applyBase = base-currentBase
+                amount = round(amount*pow(10,applyBase)/100, 2)
+                # if referential == 'DU': amount = round(amount/UD, 2)
+                trans[i].append(amount)
+                trans[i].append(round(amount/self.UD, 2))
+                trans[i].append(transaction['comment'])
+                trans[i].append(base)
+                i += 1
+
+        # Order transactions by date
+        trans.sort(key=lambda x: x[1])
+
+        # Keep only base if there is base change
+        lastBase = 0
+        for i in trans:
+            if i[6] == lastBase: i[6] = None
+            else: lastBase = i[6]
+        
+        return trans
+
+    def printHistory(self, trans, noColors):
+        # Get balance
+        if (self.historyDoc['balance'] == None): 
+            balance = balanceUD = 'null'
+        else:
+    
+            balance = self.historyDoc['balance']['amount']/100
+            balanceUD = round(balance/self.UD, 2)
+
+        # Get currency
+        currency = self.historyDoc['node']['peer']['currency']
+        if currency == 'g1': currency = 'Ḡ1'
+        elif currency == 'g1-test': currency = 'GT'
+        # if referential == 'DU': currency = 'DU/' + currency.lower()
+
+        # Get terminal size
+        rows = int(os.popen('stty size', 'r').read().split()[1])
+
+        # Display history
+        print('+', end='')
+        print('-'.center(rows-1, '-'))
+        if noColors: isBold = isBoldEnd = ''
+        else:
+            isBold = '\033[1m'
+            isBoldEnd = '\033[0m'
+        print(isBold + "|{: <19} | {: <12} | {: <7} | {: <7} | {: <30}".format("        Date","   De / À","  {0}".format(currency)," DU/{0}".format(currency.lower()),"Commentaire") + isBoldEnd)
+        print('|', end='')
+        for t in trans:
+            if t[0] == "RECEIVED": color = "green"
+            elif t[0] == "SENT": color = "blue"
+            elif t[0] == "receiving": color = "yellow"
+            elif t[0] == "sending": color = "red"
+            else: color = None
+            if noColors:
+                color = None
+                if t[0] in ('RECEIVING','SENDING'):
+                    comment = '(EN ATTENTE) ' + t[5]
+                else:
+                    comment = t[5]
+            else:
+                comment = t[5]
+
+            date = datetime.fromtimestamp(t[1]).strftime("%d/%m/%Y à %H:%M")
+            print('-'.center(rows-1, '-'))
+            if t[6]:
+                print('|', end='')
+                print('  Changement de base : {0}  '.format(t[6]).center(rows-1, '#'))
+                print('|', end='')
+                print('-'.center(rows-1, '-'))
+            print('|', end='')
+            checksum = self.gen_checksum(t[2])
+            shortPubkey = t[2][0:4] + '\u2026' + t[2][-4:] + ':' + checksum
+            if noColors:
+                print(" {: <18} | {: <12} | {: <7} | {: <7} | {: <30}".format(date, shortPubkey, t[3], t[4], comment))
+            else:
+                print(colored(" {: <18} | {: <12} | {: <7} | {: <7} | {: <30}".format(date, shortPubkey, t[3], t[4], comment), color))
+            print('|', end='')
+        print('-'.center(rows-1, '-'))
+        print('|', end='')
+        print(isBold + 'Solde du compte: {0} {1} ({2} DU/{3})'.format(balance, currency, balanceUD, currency.lower()).center(rows-1, ' ') + isBoldEnd)
+        print('+', end='')
+        print(''.center(rows-1, '-'))
+        if not noColors:
+            print(colored('Reçus', 'green'), '-', colored('En cours de réception', 'yellow'), '-', colored('Envoyé', 'blue'), '-', colored("En cours d'envoi", 'red'))
+
+        return trans
+    
+    def gen_checksum(self, pubkey):
+        """
+        Returns the checksum of the input pubkey (encoded in b58)
+        thx Matograine
+        """
+        pubkey_byte = base58.Base58Encoder.decode(str.encode(pubkey))
+        hash = hashlib.sha256(hashlib.sha256(pubkey_byte).digest()).digest()
+        return base58.Base58Encoder.encode(hash)[:3]
+
+    def jsonHistory(self, transList):
+        dailyJSON = []
+        for i, trans in enumerate(transList):
+            dailyJSON.append(i)
+            dailyJSON[i] = {}
+            dailyJSON[i]['date'] = trans[1]
+            dailyJSON[i]['pubkey'] = trans[2]
+            dailyJSON[i]['amount'] = trans[3]
+            dailyJSON[i]['amountUD'] = trans[4]
+            dailyJSON[i]['comment'] = trans[5]
+
+        dailyJSON = json.dumps(dailyJSON, indent=2)
+        # If we want to write JSON to a file
+        #jsonFile = open("history-{0}.json".format(self.pubkey[0:8]), "w")
+        #jsonFile.writelines(dailyJSON + '\n')
+        #jsonFile.close()
+        return dailyJSON
+

lib/gvaID.py

@@ -0,0 +1,81 @@
+#!/usr/bin/env python3
+
+import sys, re, os.path, json, ast
+from termcolor import colored
+from lib.natools import fmt, sign, get_privkey
+from gql import gql, Client
+from gql.transport.aiohttp import AIOHTTPTransport
+
+PUBKEY_REGEX = "(?![OIl])[1-9A-Za-z]{42,45}"
+
+class Id:
+
+    def __init__(self, dunikey, node, pubkey='', username=''):
+       
+        self.dunikey = dunikey
+        self.pubkey = pubkey if pubkey else get_privkey(dunikey, "pubsec").pubkey
+        self.username = username
+        # if not re.match(PUBKEY_REGEX, self.pubkey) or len(self.pubkey) > 45:
+        #     sys.stderr.write("La clé publique n'est pas au bon format.\n")
+        #     sys.exit(1)
+
+        # Define Duniter GVA node
+        transport = AIOHTTPTransport(url=node)
+        self.client = Client(transport=transport, fetch_schema_from_transport=True)
+
+    def sendDoc(self, getBalance=False):
+        # Build balance generation document
+        if (getBalance):
+            queryBuild = gql(
+                """
+                query ($pubkey: PubKeyGva!, $script: PkOrScriptGva!){
+                    idty (pubkey: $pubkey) {
+                        isMember
+                        username
+                    }
+                    balance(script: $script) {
+                    amount
+                    }
+                }
+            """
+            )
+        else:
+            queryBuild = gql(
+                """
+                query ($pubkey: PubKeyGva!){
+                    idty (pubkey: $pubkey) {
+                        isMember
+                        username
+                    }
+                }
+            """
+            )
+        
+        paramsBuild = {
+            "pubkey": self.pubkey,
+            "script": f"SIG({self.pubkey})"
+        }
+
+        # Send balance document
+        try:
+            queryResult = self.client.execute(queryBuild, variable_values=paramsBuild)
+        except Exception as e:
+            sys.stderr.write("Echec de récupération du solde:\n" + str(e) + "\n")
+            sys.exit(1)
+
+        jsonBrut = queryResult
+        
+        if (getBalance):            
+            if (queryResult['balance'] == None):
+                jsonBrut['balance'] = {"amount": 0.0}
+            else:
+                jsonBrut['balance'] = queryResult['balance']['amount']/100
+                
+        if (queryResult['idty'] == None):
+            username = 'Matiou'
+            isMember = False
+        else:
+            username = queryResult['idty']['username']
+            isMember = queryResult['idty']['isMember']
+
+        return json.dumps(jsonBrut, indent=2)

lib/gvaPay.py

@@ -0,0 +1,172 @@
+#!/usr/bin/env python3
+
+import sys, re, os.path, json, ast
+from termcolor import colored
+from lib.natools import fmt, sign, get_privkey
+from gql import gql, Client
+from gql.transport.aiohttp import AIOHTTPTransport
+
+PUBKEY_REGEX = "(?![OIl])[0-9A-Za-z]{42,45}"
+
+class Transaction:
+
+    def __init__(self, dunikey, node, recipient, amount, comment='', useMempool=False, verbose=False):
+        self.dunikey = dunikey
+        self.recipient = recipient
+        self.amount = int(amount*100)
+        self.comment = comment
+        self.issuer = get_privkey(dunikey, "pubsec").pubkey
+        self.useMempool = useMempool
+        self.verbose = verbose
+        self.node = node
+        self._isChange = False
+
+        try:
+            if not re.match(PUBKEY_REGEX, recipient) or len(recipient) > 45:
+                raise ValueError("La clé publique n'est pas au bon format.")
+        except:
+            sys.stderr.write("La clé publique n'est pas au bon format.\n")
+            raise
+
+
+        try:
+            if recipient == self.issuer:
+                raise ValueError('Le destinataire ne peut pas être vous même.')
+        except:
+            sys.stderr.write("Le destinataire ne peut pas être vous même.\n")
+            raise
+
+
+        # Define Duniter GVA node
+        transport = AIOHTTPTransport(url=node)
+        self.client = Client(transport=transport, fetch_schema_from_transport=True)
+
+    def genDoc(self):
+        # Build TX generation document
+        if self.verbose: print("useMempool:", str(self.useMempool))
+        queryBuild = gql(
+            """
+            query ($recipient: PkOrScriptGva!, $issuer: PubKeyGva!, $amount: Int!, $comment: String!, $useMempool: Boolean!){ genTx(
+            amount: $amount
+            comment: $comment
+            issuer: $issuer
+            recipient: $recipient
+            useMempoolSources: $useMempool
+            )
+        }
+        """
+        )
+        paramsBuild = {
+            "recipient": self.recipient,
+            "issuer": self.issuer,
+            "amount": int(self.amount),
+            "comment": self.comment,
+            "useMempool": self.useMempool
+        }
+
+        # Send TX document
+        try:
+            # self.txDoc = []
+            self.txDoc =  self.client.execute(queryBuild, variable_values=paramsBuild)['genTx']
+            if self.verbose: print(self.txDoc[0])
+            return self.txDoc
+        except Exception as e:
+            message = ast.literal_eval(str(e))["message"]
+            sys.stderr.write("Echec de la génération du document:\n" + message + "\n")
+            raise
+
+
+    # Check document
+    def checkTXDoc(self):
+        issuerRaw=[];outAmount=[];outPubkey=[];commentRaw=[]
+        for docs in self.txDoc:
+            docList = docs.splitlines()
+            for i, line in enumerate(docList):
+                if re.search("Issuers:", line):
+                    issuerRaw.append(docList[(i + 1) % len(docList)])
+                if re.search("Outputs:", line):
+                    outputRaw = docList[(i + 1) % len(docList)].split(":")
+                    outAmount.append(int(outputRaw[0]))
+                    outPubkey.append(outputRaw[2].split("SIG(")[1].replace(')',''))
+                if re.search("Comment:", line):
+                    commentRaw.append(line.split(': ', 1)[1])
+
+        # Check if it's only a change transaction
+        if all(i == self.issuer for i in outPubkey):
+            print("Le document contient une transaction de change")
+            self.isChange = True
+        # Check validity of the document
+        elif all(i != self.issuer for i in issuerRaw) or sum(outAmount) != self.amount or all(i != self.recipient for i in outPubkey) or all(i != self.comment for i in commentRaw):
+            sys.stderr.write(colored("Le document généré est corrompu !\nLe noeud " + self.node + "a peut être un dysfonctionnement.\n", 'red'))
+            sys.stderr.write(colored(issuerRaw[0] + " envoi " + str(outAmount[0]) + " vers " + outPubkey[0] + " with comment: " + commentRaw[0] + "\n", "yellow"))
+            raise ValueError('Le document généré est corrompu !')
+        else:
+            print("Le document généré est conforme.")
+            self.isChange = False
+            return self.txDoc
+
+    def signDoc(self):
+        # Sign TX documents
+        signature=[]
+        self.signedDoc=[]
+        for i, docs in enumerate(self.txDoc):
+            signature.append(fmt["64"](sign(docs.encode(), get_privkey(self.dunikey, "pubsec"))[:-len(docs.encode())]))
+            self.signedDoc.append(docs + signature[i].decode())
+        return self.signedDoc
+
+
+    def sendTXDoc(self):
+        # Build TX documents
+        txResult=[]
+        for docs in self.signedDoc:
+            querySign = gql(
+                """
+                mutation ($signedDoc: String!){ tx(
+                rawTx: $signedDoc
+                ) {
+                    version
+                    issuers
+                    outputs
+                }
+            }
+            """
+            )
+            paramsSign = {
+                "signedDoc": docs
+            }
+
+            # Send TX Signed document
+            try:
+                txResult.append(str(self.client.execute(querySign, variable_values=paramsSign)))
+            except Exception as e:
+                message = ast.literal_eval(str(e))["message"]
+                sys.stderr.write("Echec de la transaction:\n" + message + "\n")
+                if self.verbose:
+                    sys.stderr.write("Document final:\n" + docs)
+                raise ValueError(message)
+            else:
+                if self.isChange:
+                    self.send()
+                else:
+                    print(colored("Transaction effectué avec succès !", "green"))
+                    if self.verbose:
+                        print(docs)
+                    break
+
+        return txResult
+
+    def _getIsChange(self):
+        return self._isChange
+    def _setIsChange(self, newChange):
+        if self.verbose: print("_setIsChange: ", str(newChange))
+        self._isChange = newChange
+        if newChange: self.useMempool == True
+    isChange = property(_getIsChange, _setIsChange)
+
+    def send(self):
+        result = self.genDoc()
+        result = self.checkTXDoc()
+        result = self.signDoc()
+        result = self.sendTXDoc()
+        return result
+

lib/messaging.py

@@ -0,0 +1,236 @@
+import os, sys, ast, requests, json, base58, base64
+from time import time
+from datetime import datetime
+from termcolor import colored
+from lib.natools import fmt, get_privkey, box_decrypt, box_encrypt
+from lib.cesiumCommon import CesiumCommon, pp_json, PUBKEY_REGEX
+
+
+#################### Reading class ####################
+
+
+class ReadFromCesium(CesiumCommon):
+    # Configure JSON document to send
+    def configDoc(self, nbrMsg, outbox):
+        boxType = "issuer" if outbox else "recipient"
+
+        data = {}
+        data['sort'] = { "time": "desc" }
+        data['from'] = 0
+        data['size'] = nbrMsg
+        data['_source'] = ['issuer','recipient','title','content','time','nonce','read_signature']
+        data['query'] = {}
+        data['query']['bool'] = {}
+        data['query']['bool']['filter'] = {}
+        data['query']['bool']['filter']['term'] = {}
+        data['query']['bool']['filter']['term'][boxType] = self.pubkey
+
+        document = json.dumps(data)
+        return document
+
+    def sendDocument(self, nbrMsg, outbox):
+        boxType = "outbox" if outbox else "inbox"
+
+        document = self.configDoc(nbrMsg, outbox)
+        headers = {
+            'Content-type': 'application/json',
+        }
+
+        # Send JSON document and get JSON result
+        result = requests.post('{0}/message/{1}/_search'.format(self.pod, boxType), headers=headers, data=document)
+        if result.status_code == 200:
+            return result.json()["hits"]
+        else:
+            sys.stderr.write("Echec de l'envoi du document de lecture des messages...\n" + result.text)
+
+    # Parse JSON result and display messages
+    def readMessages(self, msgJSON, nbrMsg, outbox):
+        def decrypt(msg):
+            msg64 = base64.b64decode(msg)
+            return box_decrypt(msg64, get_privkey(self.dunikey, "pubsec"), self.issuer, nonce).decode()
+
+        # Get terminal size
+        rows = int(os.popen('stty size', 'r').read().split()[1])
+
+        totalMsg = msgJSON["total"]
+        if nbrMsg > totalMsg:
+            nbrMsg = totalMsg
+
+        if totalMsg == 0:
+            print(colored("Aucun message à afficher.", 'yellow'))
+            return True
+        else:
+            infoTotal = "  Nombre de messages: " + str(nbrMsg) + "/" + str(totalMsg) + "  "
+            print(colored(infoTotal.center(rows, '#'), "yellow"))
+            for hits in msgJSON["hits"]:
+                self.idMsg = hits["_id"]
+                msgSrc = hits["_source"]
+                self.issuer = msgSrc["issuer"]
+                nonce = msgSrc["nonce"]
+                nonce = base58.b58decode(nonce)
+                self.dateS = msgSrc["time"]
+                date = datetime.fromtimestamp(self.dateS).strftime(", le %d/%m/%Y à %H:%M  ")
+                if outbox:
+                    startHeader = "  À " + msgSrc["recipient"]
+                else:
+                    startHeader = "  De " + self.issuer
+                headerMsg = startHeader + date + "(ID: {})".format(self.idMsg) + "  "
+
+                print('-'.center(rows, '-'))
+                print(colored(headerMsg, "blue").center(rows+9, '-'))
+                print('-'.center(rows, '-'))
+                try:
+                    self.title = decrypt(msgSrc["title"])
+                    self.content = decrypt(msgSrc["content"])
+                except Exception as e:
+                    sys.stderr.write(colored(str(e), 'red') + '\n')
+                    pp_json(hits)
+                    continue
+                print('\033[1m' + self.title + '\033[0m')
+                print(self.content)
+                
+            print(colored(infoTotal.center(rows, '#'), "yellow"))
+    
+    # Parse JSON result and display messages
+    def jsonMessages(self, msgJSON, nbrMsg, outbox):
+        def decrypt(msg):
+            msg64 = base64.b64decode(msg)
+            return box_decrypt(msg64, get_privkey(self.dunikey, "pubsec"), self.issuer, nonce).decode()
+
+        totalMsg = msgJSON["total"]
+        if nbrMsg > totalMsg:
+            nbrMsg = totalMsg
+
+        if totalMsg == 0:
+            print("Aucun message à afficher")
+            return True
+        else:
+            data = []
+            # data.append({})
+            # data[0]['total'] = totalMsg
+            for i, hits in enumerate(msgJSON["hits"]):
+                self.idMsg = hits["_id"]
+                msgSrc = hits["_source"]
+                self.issuer = msgSrc["issuer"]
+                nonce = msgSrc["nonce"]
+                nonce = base58.b58decode(nonce)
+                self.date = msgSrc["time"]
+
+                if outbox:
+                    pubkey = msgSrc["recipient"]
+                else:
+                    pubkey = self.issuer
+
+                try:
+                    self.title = decrypt(msgSrc["title"])
+                    self.content = decrypt(msgSrc["content"])
+                except Exception as e:
+                    sys.stderr.write(colored(str(e), 'red') + '\n')
+                    pp_json(hits)
+                    continue
+
+                data.append(i)
+                data[i] = {}
+                data[i]['id'] = self.idMsg
+                data[i]['date'] = self.date
+                data[i]['pubkey'] = pubkey
+                data[i]['title'] = self.title
+                data[i]['content'] = self.content
+
+            data = json.dumps(data, indent=2)
+            return data
+
+
+#################### Sending class ####################
+
+
+class SendToCesium(CesiumCommon):
+    def encryptMsg(self, msg):
+        return fmt["64"](box_encrypt(msg.encode(), get_privkey(self.dunikey, "pubsec"), self.recipient, self.nonce)).decode()
+
+    def configDoc(self, title, msg):
+        b58nonce = base58.b58encode(self.nonce).decode()
+
+        # Get current timestamp
+        timeSent = int(time())
+
+        # Generate custom JSON
+        data = {}
+        data['issuer'] = self.pubkey
+        data['recipient'] = self.recipient
+        data['title'] = title
+        data['content'] = msg
+        data['time'] = timeSent
+        data['nonce'] = b58nonce
+        data['version'] = 2
+        document = json.dumps(data)
+
+        return self.signDoc(document)
+
+
+    def sendDocument(self, document, outbox):
+        boxType = "outbox" if outbox else "inbox"
+
+        headers = {
+            'Content-type': 'application/json',
+        }
+
+        # Send JSON document and get result
+        try:
+            result = requests.post('{0}/message/{1}?pubkey={2}'.format(self.pod, boxType, self.recipient), headers=headers, data=document)
+        except Exception as e:
+            sys.stderr.write("Impossible d'envoyer le message:\n" + str(e))
+            sys.exit(1)
+        else:
+            if result.status_code == 200:
+                print(colored("Message envoyé avec succès !", "green"))
+                print("ID: " + result.text)
+                return result
+            else:
+                sys.stderr.write("Erreur inconnue:" + '\n')
+                print(str(pp_json(result.text)) + '\n')
+
+
+#################### Deleting class ####################
+
+
+class DeleteFromCesium(CesiumCommon):
+    def configDoc(self, idMsg, outbox):
+        # Get current timestamp
+        timeSent = int(time())
+
+        boxType = "outbox" if outbox else "inbox"
+
+        # Generate document to customize
+        data = {}
+        data['version'] = 2
+        data['index'] = "message"
+        data['type'] = boxType
+        data['id'] = idMsg
+        data['issuer'] = self.pubkey
+        data['time'] = timeSent
+        document = json.dumps(data)
+
+        return self.signDoc(document)
+
+    def sendDocument(self, document, idMsg):
+        headers = {
+            'Content-type': 'application/json',
+        }
+
+        # Send JSON document and get result
+        try:
+            result = requests.post('{0}/history/delete'.format(self.pod), headers=headers, data=document)
+            if result.status_code == 404:
+                raise ValueError("Message introuvable")
+            elif result.status_code == 403:
+                raise ValueError("Vous n'êtes pas l'auteur de ce message.")
+        except Exception as e:
+            sys.stderr.write(colored("Impossible de supprimer le message {0}:\n".format(idMsg), 'red') + str(e) + "\n")
+            return False
+        else:
+            if result.status_code == 200:
+                print(colored("Message {0} supprimé avec succès !".format(idMsg), "green"))
+                return result
+            else:
+                sys.stderr.write("Erreur inconnue.")

lib/offers.py

@@ -0,0 +1,138 @@
+import sys, re, json, requests, base64
+from time import time
+from lib.cesiumCommon import CesiumCommon, PUBKEY_REGEX
+
+class Offers(CesiumCommon):
+    # Configure JSON document SET to send
+    def configDocSet(self, title, description, city, localisation, category, price: float, picture):
+        timeSent = int(time())
+
+# {"parent":"cat90","localizedNames":{"en":"Fruits & Vegetables","es-ES":"Frutas y Vegetales","fr-FR":"Fruits & Légumes"},"name":"Fruits & Légumes","id":"cat92"}
+
+        data = {}
+        if title: data['title'] = title
+        if description: data['description'] = description
+        if city: data['city'] = city
+        if localisation: 
+            geoPoint = {}
+            geoPoint['lat'] = localisation[0]
+            geoPoint['lon'] = localisation[1]
+            data['geoPoint'] = geoPoint
+        if picture:
+            picture = open(picture, 'rb').read()
+            picture = base64.b64encode(picture).decode()
+            data['thumbnail'] = {}
+            data['thumbnail']['_content'] = picture
+            data['thumbnail']['_content_type'] = "image/png"
+        # if category: data['category'] = category
+        # else: 
+        data['category'] = {"parent":"cat24","localizedNames":{"en":"DVD / Films","es-ES":"DVDs / Cine","fr-FR":"DVD / Films"},"name":"DVD / Films","id":"cat25"}
+        if price: data['price'] = float(price) * 100
+        data['type'] = 'offer'
+        data['time'] = timeSent
+        data['creationTime'] = timeSent
+        data['issuer'] = self.pubkey
+        data['pubkey'] = self.pubkey
+        data['version'] = 2
+        data['currency'] = 'g1'
+        data['unit'] = None
+        data['fees'] = None
+        data['feesCurrency'] = None
+        if picture: data['picturesCount'] = 1
+        else: data['picturesCount'] = 0
+        data['stock'] = 1
+        data['tags'] = []
+
+        document =  json.dumps(data)
+
+        return self.signDoc(document)
+
+    # Configure JSON document SET to send
+    def configDocErase(self, id):
+        timeSent = int(time())
+
+# "currency":"g1","unit":null,"fees":null,"feesCurrency":null,"picturesCount":0,"stock":0,"tags":[],"id":"AXehXeyZaml2THvBAeS5","creationTime":1613320117}
+#AXehXeyZaml2THvBAeS5
+
+
+        offerToDeleteBrut = self.sendDocumentGet(id, 'get')
+        offerToDelete = json.loads(self.parseJSON(offerToDeleteBrut))
+
+        title = offerToDelete['title']
+        creationTime = offerToDelete['time']
+        issuer = offerToDelete['issuer']
+        pubkey = offerToDelete['pubkey']
+
+        data = {}
+        data['title'] = title
+        data['time'] = timeSent
+        data['creationTime'] = creationTime
+        data['id'] = id
+        data['issuer'] = issuer
+        data['pubkey'] = pubkey
+        data['version'] = 2
+        data['type'] = "offer"
+        data['currency'] = "g1"
+        data['unit'] = None
+        data['fees'] = None
+        data['feesCurrency'] = None
+        data['picturesCount'] = 0
+        data['stock'] = 0
+        data['tags'] = []
+
+        document =  json.dumps(data)
+
+        return self.signDoc(document)
+
+    def sendDocumentGet(self, id, type):
+
+        headers = {
+            'Content-type': 'application/json',
+        }
+
+        # Send JSON document and get JSON result
+        if type == 'set':
+            reqQuery = '{0}/market/record'.format(self.pod)
+        elif type == 'get':
+            reqQuery = '{0}/market/record/{1}?_source=category,title,description,issuer,time,creationTime,location,address,city,price,unit,currency,thumbnail._content_type,thumbnail._content,picturesCount,type,stock,fees,feesCurrency,geoPoint,pubkey,freePrice'.format(self.pod, id)
+        elif type == 'erase':
+            reqQuery = '{0}/market/delete'.format(self.pod)
+            
+
+        result = requests.get(reqQuery, headers=headers)
+        # print(result)
+        if result.status_code == 200:
+            # print(result.text)
+            return result.text
+        else:
+            sys.stderr.write("Echec de l'envoi du document...\n" + result.text + '\n')
+
+
+    def sendDocumentSet(self, document, type, id=None):
+    
+        headers = {
+            'Content-type': 'application/json',
+        }
+
+        # Send JSON document and get JSON result
+        if type == 'set':
+            reqQuery = '{0}/market/record'.format(self.pod)
+        if type == 'delete':
+            reqQuery = '{0}/market/record/{1}/_update'.format(self.pod, id)
+
+        result = requests.post(reqQuery, headers=headers, data=document)
+        if result.status_code == 200:
+            # print(result.text)
+            return result.text
+        else:
+            sys.stderr.write("Echec de l'envoi du document...\n" + result.text + '\n')
+
+    def parseJSON(self, doc):
+        doc = json.loads(doc)['_source']
+        if doc:
+            # pubkey = { "pubkey": doc['issuer'] }
+            # rest = { "description": doc['description'] }
+            # final = {**pubkey, **rest}
+            return json.dumps(doc, indent=2)
+        else:
+            return 'Profile vide'

lib/profiles.py

@@ -0,0 +1,125 @@
+import sys, re, json, requests, base64
+from time import time
+from lib.cesiumCommon import CesiumCommon, PUBKEY_REGEX
+
+
+class Profiles(CesiumCommon):
+    # Configure JSON document SET to send
+    def configDocSet(self, name, description, city, address, pos, socials, avatar):
+        timeSent = int(time())
+
+        data = {}
+        if name: data['title'] = name
+        if description: data['description'] = description
+        if address: data['address'] = address
+        if city: data['city'] = city
+        if pos: 
+            geoPoint = {}
+            geoPoint['lat'] = pos[0]
+            geoPoint['lon'] = pos[1]
+            data['geoPoint'] = geoPoint
+        if socials:
+            data['socials'] = []
+            data['socials'].append({})
+            data['socials'][0]['type'] = "web"
+            data['socials'][0]['url'] = socials
+        if avatar:
+            avatar = open(avatar, 'rb').read()
+            avatar = base64.b64encode(avatar).decode()
+            data['avatar'] = {}
+            data['avatar']['_content'] = avatar
+            data['avatar']['_content_type'] = "image/png"
+        data['time'] = timeSent
+        data['issuer'] = self.pubkey
+        data['version'] = 2
+        data['tags'] = []
+
+        document =  json.dumps(data)
+
+        return self.signDoc(document)
+
+   # Configure JSON document GET to send
+    def configDocGet(self, profile, scope='title', getAvatar=None):
+
+        if getAvatar:
+            avatar = "avatar"
+        else:
+            avatar = "avatar._content_type"
+
+        data = {
+                "query": {
+                "bool": {
+                    "should":[
+                        {
+                            "match":{
+                                scope:{
+                                    "query": profile,"boost":2
+                                }
+                            }
+                        },{
+                            "prefix": {scope: profile}
+                        }
+                    ]
+                }
+            },"highlight": {
+                    "fields": {
+                        "title":{},
+                        "tags":{}
+                    }
+                },"from":0,
+                "size":100,
+                "_source":["title", avatar,"description","city","address","socials.url","creationTime","membersCount","type","geoPoint"],
+                "indices_boost":{"user":100,"page":1,"group":0.01
+                }
+        }
+
+        document =  json.dumps(data)
+
+        return document
+
+    # Configure JSON document SET to send
+    def configDocErase(self):
+        timeSent = int(time())
+
+        data = {}
+        data['time'] = timeSent
+        data['id'] = self.pubkey
+        data['issuer'] = self.pubkey
+        data['version'] = 2
+        data['index'] = "user"
+        data['type'] = "profile"
+
+        document =  json.dumps(data)
+
+        return self.signDoc(document)
+
+    def sendDocument(self, document, type):
+
+        headers = {
+            'Content-type': 'application/json',
+        }
+
+        # Send JSON document and get JSON result
+        if type == 'set':
+            reqQuery = '{0}/user/profile?pubkey={1}/_update?pubkey={1}'.format(self.pod, self.pubkey)
+        elif type == 'get':
+            reqQuery = '{0}/user,page,group/profile,record/_search'.format(self.pod)
+        elif type == 'erase':
+            reqQuery = '{0}/history/delete'.format(self.pod)
+
+        result = requests.post(reqQuery, headers=headers, data=document)
+        if result.status_code == 200:
+            # print(result.text)
+            return result.text
+        else:
+            sys.stderr.write("Echec de l'envoi du document...\n" + result.text + '\n')
+
+    def parseJSON(self, doc):
+        doc = json.loads(doc)['hits']['hits']
+        if doc:
+            pubkey = { "pubkey": doc[0]['_id'] }
+            rest = doc[0]['_source']
+            final = {**pubkey, **rest}
+            return json.dumps(final, indent=2)
+        else:
+            return 'Profile vide'

lib/qrcode-reader.py

@@ -0,0 +1,86 @@
+#!/usr/bin/env python3
+
+from io import BytesIO
+import base64, base58, varint, os, json
+# from lib.cesium import CesiumPlus as cs
+
+## BytesIO adds a stream interface to bytes
+## Exemple:
+qr = BytesIO(bytes.fromhex("8316140212c28e52e034ecaf684fa3e5d755db519074f27ad086bddffd26b386e55f3b623ca01f0177c0f8ce5f6a69764c7bc10263ec"))
+
+## Read from a file:
+# qr = open("qrcode-AXfA-M5faml2THvBAmPs.bin","rb")
+# qr = BytesIO(qr.read())
+
+## Check magic number
+assert qr.read(3) == b"\x83\x16\x14"
+
+## Read data type
+data_type = varint.decode_stream(qr)
+
+## Read price type
+raw_price_type = varint.decode_stream(qr)
+price_type = raw_price_type >> 4
+amount_len = raw_price_type & 0b1111
+
+## Read pubkey
+pubkey = qr.read(32)
+pubkey_b58 = base58.b58encode(pubkey)
+# print("Pubkey: {}".format(pubkey_b58.decode("utf-8")))
+
+## Read amount
+
+if price_type == 0: # Free price, ignore amount
+    qr.read(amount_len)
+    print("Free price")
+
+elif price_type == 1: # Units
+    amount = varint.decode_stream(qr)
+    # print("Price: {} Ğ1".format(amount/100))
+
+elif price_type == 2: # UD
+    amount_n = varint.decode_stream(qr)
+    amount_e = varint.decode_stream(qr)
+    amount = amount_n * 10 ** -amount_e
+    # print("Price: {} UD_Ğ1".format(amount.decode("utf-8")))
+
+else:
+    qr.read(amount_len)
+    print("Error: unknown price type, ignoring price")
+
+## Read data
+
+if data_type == 0: # No data
+    data = None
+    print("There is no data")
+
+elif data_type == 1: # Plain text
+    data = qr.read()
+    print("Data:")
+    print(data)
+
+elif data_type == 2: # Ğchange ad
+    data = base64.urlsafe_b64encode(qr.read(16))
+    # print("Ğchange ad ID: {}".format(data.decode("utf-8")))
+  
+    
+## Get gchange-pod datas
+
+item = os.popen("./../jaklis/jaklis.py getoffer -i {0}".format(data.decode("utf-8")))
+# item = cs.getOffer(id)
+
+
+jsonR = json.load(item)
+item_time = jsonR['creationTime']
+item_name = jsonR['title']
+item_description = jsonR['description']
+item_image = jsonR['thumbnail']
+isImage = '_content' in item_image
+if (isImage):
+    print(item_image['_content'])
+
+# print(jsonR)
+print(item_time)
+print(item_name)
+print(item_description)
+

lib/stars.py

@@ -0,0 +1,242 @@
+import os, sys, ast, requests, json, base58, base64, time, string, random, re
+from lib.natools import fmt, sign, get_privkey, box_decrypt, box_encrypt
+from time import sleep
+from hashlib import sha256
+from datetime import datetime
+from termcolor import colored
+from lib.cesiumCommon import CesiumCommon, PUBKEY_REGEX
+
+class ReadLikes(CesiumCommon):
+    # Configure JSON document to send
+    def configDoc(self, profile):
+        if not profile: profile = self.pubkey
+
+        data = {}
+        data['query'] = {}
+        data['query']['bool'] = {}
+        data['query']['bool']['filter'] = [
+            {'term': {'index': 'user'}},
+            {'term': {'type': 'profile'}},
+            {'term': {'id': profile}},
+            {'term': {'kind': 'STAR'}}
+        ]
+        # data['query']['bool']['should'] = {'term':{'issuer': self.issuer}}
+        data['size'] = 5000
+        data['_source'] = ['issuer','level']
+        data['aggs'] = {
+            'level_sum': {
+                'sum': {
+                    'field': 'level'
+                }
+            }
+        }
+
+        return json.dumps(data)
+
+    def sendDocument(self, document):
+
+        headers = {
+            'Content-type': 'application/json',
+        }
+
+        # Send JSON document and get JSON result
+        result = requests.post('{0}/like/record/_search'.format(self.pod), headers=headers, data=document)
+
+        if result.status_code == 200:
+            # print(result.text)
+            return result.text
+        else:
+            sys.stderr.write("Echec de l'envoi du document de lecture des messages...\n" + result.text + '\n')
+
+    def parseResult(self, result):
+        result = json.loads(result)
+        totalLikes = result['hits']['total']
+        totalValue = result['aggregations']['level_sum']['value']
+        if totalLikes:
+            score = totalValue/totalLikes
+        else:
+            score = 0
+        raw = result['hits']['hits']
+        finalPrint = {}
+        finalPrint['likes'] = []
+        for i in raw:
+            issuer = i['_source']['issuer']
+            # print(issuer)
+            gProfile = self.getProfile(issuer)
+            try:
+                pseudo = gProfile['title']
+            except:
+                pseudo = ''
+            try:
+                payTo = gProfile['pubkey']
+            except:
+                payTo = ''
+            id = i['_id']
+            level = i['_source']['level']
+            if issuer == self.pubkey:
+                finalPrint['yours'] = { 'id' : id, 'pseudo' : pseudo, 'payTo' : payTo, 'level' : level }
+            else:
+                finalPrint['likes'].append({ 'issuer' : issuer, 'pseudo' : pseudo, 'payTo' : payTo, 'level' : level })
+        finalPrint['score'] = score
+
+        return json.dumps(finalPrint)
+
+    def getProfile(self, profile):
+        headers = {
+            'Content-type': 'application/json',
+        }
+
+        data = {}
+        data['query'] = {}
+        data['query']['bool'] = {}
+        data['query']['bool']['filter'] = [
+            {'term': {'_index': 'user'}},
+            {'term': {'_type': 'profile'}},
+            {'term': {'_id': profile}}
+        ]
+        data['_source'] = ['title','pubkey']
+
+        data = json.dumps(data)
+
+        result = requests.post('{0}/user/profile/_search'.format(self.pod), headers=headers, data=data)
+        result = json.loads(result.text)['hits']['hits']
+        for i in result:
+            return i['_source']
+
+
+#################### Like class ####################
+
+
+class SendLikes(CesiumCommon):
+    # Configure JSON document to send
+    def configDoc(self, profile, likes):
+        if not profile: profile = self.pubkey
+        if likes not in range(0, 6):
+            sys.stderr.write(colored('Votre like doit être compris entre 0 et 5.\n', 'red'))
+            return False
+
+
+        timeSent = int(time.time())
+
+        data = {}
+        data['version'] = 2
+        data['index'] = "user"
+        data['type'] = "profile"
+        data['id'] = profile
+        data['kind'] = "STAR"
+        data['level'] = likes
+        data['time'] = timeSent
+        data['issuer'] = self.pubkey
+
+        document = json.dumps(data)
+
+        # Generate hash of document
+        hashDoc = sha256(document.encode()).hexdigest().upper()
+
+        # Generate signature of document
+        signature = fmt["64"](sign(hashDoc.encode(), get_privkey(self.dunikey, "pubsec"))[:-len(hashDoc.encode())]).decode()
+
+        # Build final document
+        data = {}
+        data['hash'] = hashDoc
+        data['signature'] = signature
+        signJSON = json.dumps(data)
+        finalJSON = {**json.loads(signJSON), **json.loads(document)}
+        finalDoc = json.dumps(finalJSON)
+
+        return finalDoc
+
+    def sendDocument(self, document, pubkey):
+
+        headers = {
+            'Content-type': 'application/json',
+        }
+
+        # Send JSON document and get JSON result
+        result = requests.post('{0}/user/profile/:id/_like'.format(self.pod), headers=headers, data=document)
+
+        if result.status_code == 200:
+            print(colored("Profile liké avec succès !", 'green'))
+            return result.text
+        elif result.status_code == 400:
+            resultJson = json.loads(result.text)
+            if 'DuplicatedDocumentException' in resultJson['error']:
+                rmLike = UnLikes(self.dunikey, self.pod)
+                idLike = rmLike.checkLike(pubkey)
+                if idLike:
+                    document = rmLike.configDoc(idLike)
+                    rmLike.sendDocument(document, True)
+                sleep(0.5)
+                self.sendDocument(document, pubkey)
+                return resultJson['error']
+            else:
+                sys.stderr.write("Echec de l'envoi du document de lecture des messages...\n" + resultJson['error'] + '\n')
+        else:
+            resultJson = json.loads(result.text)
+            sys.stderr.write("Echec de l'envoi du document de lecture des messages...\n" + resultJson['error'] + '\n')
+
+
+#################### Unlike class ####################
+
+
+class UnLikes(CesiumCommon):
+    # Check if you liked this profile
+    def checkLike(self, pubkey):
+        readProfileLikes = ReadLikes(self.dunikey, self.pod)
+        document = readProfileLikes.configDoc(pubkey)
+        result = readProfileLikes.sendDocument(document)
+        result = readProfileLikes.parseResult(result)
+        result = json.loads(result)
+
+        if 'yours' in result:
+            myLike = result['yours']['id']
+            return myLike
+        else:
+            sys.stderr.write("Vous n'avez pas liké ce profile\n")
+            return False
+
+    # Configure JSON document to send
+    def configDoc(self, idLike):
+        timeSent = int(time.time())
+
+        data = {}
+        data['version'] = 2
+        data['index'] = "like"
+        data['type'] = "record"
+        data['id'] = idLike
+        data['issuer'] = self.pubkey
+        data['time'] = timeSent
+
+        document = json.dumps(data)
+
+        # Generate hash of document
+        hashDoc = sha256(document.encode()).hexdigest().upper()
+
+        # Generate signature of document
+        signature = fmt["64"](sign(hashDoc.encode(), get_privkey(self.dunikey, "pubsec"))[:-len(hashDoc.encode())]).decode()
+
+        # Build final document
+        data = {}
+        data['hash'] = hashDoc
+        data['signature'] = signature
+        signJSON = json.dumps(data)
+        finalJSON = {**json.loads(signJSON), **json.loads(document)}
+        finalDoc = json.dumps(finalJSON)
+
+        return finalDoc
+
+    def sendDocument(self, document, silent):
+
+        headers = {
+            'Content-type': 'application/json',
+        }
+
+        # Send JSON document and get JSON result
+        result = requests.post('{0}/history/delete'.format(self.pod), headers=headers, data=document)
+
+        if result.status_code == 200:
+            if not silent:
+                print(colored("Like supprimé avec succès !", 'green'))
+            return result.text
+        else:
+            sys.stderr.write("Echec de l'envoi du document de lecture des messages...\n" + result.text + '\n')

paiements.py

@@ -0,0 +1,94 @@
+#!/usr/bin/env python3
+
+"""
+ZetCode Tkinter tutorial
+
+In this example, we use the pack
+manager to create a review example.
+
+Author: Jan Bodnar
+Website: www.zetcode.com
+"""
+
+import PySimpleGUI as sg
+from lib.gva import GvaApi
+import sys, os, threading
+from shutil import copyfile
+from os.path import join, dirname
+from dotenv import load_dotenv
+from lib.natools import get_privkey
+import requests
+
+class StdoutRedirector(object):
+    def __init__(self, text_widget):
+        self.text_widget = text_widget
+ 
+    def write(self, s):
+        self.text_widget.insert('end', s)
+        self.text_widget.see('end')
+
+    def flush(self):
+        pass
+
+
+MY_PATH = os.path.realpath(os.path.dirname(sys.argv[0])) + '/'
+
+# Get variables environment
+if not os.path.isfile(MY_PATH + '.env'):
+    copyfile(MY_PATH + ".env.template",MY_PATH +  ".env")
+dotenv_path = join(dirname(__file__),MY_PATH +  '.env')
+load_dotenv(dotenv_path)
+
+dunikey = os.getenv('DUNIKEY')
+if not os.path.isfile(dunikey):
+    HOME = os.getenv("HOME")
+    dunikey = HOME + dunikey
+    if not os.path.isfile(dunikey):
+        sys.stderr.write('Le fichier de trousseau {0} est introuvable.\n'.format(dunikey))
+        sys.exit(1)
+node = os.getenv('NODE')
+issuer = get_privkey(dunikey, "pubsec").pubkey
+
+
+def ProceedPaiement(recipient, amount, comment):
+    if not recipient:
+        raise ValueError("Veuillez indiquer un destinataire de paiement")
+    elif not amount:
+        raise ValueError("Veuillez indiquer le montant de la transaction")
+
+    amount = int(float(amount.replace(',','.'))*100)
+    print("Paiement en cours vers", recipient)
+    gva = GvaApi(dunikey, node, recipient)
+    gva.pay(amount, comment, False, False)
+
+    recipient = amount = comment = None
+
+
+sg.theme('DarkGrey2')
+layout = [  [sg.Text('Noeud utilisé: ' + node)],
+            [sg.Text('Votre clé publique: ' + issuer)],
+            [sg.Text('')],
+            [sg.Text('Destinataire:  '), sg.InputText(size=(55, None),default_text=issuer)],
+            [sg.Text('Montant:        '), sg.InputText(size=(7, None)), sg.Text('Ḡ1')],
+            [sg.Text('Commentaire:'), sg.InputText(size=(55, None))],
+            [sg.Button('Envoyer')] ]
+
+# Create the Window
+window = sg.Window('Paiement Ḡ1 - GVA', layout)
+# availablePubkeys = requests.get('https://g1-stats.axiom-team.fr/data/wallets-g1.txt')
+while True:
+    try:
+        event, values = window.read()
+        if event == sg.WIN_CLOSED:
+            break
+        if event == 'Envoyer':
+            ProceedPaiement(values[0], values[1], values[2])
+    except Exception as e:
+        loc = window.CurrentLocation()
+        sg.popup(e, title="ERREUR", button_color=('black','red'), location=(loc))
+    else:
+        loc = window.CurrentLocation()
+        sg.popup(f'Transaction effectué avec succès !', title="Envoyé", location=(loc))
+
+
+window.close()

readmsg.sh

@@ -1,82 +0,0 @@
-#!/bin/bash
-
-# ###
-# Lecture des messages Cesium+
-# ###
-
-[[ -z $(which jq) || -z $(which curl) ]] && echo "Installation de jq et curl ..." && sudo apt update && sudo apt install jq curl -y
-
-[[ ! -f .env ]] && cp .env.template .env
-source .env
-
-# Help display
-helpOpt() {
-    echo -e "Cesium+ messages sender
-    \r$0
-    Default: ask recipient in interactive mode.
-    Advice: Fill your .env file for more fun.
-
-    \rOptions:
-    -k,--key <key>\t\tPath <key> to the pubsec keychain file of the issuer.
-    -n,--number <number>\tDisplay the <number> lasts messages from Cesium (tail-like format)
-    -o,--outbox\t\t\tRead outbox messages instead of inbox
-    -h,--help\t\t\tDisplay this help"
-}
-
-REGEX_PUBKEYS="[a-zA-Z0-9]{42,44}"
-
-recipient=$issuer
-
-# Parse options
-declare -a args=($@)
-for ((i=0; i<${#args[*]}; ++i))
-do
-    case ${args[$i]} in
-        -k|--key) dunikey="${args[$i+1]}"
-            [[ -z $dunikey ]] && echo "Veuillez préciser un fichier de trousseau." && exit 1;;
-        -o|--outbox) type=outbox;;
-        -n|--number) nbrRaw="${args[$i+1]}";;
-        -n*) nbrRaw="${args[$i]:2}";;
-        -h|--help) helpOpt && exit 0;;
-        *) [[ "${args[$i]}" == "-"* ]] && echo "Option inconnue." && exit 1;;
-    esac
-done
-
-
-recipient=$(./natools.py pk -f pubsec -k $dunikey)
-if [[ -z $dunikey ]]; then
-    read -p "Fichier de trousseau: " dunikey
-fi
-[[ -z $type ]] && type="inbox"
-[[ -z $nbrRaw ]] && nbrRaw=5000
-
-[[ -z $(grep -Eo $REGEX_PUBKEYS <<<$recipient) ]] && echo "Le format de la clé publique du destinataire est invalide." && exit 1
-
-document="{\"sort\":{\"time\":\"desc\"},\"from\":0,\"size\":$nbrRaw,\"_source\":[\"issuer\",\"recipient\",\"title\",\"content\",\"time\",\"nonce\",\"read_signature\"],\"query\":{\"bool\":{\"filter\":{\"term\":{\"recipient\":\"$recipient\"}}}}}"
-
-# Envoi du document
-msgContent=$(curl -s -X POST "$pod/message/$type/_search" -d "$document" | jq .hits.hits[]._source -c)
-
-#Traitement des données
-n=0
-for i in $msgContent; do
-    echo -e "=== $n ===\n"
-    dataObj=($(jq -r '.issuer,.recipient,.nonce,.title,.content,.time' <<<"$i"))
-    issuer="${dataObj[0]}"
-    recipient="${dataObj[1]}"
-    nonce=$(echo "${dataObj[2]}" | base58 -d | base64 -w 0)
-    title="${dataObj[3]}"
-    content="${dataObj[4]}"
-    time="${dataObj[5]}"
-
-    titleClear=$(./natools.py box-decrypt -p $issuer -f pubsec -k $dunikey -n $nonce -I 64 <<< "${title}")
-    contentClear=$(./natools.py box-decrypt -p $issuer -f pubsec -k $dunikey -n $nonce -I 64 <<< "${content}")
-    echo "$titleClear"
-    echo "$contentClear"
-    echo "========="
-    ((n++))
-#    echo "./natools.py box-decrypt -p $issuer -f pubsec -k $dunikey -n $nonce -I 64 <<< \"${title}\""
-done
-
-#echo "$msgContent" | jq
-

requirements.txt

@@ -0,0 +1,9 @@
+wheel
+base58
+pybase64
+duniterpy==0.62.0
+termcolor
+python-dotenv
+gql==3.0.0a5
+#gql==2.0
+requests

sendmsg.sh

@@ -1,101 +0,0 @@
-#!/bin/bash
-
-# ###
-# Simple testeur d'envoi de message via la messagerie de Cesium ou de Gchange.
-# ###
-
-[[ -z $(which jq) || -z $(which curl) ]] && echo "Installation de jq et curl ..." && sudo apt update && sudo apt install jq curl -y
-
-[[ ! -f .env ]] && cp .env.template .env
-source .env
-
-# Help display
-helpOpt() {
-    echo -e "Cesium+ messages sender
-    Default: ask title, content and recipient in interactive mode.
-    Advice: Fill your .env file for more fun.
-    Example: $0 -f <Path of file content message> -r <recipient pubkey> -k <path of pubsec keychain of issuer>
-
-    \rOptions:
-    -t\t\t\t\tTest mode: Uses the \"test.txt\" file as well as the same recipient as the sender.
-    -f,--file <file>\t\tRead the file <file> with title in first line and content in rest of the file for the message.
-    -r,--recipient <pubkey>\tUses <pubkey> as recipient of the message.
-    -k,--key <key>\t\tPath <key> to the pubsec keychain file of the issuer.
-    -h,--help\t\t\tDisplay this help"
-}
-
-REGEX_PUBKEYS="[a-zA-Z0-9]{42,44}"
-
-# Parse options
-declare -a args=($@)
-for ((i=0; i<${#args[*]}; ++i))
-do
-    case ${args[$i]} in
-        -f|--file) file="${args[$i+1]}"
-            [[ ! -f $file ]] && echo "Le fichier $file n'existe pas." && exit 1;;
-        -t|--test) file="test.txt"
-            issuer=$(./natools.py pk -f pubsec -k $dunikey)
-            recipient=$issuer;;
-        -r|--recipient) recipient="${args[$i+1]}"
-            [[ -z $recipient ]] && echo "Veuillez préciser un destinataire." && exit 1;;
-        -k|--key) dunikey="${args[$i+1]}"
-            [[ -z $dunikey ]] && echo "Veuillez préciser un fichier de trousseau." && exit 1;;
-        -h|--help) helpOpt && exit 0;;
-        *) [[ "${args[$i]}" == "-"* ]] && echo "Option inconnue." && exit 1;;
-    esac
-done
-
-if [[ -z $dunikey ]]; then
-    read -p "Fichier de trousseau: " dunikey
-fi
-issuer=$(./natools.py pk -f pubsec -k $dunikey)
-
-if [[ -z $file ]]; then
-    read -p "Objet du message: " title
-    read -p "Corps du message: " content
-    message="$title"$'\n'"$content"
-else
-    message=$(cat $file)
-fi
-if [[ -z $recipient ]]; then
-    read -p "Destinataire: " recipient
-fi
-
-[[ -z $(grep -Eo $REGEX_PUBKEYS <<<$recipient) ]] && echo "Le format de la clé publique du destinataire est invalide." && exit 1
-[[ -z $(grep -Eo $REGEX_PUBKEYS <<<$issuer) ]] && echo "Le format de la clé publique de l'émetteur est invalide." && exit 1
-
-# Récupération et chiffrement du titre et du message
-nonce=$(cat /dev/urandom | tr -dc 'a-zA-Z0-9' | fold -w 32 | head -n 1)
-b58nonce=$(echo $nonce | base64 -d | base58)
-title=$(head -n1 <<<$message | ./natools.py box-encrypt -n $nonce -f pubsec -k $dunikey -p $recipient -O 64)
-content=$(tail -n+2 <<<$message | ./natools.py box-encrypt -n $nonce -f pubsec -k $dunikey -p $recipient -O 64)
-
-times=$(date -u +'%s')
-
-# Fabrication du hash
-hashBrut="{\"issuer\":\"$issuer\",\"recipient\":\"$recipient\",\"title\":\"$title\",\"content\":\"$content\",\"time\":$times,\"nonce\":\"$b58nonce\",\"version\":2}"
-hash=$(echo -n "$hashBrut" | sha256sum | cut -d ' ' -f1 | awk '{ print toupper($0) }')
-
-# Fabrication de la signature
-signature=$(echo -n "$hash" | ./natools.py sign -f pubsec -k $dunikey --noinc -O 64)
-
-# Affichage du JSON final
-document="{\"hash\":\"$hash\",\"signature\":\"$signature\",${hashBrut:1}"
-jq . <<<$document
-
-# Envoi du document
-#curl -s -i -X OPTIONS "$pod/message/inbox?pubkey=$issuer" -d "pubkey=$issuer"
-msgID=$(curl -s -X POST "$pod/message/inbox?pubkey=$recipient" -d "$document")
-echo -e "\nMessage ID: $msgID"
-
-
-### Tests mode ###
-
-# Delete the message 1 second later, just for test
-#sleep 1 && ./deletemsg.sh -id $msgID
-
-# To put the message in outbox too
-#curl -s -X POST "$pod/message/outbox?pubkey=$issuer" -d "$document"
-
-# To put the message as read, add this at the end of document
-#,\"read_signature\":\"$signature\"

setup.sh

@@ -0,0 +1,12 @@
+#!/bin/bash
+
+for i in gcc python3-pip python3-setuptools libpq-dev python3-dev python3-wheel; do
+	if [ $(dpkg-query -W -f='${Status}' $i 2>/dev/null | grep -c "ok installed") -eq 0 ]; then
+		[[ ! $j ]] && sudo apt update
+		sudo apt install -y $i
+		j=1
+	fi
+done
+
+pip3 install -r requirements.txt
+chmod u+x jaklis.py

test.txt

@@ -1,9 +0,0 @@
-Hello bot !
-Bonjour,
-
-Ceci est un message de test d'envoi de message via la messagerie de Cesium+.
-
-Veuillez nous envoyer 100001Ḡ1 pour ne pas perdre toutes vos données personnelles dans les prochaines 48h.
-
-Cordilament,
-le Ḡstaff