MERCI;
Ça fonctionne! Je vais maintenant essayer d’utiliser duniterpy directement.
Voici les commandes que je cherche à effectuer:
./silkaj/silkaj generate_auth_file -salt="$PHONE" -password="$PIN" => Initialise un wallet
./silkaj/silkaj amount "$RIB" => Montant du compte
./silkaj transaction --auth-scrypt -salt="$PHONE" -password="$PIN" --amount="$VIR" --output="$DESTRIB" => KO ou Montant restant
./silkaj/silkaj id "$MEMBERUID" => Clef Publique Membre
Je vais fouiller dans les exemples… Enfin, si veux m’aiguiller, je suis preneur.
Ils ne savaient pas que c’était impossible, alors ils l’ont fait
Le script correspondant à ta première commande. Il contient les bases d’un code python 3.5 propre avec typage pour gérer les arguments passés en ligne de commande. Il est inspiré de l’exemple présent dans le dépôt Duniterpy, mais remplace l’interactivité avec l’utilisateur par des arguments.
Note l’importance que je donne aux commentaires et aux docstrings afin que le code soit immédiatement compréhensible par un dev python et aussi pour l’IDE qui affiche la doc des fonctions à partir des docstrings.
[EDIT] Créer un fichier gen_pubkey.py contenant le code suivant :
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)
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)
A prioris , je peux aussi accéder aux profils cesium+ par duniterpy?
Je me posais la question des requêtes sur elasticsearch, est-il possible d’écrire un profil cesium+?
Comme ajouter un nom, une image associé au compte porte monnaie SMS créé…
Je voudrais faire une double authentification quand on déclare par SMS son pseudo de membre possesseur du porte-monnaie. Je pourrai envoyer code par email (saisi dans Cesium pour les notifications).
Mais là si j’ai bien compris, il faut une autorisation spéciale (la clef de l’opérateur de notification SMS) @kimamila?
Maintenant que je me sens plus à l’aise avec python (quoi que), j’essaye de mettre au point G1sms+
Avec des framboises, un chapeau GSM, du script shell, du python et un essaim IPFS (ou Textile) pour dialoguer en toute égalité d’accès spatio-temporelle avec les données partagées…
Après un casse tête sur l’accès au port série (que Raspbian s’allouait pour y coller une console), la V1 de G1sms tourne (en double). Voila le moment de la pimper un peu !!
Et @vit, quand j’essaye de lancer le gen_pubkey.py que tu m’as mis plus haut, voila que le gros serpent se rebiffe:
python3 gen_pubkey.py MAMA MIA
Traceback (most recent call last):
File "gen_pubkey.py", line 37, in <module>
print(generate_public_key(_salt, _password))
File "gen_pubkey.py", line 13, in generate_public_key
key = SigningKey(salt, password)
TypeError: __init__() takes 2 positional arguments but 3 were given
Il me reste à comprendre pourquoi ce que me retourne ce script n’est pas compatible json
import asyncio
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)
# prompt entry
# pubkey = input("\nEnter a public key to get the user profile: ")
pubkey = "DsEx1pS33vzYZg4MroyBV9hCw98j1gtHEhwiZ5tK7ech"
# Get the profil of a public key (direct REST GET request)
# print("\nGET user/profile/{0}/_source:".format(pubkey))
response = await client.get('user/profile/{0}/_source'.format(pubkey.strip(' \n')))
print(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())
Je voudrai récupérer l’image (pour mettre sur les billets) et les coordonnées du membre pour une double authentification
Si l’image est contenue dans le json elle est sûrement en format url, ce qui doit être de la base 64 je pense. Donc il faut la convertir en binaire d’abord.
Pas tant que ça, là tu avais un problème parce que Duniterpy a évolué en brisant la compatibilité avec les versions antérieures. Forcément tu ne peux pas le deviner à moins de fouiller le code…
Je t’invite vraiment à utiliser un IDE comme PyCharm (version community) qui t’apportera l’auto-completion automatique et t’aurais proposé la solution !
Grand merci à @tuxmain qui maîtrise python ET Duniterpy !
Concernant les accès BMA, quels sont les serveurs à qui m’adresser pour la Ḡ1? J’ai mis: BMAS_ENDPOINT = "BMAS g1.duniter.org 443" TRANSACTION_VERSION = 10 est-il d’accualité?
Alors je n’ai pas lu le code python en question, mais je peut au moins te dire que les documents transaction n’ont pas d’attribut montant : une transaction ne correspond qu’a la destructions de sources en inputs et la création de nouvelles sources en output.
Pour que la transaction soit valide, il faut entre autre que la somme des montants des inputs soit strictement égale a la somme des montants en output.
Concernant le “montant” envoyé au destinataire de la transaction il s’agit du montant de l’output qui sera attribué au destinataire. (Il peut y avoir un 2ème output de “reste” que l’émetteur se renvoi a lui-même si les sources consommés en input atteignent un montant supérieur a celui qu’il souhaite envoyer).
Sur dup-tools-front tu a un exemple de chaque document, le document transaction d’exemple montre l’envoi de 20,04 G1
