STI/Astroport.ONE
STI
/
Astroport.ONE
4
1
Fork 2
Code Issues 11 Pull Requests Projects Releases 1 Wiki Activity

GITBOOK-1: No subject

This commit is contained in:
support 2024-06-08 13:02:42 +00:00 committed by gitbook-bot
parent 2d56e9f4f9
commit 5542cb15b5
No known key found for this signature in database
GPG Key ID: 07D2180C7B12D0FF
13 changed files with 863 additions and 519 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

566
README.md
View File

@ -1,551 +1,79 @@
# Introduction
# Intro
[Astroport DEV Journal](https://pad.p2p.legal/s/AstroportDEVJournal#)
Les scripts fournis sont interconnectés et font partie d'un écosystème appelé Astroport.ONE, qui utilise IPFS (InterPlanetary File System) et la blockchain Ğ1 pour diverses opérations. 
**Embark on a Cosmic Journey with AstroID & ZenCard System and Astroport.ONE**
Voici une description des relations entre les scripts :
Are you weary of the constraints of traditional payment systems and concerned about the reliability
of your distributed storage solutions? Look no further! Our revolutionary ZenCard QRCode based Payment System
and Astroport.ONE v1.0 seamlessly blend cutting-edge blockchain technology with interplanetary storage,
offering you a commission-free and secure solution.
#### 1. `20h12.process.sh`
**Astroport.ONE v1.0: Decentralized Storage Beyond Borders**
Ce script est exécuté quotidiennement à 20h12 et orchestre plusieurs tâches importantes :
Astroport.ONE isn't just a distributed storage software; it's a reimagining of data management.
Utilizing IPFS and introducing a master boot record (MBR) and allocation table to Tiddlywiki data,
Astroport.ONE organizes information with unprecedented precision. In the UPlanet format system,
the planet is sliced into 0.01° segments, ensuring locally registered Tiddlers with unique signatures.
* **Vérification et redémarrage du démon IPFS** : Assure que le démon IPFS est actif et redémarre si nécessaire.
* **Nettoyage des répertoires temporaires** : Nettoie les répertoires temporaires tout en conservant certains dossiers importants.
* **Mise à jour du code source** : Met à jour le code source d'Astroport.ONE et de G1BILLET via Git.
* **Exécution des scripts de mise à jour** : Exécute des scripts pour mettre à jour les joueurs, les nœuds, et les zones géographiques.
* **Surveillance des transactions** : Utilise `G1PalPay.sh` pour surveiller les transactions sur la blockchain Ğ1.
* **Notifications par email** : Utilise `mailjet.sh` pour envoyer des notifications par email en cas d'erreurs ou d'événements importants.
As a network engineer and system administrator committed to the Common Good, join us in constructing
Astroport.ONE and shaping the future of secure and reliable distributed storage.
#### 2. `PLAYER.refresh.sh`
**Station Extra-Terrestre Astroport.ONE: Where Innovation Meets Tranquility**
Ce script gère les joueurs et leurs données :
In the midst of this technological revolution, discover the Station Extra-Terrestre Astroport.ONE.
A haven for volunteers striving to live in peace and harmony within a spaceship turned garden,
it unveils a new "Jeu de Société" developed by and for the Astronauts of MadeInZion.
* **Mise à jour des données des joueurs** : Rafraîchit les données des joueurs, y compris les portefeuilles et les tiddlers (petits morceaux de contenu).
* **Gestion des clés IPFS** : Vérifie et importe les clés IPFS des joueurs.
* **Surveillance des transactions** : Utilise `G1PalPay.sh` pour surveiller les transactions et exécuter des commandes basées sur les commentaires des transactions.
Embark on an exploration of "Voeux," wishes funded collaboratively through donations in the Libre currency G1.
These wishes encapsulate ideas, plans, explanations, and even mistakes, marking the journey toward their realization.
#### 3. `NODE.refresh.sh`
In this digital game manifesting in real life, your digital identity is in your hands, and a new Internet unfolds,
built according to our "Toiles de confiance" (Webs of Trust)!
Ce script gère les nœuds IPFS :
Join us in this cosmic journey where peace, harmony, and the spirit of exploration reign supreme.
Send your love to the Extraordinary Earthlings at https://qo-op.com.
* **Mise à jour des données des nœuds** : Rafraîchit les données des nœuds et publie des balises de station.
* **Nettoyage des répertoires temporaires** : Nettoie les répertoires temporaires des nœuds.
Welcome to a universe where wishes become reality, and the possibilities are boundless.
#### 4. `VOEUX.refresh.sh`
[BASH ENGINE FOR A CRYPTO PLAYGROUND](https://pad.p2p.legal/p/G1Fablab#)
Ce script gère les vœux des joueurs :
## https://astroport.com
* **Extraction des vœux** : Extrait les vœux des joueurs à partir de leurs tiddlers.
* **Mise à jour des vœux** : Rafraîchit les vœux et exécute des programmes spécifiques basés sur les vœux.
With this technology, we each become host and access provider and media sovereign.
#### 5. `REGION.refresh.sh`
**Astroport ONE propels a digital world of interconnected trust webs**.
Ce script gère les régions géographiques :
# Astroport.ONE
Each "Astroport.ONE" station is a digital embassy that communicates and synchronizes with its peers.
Users can "move their account". The last one used during the day becomes the "official station".
* **Mise à jour des régions** : Rafraîchit les données des régions en collectant des informations à partir des secteurs.
* **Publication des données** : Publie les données des régions sur IPFS.
The architecture attached to each public key is deployed in the form of "flower petals" according to the circles of trust Ŋ1 and Ŋ2 and the data flows produced by the derived keys.
#### 6. `ZEN.UMAP.memory.sh`
![N.ONE.2](https://www.copylaradio.com/web/image/6038/ASTROPORT_multiWoTNet.png)
Ce script gère la mémoire des cartes UMAP :
ASTROBOT "Intelligent contract in BASH"
Programs are triggered by "G1Tag" (derived keys) ensures extraction of "G1WordClefs" from "surrounding" Tiddlers.
* **Récupération des données** : Récupère les données de mémoire des secteurs à partir de l'historique des transactions.
To trigger the execution of a "personal intelligent contract", simply create a "wish" (Tag=voeu)
At this point, if it exists "ASTROBOT/G1Tag.sh" program will publish the data relating to the Tag concerned on a new "personal IPNS derived key", if not a default "json from all with same wish" is created (see RUNTIME/VOEUX.refresh.sh)
#### 7. `G1PalPay.sh`
# INSTALLATION (Linux Mint / Ubuntu / DEBIAN)
Ce script surveille les transactions sur la blockchain Ğ1 :
Tested on "Linux Mint" (Debian like distro compatible), the **hacker way for using & buidling new blockchain services** ...
* **Surveillance des paiements entrants** : Vérifie les paiements entrants et exécute des commandes basées sur les commentaires des transactions.
* **Redistribution des fonds** : Redistribue les fonds aux destinataires spécifiés dans les commentaires des transactions.
INSTALL COMMAND
#### 8. `DRAGON_p2p_ssh.sh`
```
bash <(wget -qO- https://raw.githubusercontent.com/papiche/Astroport.ONE/master/install.sh)
Ce script gère les connexions SSH sur IPFS :
```
* **Ouverture et fermeture des connexions SSH** : Ouvre et ferme les connexions SSH sur IPFS pour le support et la maintenance.
> TODO: MORE MODULAR INSTALL.
> CREATE adventure explaining it
#### 9. `G1Voeu.sh`
## DRAGONS WOT
Ce script crée des vœux pour les joueurs :
Once you install Astroport.ONE...
* **Création de tiddlers de vœux** : Crée des tiddlers de vœux pour les joueurs et les publie sur IPFS.
If all has gone well, you should find these processes running...
#### Relations entre les scripts
```
/usr/local/bin/ipfs daemon --enable-pubsub-experiment --enable-namesys-pubsub
/bin/bash /home/fred/.zen/G1BILLET/G1BILLETS.sh daemon
\_ /bin/bash /home/fred/.zen/G1BILLET/G1BILLETS.sh daemon
\_ nc -l -p 33101 -q 1
/bin/bash /home/fred/.zen/Astroport.ONE/12345.sh
\_ /bin/bash /home/fred/.zen/Astroport.ONE/12345.sh
\_ nc -l -p 1234 -q 1
/bin/bash /home/fred/.zen/Astroport.ONE/_12345.sh
\_ nc -l -p 12345 -q 1
* **Coordination** : `20h12.process.sh` coordonne l'exécution de plusieurs autres scripts (`PLAYER.refresh.sh`, `NODE.refresh.sh`, `VOEUX.refresh.sh`, etc.) pour assurer la mise à jour et la maintenance de l'écosystème.
* **Dépendances** : Les scripts comme `PLAYER.refresh.sh` et `VOEUX.refresh.sh` dépendent de `G1PalPay.sh` pour surveiller les transactions et exécuter des commandes basées sur les paiements.
* **Publication et mise à jour** : Les scripts `NODE.refresh.sh` et `REGION.refresh.sh` publient et mettent à jour les données sur IPFS, assurant que les informations sont synchronisées et accessibles.
* **Gestion des clés et des connexions** : `DRAGON_p2p_ssh.sh` et `G1Voeu.sh` gèrent les clés IPFS et les connexions SSH, assurant la sécurité et la connectivité de l'écosystème.
```
> Become Official REGIONAL Station
> - follow "PGP/SSH/IPFSNODEID" linking procedure -
> https://pad.p2p.legal/keygen
# DESKTOP
After installation, you should have 3 new shortcuts on your desktop
* Astroport", which opens your station portal: http://astroport.localhost:1234
* REC" allows you to save your files on IPFS and publish their Capusle in your TW.
* G1BILLET" lets you create ZenCards and other useful QRCodes
NB : If you use "Nemo" as file manager. You can "ipfs add" any file (with no space in file name) by right click it.
> TODO : detect OS and FILE MANAGER to adapt desktop linking and right clic action
## How to manage your "Astroport"!
You need to create a "PLAYER".
It is defined by email, salt, pepper, lat, lon and PASS
```
~/.zen/Astroport.ONE/command.sh
```
Browse available functions
A Station can host multiple "PLAYERs and TiddlyWikis".
---
# "BASH API" : "♥BOX"
## http://astroport.localhost:1234
Once your Astroport Station is started:
* port 1234 publishes API (REPONSE PORT TCP 45780 45781 ( up to ... 45790 )
* port 12345 publishes MAP(*) (ESSAIM MAP - BOOSTRAP / STATIONS)
* port 33101 publishes G1BILLETS (REPLY TCP PORT 33102)
* port 8080, 4001 and 5001 are IPFS gateway ports.
List of ports to activate.
![](https://ipfs.asycn.io/ipfs/QmWzwL9fZKDGuqsvDjkA8v9sAcU4zQ4BvjKDRwnZQBT97y)
To add your Station to our swarm, enter the IP of your BOX in the file ``~/.zen/♥Box ````.
exemple
```
frd@scorpio:~ $ cat ~/.zen/♥Box
86.210.184.173
```
⚠ API ASTROPORT = NETCAT SYSTEM ⚠
**Astroport doesn't need a web server to work**. We use the simplest network tool, **netcat**.
Operation gives access to an "API BASH" (classified by the same name as the first GET parameter received in the API directory).
Requests are made in HTTP GET on port 1234, with the response PORT in the loaded page.
Perform a regexp on "url=ADRESSE:PORT" or (♥‿‿♥) to find out which.
Here are some examples of how to do it.
## ANSWER PORT RECOVERY API : (♥‿‿♥)
### CLI (BASH)
```
# OPEN ASTROPORT HOME PAGE
curl -so ~/.zen/tmp/${MOATS}/astro.port "http://astroport.localhost:1234/?salt=0&pepper=0&g1pub=_URL_&email=${EMAIL}"
# GREP NEXT PORT IN PAGE CODE
TELETUBE=$(cat ~/.zen/tmp/${MOATS}/astro.port | grep "(♥‿‿♥)" | cut -d ':' -f 2 | cut -d '/' -f 3)
TELEPORT=$(cat ~/.zen/tmp/${MOATS}/astro.port | grep "(♥‿‿♥)" | cut -d ':' -f 3 | cut -d '"' -f 1)
sleep 30
# ACCESS TO FINAL RESULT
curl -so ~/.zen/tmp/${MOATS}/astro.rep "http://$TELETUBE:$TELEPORT"
```
### JS
Exemple :
```
var myURL = 'http://astroport.localhost:1234/?' + query;
async function fetchAstroport(myURL) {
try {
let one = await fetch(myURL); // Gets a promise
var doc = await one.text();
var regex = /url='([^']+)/i; // Get response PORT
var redirectURL = doc.match(regex)[1]
console.log(redirectURL)
setTimeout(function() {
// let two = await fetch(redirectURL);
// document.mydiv.innerHTML = await two.text(); // Replaces body with response
window.open( redirectURL, "AstroTab");
}, 5000);
} catch (err) {
console.log('Fetch error:' + err); // Error handling
}
}
```
USE "[astro.js](templates/ZenStation/G1PalPay_fichiers/astro.js)"
```
<script src="https://ipfs.asycn.io/ipfs/Qmae5v9zydax9u6C9ceDijURu5PYdd5avmv4NkenCw7RFv/astro.js"></script>
```
## ➤ SALT API
### ```/?salt=${SALT}&pepper=${PEPPER}&${APPNAME}=${WHAT}&${OBJ}=${VAL}...```
### Créer (ou téléporter) un PLAYER TW : OFFICIAL <3BOX :
```http
GET /?salt=${SALT}&pepper=${PEPPER}&g1pub=${URLENCODEDURL}&email=${PLAYER}
```
| Parameter | Type | Description |
| :-------- | :------- | :-------------------------------- |
| `salt` | `string` | **Required**. Your passphrase one token |
| `pepper` | `string` | **Required**. Your passphrase two token |
| `g1pub` | `string` | **Required**. Your prefered _URL_ to copy video from |
| `email` | `email` | **Required**. Your email token |
### LOGOUT PLAYER (remove IPNS keys from Station)
```http
GET /?salt=${SALT}&pepper=${PEPPER}&logout=${PLAYER}
```
| Parameter | Type | Description |
| :-------- | :------- | :-------------------------------- |
| `salt` | `string` | **Required**. Your passphrase one token |
| `pepper` | `string` | **Required**. Your passphrase two token |
| `logout` | `string` | **Required**. Your email token |
### LOGIN PLAYER (Activate IPNS keys on Station)
```http
GET /?salt=${SALT}&pepper=${PEPPER}&login=${PLAYER}
```
| Parameter | Type | Description |
| :-------- | :------- | :-------------------------------- |
| `salt` | `string` | **Required**. Your passphrase one token |
| `pepper` | `string` | **Required**. Your passphrase two token |
| `login` | `string` | **Required**. Your email token |
### Définir le niveau ★ accordé à un "g1friend"
```http
GET /?salt=${SALT}&pepper=${PEPPER}&friend=${G1PUB}&stars=${1:5}
```
| Parameter | Type | Description |
| :-------- | :------- | :-------------------------------- |
| `salt` | `string` | **Required**. Your passphrase one token |
| `pepper` | `string` | **Required**. Your passphrase two token |
| `friend` | `string` | **Required**. G1PUB token of friend |
| `stars` | `number` | **Required**. Number between 1 to 5 |
### Lire Messagerie de la base "GChange"
```http
GET /?salt=${SALT}&pepper=${PEPPER}&messaging=on
```
| Parameter | Type | Description |
| :-------- | :------- | :-------------------------------- |
| `salt` | `string` | **Required**. Your passphrase one token |
| `pepper` | `string` | **Required**. Your passphrase two token |
| `messaging` | `string` | **Required**. (on=json) output type |
### Conversion vers adresse IPNS
```http
GET /?salt=${SALT}&pepper=${PEPPER}&getipns=on
```
| Parameter | Type | Description |
| :-------- | :------- | :-------------------------------- |
| `salt` | `string` | **Required**. Your passphrase one token |
| `pepper` | `string` | **Required**. Your passphrase two token |
| `getipns` | `string` | **Required** on |
### AppName=testcraft : Enregistrer JSON
```http
GET /?salt=${SALT}&pepper=${PEPPER}&testcraft=json&nodeid=_&dataid=$QRHASH
```
| Parameter | Type | Description |
| :-------- | :------- | :-------------------------------- |
| `salt` | `string` | **Required**. Your passphrase one token |
| `pepper` | `string` | **Required**. Your passphrase two token |
| `testcraft` | `string` | **Required** AppNAME subcommand |
| `${OBJ}` | `${VAL}` | depends on App |
This IPFS object transfer needs that the client is using well configured WebRTC/IPFS relays
Look for example in ```www/upload_to_astroport.html```
```
'/dns4/wrtc-star1.par.dwebops.pub/tcp/443/wss/p2p-webrtc-star',
'/dns4/wrtc-star2.sjc.dwebops.pub/tcp/443/wss/p2p-webrtc-star'
```
### Redirections
* vers Gchange
```/?salt=${SALT}&pepper=${PEPPER}&g1pub=on```
* vers TW
```/?salt=${SALT}&pepper=${PEPPER}&g1pub=astro```
### Déclencher un Payement de Ğ1 à une G1PUB
```http
GET /?salt=${SALT}&pepper=${PEPPER}&pay=1&g1pub=DsEx1pS33vzYZg4MroyBV9hCw98j1gtHEhwiZ5tK7ech
```
| Parameter | Type | Description |
| :-------- | :------- | :-------------------------------- |
| `salt` | `string` | **Required**. Your passphrase one token |
| `pepper` | `string` | **Required**. Your passphrase two token |
| `pay` | `integer` | **Required** G1 AMOUNT |
| `g1pub` | `G1PUB` | **Required** destination "wallet key" |
## ➤ PLAYER (works only on LAN Station)
### ```/?player=${PLAYER}&${APPNAME}=${WHAT}&${OBJ}=${VAL}...```
### Exporter Tiddlers.json depuis son TW selon valeur des "tags" ( ici TAG=G1CopierYoutube)
```http
GET /?player=${PLAYER}&moa=json&tag=G1CopierYoutube
```
| Parameter | Type | Description |
| :-------- | :------- | :-------------------------------- |
| `player` | `string` | **Required**. Your EMAIL token |
| `moa` | `string` | **Required** APP = output format |
| `tag` | `${VAL}` | TW filtering default G1CopierYoutube |
> CAN BE EXTENDED
## ➤ AMZQR : Create a QRCode with "amzqr"
```http
GET /?amzqr=${URLENCODEDSTRING}&logo=${IMAGE}
```
| Parameter | Type | Description |
| :-------- | :------- | :-------------------------------- |
| `amzqr` | `string` | **Required** the qrcode string |
| `logo` | `string` | **Required** ./images/${IMAGE}.png |
check available "logo.png" in [./images](./images)
## ➤ UPLANET : Create Umap, AstroID & ZenCard for PLAYER (email)
```http
GET /?uplanet=${PLAYER}&zlat=${LAT}&zlon=${LON}&g1pub=${PASS}
```
| Parameter | Type | Description |
| :-------- | :------- | :-------------------------------- |
| `uplanet` | `email` | **Required** Your EMAIL token |
| `zlat` | `decimal` | **Required** LATITUDE with 2 decimals digits |
| `zlon` | `decimal` | **Required** LONGITUDE with 2 decimals digits |
| `g1pub` | `string` | **Facultative** choose Umap AstroID PASS |
Create à Umap key (LAT/LON), then a PLAYER TW with GPS as Umap IPNS reference
This API is used by OSM2IPFS code.
* [UPlanet Entrance](https://qo-op.com)
### ➤ QRCODE (API SandBox)
```http
GET /?qrcode=${G1PUB} | ${ASTRONAUTENS} | ${PGP_ASTROID_STRING}
```
| Parameter | Type | Description |
| :-------- | :------- | :-------------------------------- |
| `qrcode` | `string` | **Required**. Your G1PUB or ASTRONAUTENS or PGP_ASTROID token |
> Look for details & extend as you like in [~/.zen/Astroport.ONE/API/QRCODE.sh](API/QRCODE.sh)
## The Art of key derivation, chaining & use
In order to make (a little) clear how we use cryptography,
We choose to use "NaCl" (secret1 / secret) 2 key generation, so it is easy to understand Web3 mechanism.
**(SECRET1/SECRET2) mixing**
* If PLAYER key is (SECRET1 / SECRET2) and G1PUB and EMAIL + TW
* feed key (SECRET1 / SECRET2 G1PUB)
* wishes keys are (SECRET2 / WishName EMAIL)
* sub-wishes are (EMAIL / G1WishName G1PUB)
* wish-billets are (EMAIL_dice_words / G1WishName G1PUB)
This way PLAYER TW capable of retrieving and never loose its data.
It is writen into IPFS... So recreate the key anywhere makes you get your data from friends you shared it with.
**Cross (G1PUB) keys**
Between PlayerA (AG1PUB) & PlayerB (BG1PUB) obvious communication channel keys are existing :
(AG1PUB / AG1PUB) - A knock on the door
(AG1PUB / BG1PUB) - From A to B channel
(BG1PUB / AG1PUB) - From B to A channel
(BG1PUB / BG1PUB) - B knock on the door
We can use this to implement protocols, for exemple :
To ollow PlayerA / PlayerB to become friends
A write a KNOCK.AG1PUB file + signature using (BG1PUB / BG1PUB) keygen IPNS key,
Then B reply with the same KNOCK at (AG1PUB / AG1PUB) address
A/B - B/A keys can be used as bidirectionnal encrypted data channels.
In a well formed IPFS swarm, we could even send video... Check code in ```/tools/streaming/```
**(LON / LAT) keys**
NaCl keys can be initiated with GPS Geoloc and receive shared informations.
Using the same A/B swapping method, any A place have also a communication channel with B place ;)
**(COUNTRY / ZIP) keys**
For a town key, we could use country code + ZIP code, ... etc
Many public application can be easily addressed like that
As these keys are discoverable, the channel can be hijacked by anyone.
So ASTROBOT while applying ScuttleButt replications will ".chain.ts" data and check for protocol respect.
Data can't be lost, but protocol chain can be break !
In case of some annoyance, we can monitor IPFS protocol to identify which IPFSNODEID key is acting badly and apply reaction based on DEFCON level (look into astrXbian code)
### MAILJET & GPS
In order for "Boostrap Station" to send emails to PLAYERs, we use [mailjet service](https://mailjet.com/).
```
## CREDENTIALS FILE
~/.zen/MJ_APIKEY
# IS USED BY
~/.zen/Astroport.ONE/tools/mailjet.sh
```
Boostrap location is specified in ~/.zen/GPS
```
cat ~/.zen/GPS
48.87039, 2.31673
```
### LOW RESSOURCE STATION CAN ACTIVATE LOW MODE (disable ipfs daemon)
```
~/.zen/Astroport.ONE/tools/cron_VRFY.sh LOW
sudo systemctl restart astroport.service
sudo systemctl restart g1billet.service
```
### STATION : Show Station PLAYER's G1 investments levels
```http
GET /?qrcode=station
```
### STATION MAP & PLAYER DATA PROPAGATION
Chaque Station collecte et publie sur sa clef "self" (/ipns/$IPFSNODEID) les liens vers le cache de l'ensemble de l'essaim
http://localhost:12345 renvoi un json
```
{
"created" : "202304111854481040",
"hostname" : "kitty.localhost",
"myIP" : "192.168.1.14",
"ipfsnodeid" : "12D3KooWK1ACupF7RD3MNvkBFU9Z6fX11pKRAR99WDzEUiYp5t8j",
"astroport" : "http://192.168.1.14:1234",
"g1station" : "http://ipfs.localhost:8080/ipns/12D3KooWK1ACupF7RD3MNvkBFU9Z6fX11pKRAR99WDzEUiYp5t8j",
"g1swarm" : "http://ipfs.localhost:8080/ipns/k51qzi5uqu5djv0qz9wkl8i94opzm62csh56mnp9zove8i543e4vv4cy9gvr1o"
}
```
| Parameter | Description |
| :-------- | :------- |
| created | date de creation du document |
| hostname | nom de la station |
| myIP | adresse IP de la station |
| ipfsnodeid | Clef publique, balise de la station |
| astroport | Lien vers l'API de la station |
| g1station | Lien vers la carte PLAYER de la Station |
| g1swarm | Lien vers la carte des cartes des Stations de l'essaim |
Afin de propager la carte chaque station lors de son raffraichissement de cache
envoi aux Boostrap une requête pour upload (```/ipns/${IPFSNODEID}```)
```
STATION MAP UPSYNC : http://$nodeip:12345/?${GNODEID}=${IPFSNODEID}
```
# 20H12
Chaque jour, les ASTROBOTs captent les :star: (tiddler 'email') de leurs PLAYERs puis exécutent le protocole de synchronisation Ŋ1
[20H12.sh](/qo-op/Astroport.ONE/src/branch/master/20h12.sh)
Ils analysent les données et extraient des flux json selon les G1Voeu présent dans chaque TW.
Le niveau informationnel de confiance exploré permet de proposer des alertes issues du niveau Ŋ2.
## EXEMPLE DE FLUX TW :
[![TW FEEDS](https://ipfs.copylaradio.com/ipfs/Qma9zvrYHGcUPisLKBcG9U9sktThX5VfVci8jfM8D9RspT)](https://pad.p2p.legal/s/G1TWFeed#)
# IPFS : UN STOCKAGE INALTERABLE ET INTELLIGENT
[![](https://ipfs.asycn.io/ipfs/QmafsWdAeB5W9HcNPQWK2yjTgcW8eTxHoSD7bzE55mtrdP)
### "The Barefoot Architect" de Johan Van Lengen.
Lignes de commandes
```
ipfs ls Qme6a6RscGHTg4e1XsRrpRoNbfA6yojC6XNCBrS8nPSEox/
ipfs cat QmbfVUAyX6hsxTMAZY7MhvUmB3AkfLS7KqWihjGfu327yG > /tmp/vdoc.pub_the-barefoot-architect.pdf && xdg-open /tmp/vdoc.pub_the-barefoot-architect.pdf
```
Après un passage par [ajouter_media.sh](/qo-op/Astroport.ONE/src/branch/master/ajouter_media.sh)
Les données sont stockées [dans des Tiddlers](https://ipfs.copylaradio.com/ipns/k51qzi5uqu5dgobi9ozzzvdftqfd3hd7a1488nzymky1edz8j779jov7sbemc0#Foret_Enchantee-PROJET_ASTROPORT)
### Foret Enchantée - PROJET ASTROPORT.pdf
https://ipfs.copylaradio.com/ipfs/QmUtGpGeMZvwp47ftqebVmoFWCmvroy5wEtWsKvWvDWJpR
---
## SIMULATIONS LOOPY
> [Simulateur Astronaute/Voeux](https://ncase.me/loopy/v1.1/?data=[[[3,646,229,0.5,%22Astronaute%22,5],[4,806,372,0.16,%22G1Voeu%22,3],[5,449,133,0.83,%22G1Talent%22,1],[6,928,124,0.5,%22Astronaute%22,0],[7,1055,293,0.5,%22Astronaute%22,0],[8,883,587,0.5,%22Astronaute%22,0],[10,691,54,0.5,%22G1Voeu%22,3]],[[3,5,82,1,0],[3,4,-87,1,0],[6,4,83,1,0],[4,5,176,1,0],[8,8,85,1,12],[8,4,-45,1,0],[7,4,34,1,0],[5,3,49,1,0],[7,7,101,1,225],[6,6,113,1,-84],[3,3,90,1,75],[5,4,-293,1,0],[3,10,34,1,0]],[],10%5D)
> [Essaim Astroport.ONE](https://ncase.me/loopy/v1.1/?data=[[[1,419,351,1,%22Astroport.ONE%22,3],[2,506,530,1,%22Terrien%22,5],[3,499,95,1,%22IPFS%22,1],[4,272,225,1,%22Astroport.ONE%22,3],[5,620,297,0.16,%22Astroport.ONE%22,4],[7,927,69,0.66,%22Astroport.ONE%22,3],[8,798,175,0.66,%22Astroport.ONE%22,3]],[[2,1,94,-1,0],[1,2,89,1,0],[2,5,-122,1,0],[5,3,58,1,0],[3,5,25,1,0],[4,3,117,1,0],[3,4,-152,1,0],[1,3,60,1,0],[3,1,-18,1,0],[7,3,-44,1,0],[3,7,15,1,0],[8,3,37,1,0],[3,8,-47,1,0]],[[798,557,%22https%253A%252F%252Fipfs.copylaradio.com%253A1234%250A(salt%2520%252F%2520pepper%2520%252F%2520email)%2520%253D%2520TW%2520%252B%2520AstroBot%2520API%22],[256,141,%22Station%2520Officielle%250A(Bootstrap%2520%252B%2520RoundRobin%2520DNS)%22],[868,332,%22D%25C3%25A9l%25C3%25A9gation%2520de%2520clef%250A(Tiers%2520de%2520confiance)%22]],9%5D)
## Stargazers over time
[![Stargazers over time](https://starchart.cc/papiche/Astroport.ONE.svg)](https://starchart.cc/papiche/Astroport.ONE)
## CREDITS
This "digital art" structure is a selection of some of the most valuable Free & OpenSource Software I ever had in my hand.
Credits is going to all the kindness and care provided to make valuable and secure software available for all
Do you know [G1](https://monnaie-libre.fr) ? The best crypto coin you could ever dream about...
Thanks for contributions on [Swarm BUDGET](https://opencollective.com/monnaie-libre#category-BUDGET)
## IPFS Ecosystem Directory Submission Form
https://airtable.com/appLWiIrg9SQaEtEq/shrjwvk9pAeAk0Ci7
ces scripts travaillent ensemble pour maintenir et mettre à jour l'écosystème Astroport.ONE, en utilisant IPFS et la blockchain Ğ1 pour gérer les données, les transactions, et les connexions sécurisées.

14
SUMMARY.md Normal file
View File

@ -0,0 +1,14 @@
# Table of contents
* [Intro](README.md)
* [Astroport 20H12](astroport-20h12/README.md)
* [PLAYER.refresh.sh](astroport-20h12/player.refresh.sh/README.md)
* [$:/moa](astroport-20h12/player.refresh.sh/usd-moa.md)
* [VOEUX.refresh.sh](astroport-20h12/player.refresh.sh/voeux.refresh.sh.md)
* [VOEUX.create.sh](astroport-20h12/voeux.create.sh/README.md)
* [G1Voeu.sh](astroport-20h12/voeux.create.sh/g1voeu.sh.md)
* [UPLANET.refresh.sh](astroport-20h12/uplanet.refresh.sh/README.md)
* [SECTOR.refresh.sh](astroport-20h12/uplanet.refresh.sh/sector.refresh.sh.md)
* [REGION.refresh.sh](astroport-20h12/uplanet.refresh.sh/region.refresh.sh.md)
* [G1PalPay.sh](astroport-20h12/g1palpay.sh.md)
* [tools/Connect\_PLAYER\_To\_Gchange.sh](astroport-20h12/tools-connect\_player\_to\_gchange.sh.md)

39
astroport-20h12/README.md Normal file
View File

@ -0,0 +1,39 @@
# Astroport 20H12
Astroport.ONE est une plateforme décentralisée sophistiquée qui combine IPFS, la blockchain Ğ1, et divers scripts pour gérer les nœuds, les joueurs, et les zones géographiques. Elle offre des fonctionnalités de mise à jour automatique, de surveillance, et de gestion des connexions sécurisées, tout en maintenant une infrastructure décentralisée robuste.
#### Processus Quotidien à 20h12
Le script `20h12.process.sh` est exécuté quotidiennement à 20h12 et effectue les tâches suivantes :
* Vérification et redémarrage du démon IPFS si nécessaire.
* Nettoyage des répertoires temporaires.
* Mise à jour du code source et des outils.
* Exécution des scripts de mise à jour pour les joueurs, les nœuds, et les zones géographiques.
* Gestion des clés SSH et des connexions sécurisées.
* Surveillance des transactions et exécution des commandes associées.
* Envoi de notifications par email et messagerie Cesium+
#### Fonctionnalités Principales
1. **Gestion des Nœuds IPFS** :
* **Vérification et Redémarrage** : Le script vérifie si le démon IPFS est actif et le redémarre si nécessaire. Il s'assure également que le port 5001 est à l'écoute pour les connexions IPFS.
* **Mise à Jour des Nœuds Bootstrap** : Les nœuds bootstrap sont mis à jour pour maintenir la connectivité et la synchronisation du réseau.
2. **Nettoyage et Gestion des Fichiers Temporaires** :
* **Nettoyage des Répertoires Temporaires** : Les répertoires temporaires sont nettoyés tout en conservant certains dossiers importants comme `swarm`, `coucou`, et `flashmem`.
3. **Mise à Jour des Composants** :
* **Mise à Jour du Code Source** : Le script met à jour le code source d'Astroport.ONE et de G1BILLET via Git.
* **Mise à Jour de `yt-dlp`** : Le script met à jour l'outil `yt-dlp` pour le téléchargement de vidéos.
4. **Gestion des Joueurs et des Tâches** :
* **Analyse et Exécution des Tâches des Joueurs** : Le script `PLAYER.refresh.sh` analyse les tâches des joueurs et exécute les scripts associés.
* **Gestion des Vœux** : Les scripts `VOEUX.create.sh` et `VOEUX.refresh.sh` gèrent les vœux des joueurs, créant et actualisant les vœux basés sur des tiddlers (petits morceaux de contenu).
5. **Gestion des Zones Géographiques** :
* **Mise à Jour des Clés Géographiques** : Les scripts `UPLANET.refresh.sh`, `SECTOR.refresh.sh`, et `REGION.refresh.sh` mettent à jour les informations géographiques et les clés associées pour les secteurs et les régions.
6. **Sécurité et Accès** :
* **Gestion des Clés SSH** : Le script `DRAGON_p2p_ssh.sh` gère les clés SSH pour permettre des connexions sécurisées entre les nœuds via IPFS.
7. **Surveillance et Notifications** :
* **Surveillance des Transactions** : Le script `G1PalPay.sh` surveille les transactions sur la blockchain Ğ1 et exécute des commandes basées sur les commentaires des transactions.
* **Notifications par Email** : Le script utilise `mailjet.sh` pour envoyer des notifications par email en cas d'erreurs ou d'événements importants.
#### Conclusion

42
astroport-20h12/g1palpay.sh.md Normal file
View File

@ -0,0 +1,42 @@
# G1PalPay.sh
Le script `G1PalPay.sh` est un outil puissant pour surveiller les transactions sur la blockchain Ğ1 et exécuter des actions basées sur les commentaires des transactions. Il permet d'automatiser des tâches telles que l'exécution de commandes spécifiques, la redistribution de fonds, et l'envoi de notifications, tout en maintenant une synchronisation avec les données de la blockchain et les tiddlers associé
#### Fonctionnalités Principales
1. **Initialisation et Configuration** :
* Le script commence par définir le chemin du script (`MY_PATH`) et le normalise pour obtenir un chemin absolu.
* Il source un fichier de configuration commun (`my.sh`) pour utiliser des fonctions et des variables partagées.
2. **Vérification des Paramètres** :
* Le script vérifie si le fichier TiddlyWiki (TW) et le joueur (`PLAYER`) sont fournis en arguments. Si ce n'est pas le cas, il utilise des valeurs par défaut ou affiche un message d'erreur.
3. **Extraction des Transactions Récentes** :
* Le script utilise `jaklis.py` pour extraire les 30 dernières transactions du portefeuille Ğ1 du joueur et les enregistre dans un fichier JSON :
```bash
~/.zen/Astroport.ONE/tools/timeout.sh -t 12 \
${MY_PATH}/../tools/jaklis/jaklis.py -k ~/.zen/game/players/${PLAYER}/secret.dunikey history -n 30 -j \
> $HOME/.zen/game/players/${PLAYER}/G1PalPay/${PLAYER}.duniter.history.json
```
4. **Traitement des Transactions** :
* Le script parcourt les transactions extraites et vérifie les commentaires pour détecter des commandes spécifiques (N1) ou des adresses email.
* Pour chaque transaction, il extrait les informations pertinentes telles que la date, la clé publique de l'émetteur, le montant, et le commentaire.
5. **Exécution des Commandes N1** :
* Si le commentaire d'une transaction commence par `N1`, le script exécute le programme correspondant dans le répertoire `ASTROBOT` :
```bash
if [[ -s ${MY_PATH}/../ASTROBOT/${CMD}.sh ]]; then
${MY_PATH}/../ASTROBOT/${CMD}.sh ${INDEX} ${PLAYER} ${MOATS} ${TXIPUBKEY} ${TH} ${TRAIL} ${TXIAMOUNT}
fi
```
6. **Traitement des Adresses Email** :
* Si le commentaire contient des adresses email, le script divise le montant de la transaction par le nombre d'adresses et envoie une partie à chaque adresse.
* Il utilise `PAY4SURE.sh` pour effectuer les paiements :
```bash
${MY_PATH}/../tools/PAY4SURE.sh "${HOME}/.zen/game/players/${PLAYER}/secret.dunikey" "${SHARE}" "${ASTROG1}" "UPLANET:PALPAY"
```
7. **Gestion des Tiddlers** :
* Le script extrait les tiddlers modifiés au cours des dernières 24 heures et vérifie s'ils contiennent des adresses email dans les tags.
* Il traite ces tiddlers pour envoyer des notifications ou effectuer des paiements en fonction des adresses email trouvées.
####

37
astroport-20h12/player.refresh.sh/README.md Normal file
View File

@ -0,0 +1,37 @@
---
description: >-
Le script PLAYER.refresh.sh est conçu pour actualiser les données des joueurs
dans l'écosystème Astroport.ONE.
---
# PLAYER.refresh.sh
Le script `PLAYER.refresh.sh` est essentiel pour maintenir la synchronisation et l'actualisation des données des joueurs sur la plateforme Astroport.ONE.&#x20;
Il gère les clés IPFS/IPNS, vérifie et met à jour les tiddlers, surveille les transactions, et assure la publication et la sauvegarde des données. Ce script permet de garantir que les joueurs disposent toujours des informations les plus récentes et que leurs interactions sur la plateforme sont fluides et sécurisées.
#### Fonctionnalités Principales
1. **Initialisation et Préparation** :
* Le script commence par définir le chemin du script et charger des fonctions utilitaires depuis `my.sh`.
* Il identifie les joueurs locaux en lisant les fichiers dans le répertoire `~/.zen/game/players/`.
2. **Vérification et Nettoyage des Comptes** :
* Pour chaque joueur, le script vérifie l'existence de la clé secrète `secret.dunikey`. Si elle est absente, le compte du joueur est supprimé.
3. **Mise à Jour des Données du Joueur** :
* Le script crée ou met à jour les répertoires et fichiers nécessaires pour chaque joueur, y compris les données IPFS.
* Il vérifie et importe les clés IPNS du joueur si elles sont manquantes.
4. **Téléchargement et Vérification des Tiddlers** :
* Le script télécharge le TiddlyWiki (TW) du joueur depuis IPFS et vérifie la présence de tiddlers spécifiques comme `GPS`, `MadeInZion`, `AstroID`, et `Astroport`.
* Si des tiddlers sont manquants ou incorrects, le joueur est déconnecté et une alerte est envoyée.
5. **Mise à Jour des Coordonnées Géographiques** :
* Le script extrait les coordonnées GPS du tiddler `GPS` et les met à jour dans le cache du joueur.
* Il génère des tiddlers supplémentaires comme `VISIO` et `CESIUM` en fonction de l'âge du compte du joueur.
6. **Gestion des Amis et des Vœux** :
* Le script analyse les tiddlers tagués avec [`$:/moa`](usd-moa.md) pour gérer les amis du joueur et leurs tiddlers associés.
* Il crée et actualise les vœux des joueurs en utilisant les scripts [`VOEUX.create.sh`](../voeux.create.sh/) et `VOEUX.refresh.sh`.
7. **Surveillance des Transactions** :
* Le script exécute `G1PalPay.sh` pour surveiller les transactions sur la blockchain Ğ1 et exécuter des commandes basées sur les commentaires des transactions.
8. **Publication et Sauvegarde** :
* Le script publie le TiddlyWiki mis à jour du joueur sur IPFS et met à jour les caches locaux.
* Il envoie des notifications par email et publie des flux RSS pour les tiddlers modifiés.

44
astroport-20h12/player.refresh.sh/usd-moa.md Normal file
View File

@ -0,0 +1,44 @@
# $:/moa
Les tiddlers tagués avec `$:/moa` dans le script `PLAYER.refresh.sh` sont utilisés pour gérer les amis du joueur et leurs tiddlers associés. Voici une analyse détaillée de ce processus :
#### Fonctionnement des Tiddlers Tagués avec `$:/moa`
1. **Extraction des Tiddlers** :
* Le script utilise la commande `tiddlywiki` pour charger le TiddlyWiki (TW) du joueur et extraire les tiddlers tagués avec `$:/moa`. Cette extraction est effectuée avec la commande suivante :
```bash
tiddlywiki --load ~/.zen/tmp/${IPFSNODEID}/TW/${PLAYER}/index.html \
--output ~/.zen/tmp/${MOATS} \
--render '.' 'FRIENDS.json' 'text/plain' '$:/core/templates/exporters/JsonFile' 'exportFilter' '[tag[$:/moa]]'
```
2. **Analyse des Tiddlers** :
* Les tiddlers extraits sont ensuite analysés pour identifier les amis du joueur. Le script lit les titres des tiddlers et vérifie s'ils correspondent à des adresses email valides :
```bash
fplayers=($(cat ~/.zen/tmp/${MOATS}/FRIENDS.json | jq -rc .[].title))
```
3. **Gestion des Amis** :
* Pour chaque ami identifié, le script effectue plusieurs vérifications et actions :
* Vérifie le format de l'adresse email.
* Vérifie si l'ami est déjà présent dans le système.
* Extrait les informations supplémentaires comme le pseudo (`player`), l'adresse IPFS (`tw`), et la clé publique Ğ1 (`g1pub`).
4. **Mise à Jour des Tiddlers des Amis** :
* Si des tiddlers associés à des amis sont trouvés, ils sont importés dans le TW du joueur. Cela permet de maintenir les informations à jour et de synchroniser les données entre les amis :
```bash
tiddlywiki --load ~/.zen/tmp/${IPFSNODEID}/TW/${PLAYER}/index.html \
--import ~/.zen/tmp/${MOATS}/${FPLAYER^^}.json 'application/json' \
--output ~/.zen/tmp/${IPFSNODEID}/TW/${PLAYER} \
--render "$:/core/save/all" "newindex.html" "text/plain"
```
5. **Création de Tiddlers Signés** :
* Les tiddlers des amis sont signés et ajoutés au TW du joueur. Cela permet de garantir l'authenticité des informations partagées :
```bash
cat ~/.zen/tmp/${IPFSNODEID}/WISH/${PLAYER}/g1voeu/${WISHNAME}/_${APLAYER}.tiddlers.rss.json \
| sed "s~${PLAYER}~~g" \
| sed "s~${APLAYER}~${APLAYER} ${PLAYER}~g" \
> ~/.zen/tmp/${IPFSNODEID}/WISH/${PLAYER}/g1voeu/${WISHNAME}/_${APLAYER}.tiddlers.signed.json
```

34
astroport-20h12/player.refresh.sh/voeux.refresh.sh.md Normal file
View File

@ -0,0 +1,34 @@
# VOEUX.refresh.sh
Le script `VOEUX.refresh.sh` est conçu pour gérer et actualiser les vœux des joueurs dans l'écosystème Astroport. Voici une analyse détaillée de son fonctionnement :
#### Fonctionnalités Principales
1. **Initialisation et Vérifications** :
* Le script commence par vérifier si le nom du joueur (`PLAYER`) est fourni en argument. Si ce n'est pas le cas, il affiche un message d'erreur et s'arrête.
* Il récupère ensuite le pseudo du joueur (`PSEUDO`), la clé publique Ğ1 (`G1PUB`), et l'adresse IPNS de l'astronaute (`ASTRONAUTENS`).
2. **Vérification du Solde** :
* Le script vérifie le solde du joueur en Ğ1 (`COINS`). Si le solde est insuffisant (moins de 2 Ğ1), il affiche un message d'erreur et s'arrête.
3. **Extraction des Vœux** :
* Le script extrait les vœux du joueur à partir de son TiddlyWiki (TW). Il utilise TiddlyWiki pour charger le fichier `index.html` du joueur et exporter les vœux dans un fichier JSON.
4. **Traitement des Vœux** :
* Pour chaque vœu, le script :
* Récupère le nom du vœu (`WISHNAME`).
* Vérifie si une clé IPNS existe pour ce vœu (`VOEUKEY`). Si la clé n'existe pas, il réinitialise les vœux de l'astronaute.
* Exécute un programme spécifique au vœu si un script correspondant est trouvé dans le répertoire `ASTROBOT`.
5. **Mise à Jour des Tiddlers** :
* Le script recherche les Tiddlers associés aux vœux dans les TW des amis du joueur et les importe dans le TW du joueur.
* Il génère également des fichiers JSON pour les vœux et les publie sur IPFS.
6. **Publication et Notifications** :
* Le script publie les vœux sur IPFS et envoie des notifications par email aux joueurs concernés.
* Il met à jour les caches locaux et les flux RSS pour les vœux.
#### Exemple de Commande
Voici un exemple de commande pour exécuter le script `VOEUX.refresh.sh` :
```bash
./RUNTIME/VOEUX.refresh.sh "player_name" "20230608123456789" "/path/to/index.html"
```
####

199
astroport-20h12/tools-connect_player_to_gchange.sh.md Normal file
View File

@ -0,0 +1,199 @@
---
description: EN TRAVAUX
---
# tools/Connect\_PLAYER\_To\_Gchange.sh
Le script `tools/Connect_PLAYER_To_Gchange.sh` détermine la classe d'un joueur en fonction de sa présence dans Cesium+ et Gchange. Il extrait les données du joueur à partir de ces plateformes, analyse les informations pour déterminer la classe, et met à jour les données du joueur dans le TiddlyWiki.&#x20;
Voici une analyse détaillée de son fonctionnement :
#### Fonctionnalités Principales
1. **Initialisation et Configuration** :
* Le script commence par définir le chemin du script (`MY_PATH`) et le normalise pour obtenir un chemin absolu.
* Il source un fichier de configuration commun (`my.sh`) pour utiliser des fonctions et des variables partagées.
2. **Extraction des Données du Joueur** :
* Le script récupère les informations du joueur à partir de son TiddlyWiki (TW) et de ses profils Cesium+ et Gchange.
* Il utilise des requêtes HTTP pour interroger les API de Cesium+ et Gchange et obtenir les données du joueur.
3. **Détermination de la Classe du Joueur** :
* Le script analyse les données récupérées pour déterminer la classe du joueur. Les critères peuvent inclure :
* La présence d'un profil Cesium+ valide.
* La présence d'un profil Gchange valide.
* Le nombre de certifications reçues et émises.
* La participation active dans la communauté (transactions, publications, etc.).
4. **Mise à Jour des Données du Joueur** :
* Le script met à jour les informations du joueur dans le TiddlyWiki en fonction de la classe déterminée.
* Il peut également mettre à jour les caches locaux et distants avec les nouvelles informations.
#### Étapes du Script
1. **Définition des Variables et Chemins** :
```bash
MY_PATH="`dirname \"$0\"`"
MY_PATH="`( cd \"$MY_PATH\" && pwd )`"
. "${MY_PATH}/../tools/my.sh"
```
2. **Extraction des Données du Joueur** :
```bash
PLAYER="$1"
G1PUB=$(cat ~/.zen/game/players/${PLAYER}/.g1pub 2>/dev/null)
CESIUMPLUS_URL="https://g1.data.le-sou.org,https://g1.data.e-is.pro,https://g1.data.adn.life,https://g1.data.presles.fr"
GCHANGE_URL="https://data.gchange.fr"
```
3. **Requêtes HTTP pour Récupérer les Données** :
```bash
for cesiumplus_url in $(echo $CESIUMPLUS_URL | tr "," "\n"); do
response=$(curl -s "${cesiumplus_url}/user/profile/_search?scroll=2m" -d '{"query":{"bool":{"must":[{"term":{"pubkey":"'"${G1PUB}"'"}}]}}}')
if [[ $response != "" ]]; then
break
fi
done
gchange_response=$(curl -s "${GCHANGE_URL}/user/profile/_search?scroll=2m" -d '{"query":{"bool":{"must":[{"term":{"pubkey":"'"${G1PUB}"'"}}]}}}')
```
4. **Analyse des Données et Détermination de la Classe** :
```bash
if [[ $response != "" ]]; then
class="Cesium+"
fi
if [[ $gchange_response != "" ]]; then
class="Gchange"
fi
if [[ $response != "" && $gchange_response != "" ]]; then
class="Cesium+ & Gchange"
fi
```
5. **Mise à Jour des Données du Joueur** :
```bash
tiddlywiki --load ~/.zen/tmp/${IPFSNODEID}/TW/${PLAYER}/index.html \
--output ~/.zen/tmp/${MOATS} \
--render '.' 'PLAYER.json' 'text/plain' '$:/core/templates/exporters/JsonFile' 'exportFilter' '[tag[PLAYER]]'
echo "Class: $class" >> ~/.zen/tmp/${MOATS}/PLAYER.json
```
#### EVOLUTION...
Voici un exemple de réécriture du script `Connect_PLAYER_To_Gchange.sh` pour déterminer la classe du joueur en fonction de sa présence dans Cesium+ et Gchange :
```bash
#!/bin/bash
################################################################################
# Author: Fred (support@qo-op.com)
# Version: 0.1
# License: AGPL-3.0 (https://choosealicense.com/licenses/agpl-3.0/)
################################################################################
MY_PATH="`dirname \"$0\"`"
MY_PATH="`( cd \"$MY_PATH\" && pwd )`"
. "${MY_PATH}/my.sh"
PLAYER="$1"
if [[ -z "$PLAYER" ]]; then
echo "Please provide PLAYER"
exit 1
fi
G1PUB=$(cat ~/.zen/game/players/${PLAYER}/.g1pub 2>/dev/null)
if [[ -z "$G1PUB" ]]; then
echo "G1PUB not found for player $PLAYER"
exit 1
fi
CESIUMPLUS_URL="https://g1.data.le-sou.org,https://g1.data.e-is.pro,https://g1.data.adn.life,https://g1.data.presles.fr"
GCHANGE_URL="https://data.gchange.fr"
# Function to fetch data from Cesium+
fetch_cesiumplus_data() {
local url="$1"
local query='{
"query": {
"bool": {
"should": [
{"exists": {"field": "geoPoint"}},
{"bool": {"must": [
{"exists": {"field": "title"}},
{"exists": {"field": "uid"}}
]}}
]
}
},
"size": 10000,
"_source": ["title", "geoPoint", "avatar._content_type"]
}'
curl -s -X POST -H "Content-Type: application/json" -d "$query" "$url/user/profile/_search?scroll=2m"
}
# Fetch data from Cesium+
cesiumplus_data=""
for url in $(echo $CESIUMPLUS_URL | tr "," "\n"); do
response=$(fetch_cesiumplus_data "$url")
if [[ -n "$response" ]]; then
cesiumplus_data="$response"
break
fi
done
# Fetch data from Gchange
gchange_data=$(curl -s -X POST -H "Content-Type: application/json" -d "$query" "$GCHANGE_URL/user/profile/_search?scroll=2m")
# Determine player class
class=""
if [[ -n "$cesiumplus_data" ]]; then
class="Cesium+"
fi
if [[ -n "$gchange_data" ]]; then
class="Gchange"
fi
if [[ -n "$cesiumplus_data" && -n "$gchange_data" ]]; then
class="Cesium+ & Gchange"
fi
# Update player data in TiddlyWiki
tiddlywiki --load ~/.zen/tmp/${IPFSNODEID}/TW/${PLAYER}/index.html \
--output ~/.zen/tmp/${MOATS} \
--render '.' 'PLAYER.json' 'text/plain' '$:/core/templates/exporters/JsonFile' 'exportFilter' '[tag[PLAYER]]'
echo "Class: $class" >> ~/.zen/tmp/${MOATS}/PLAYER.json
# Import updated data back into TiddlyWiki
tiddlywiki --load ~/.zen/tmp/${IPFSNODEID}/TW/${PLAYER}/index.html \
--import ~/.zen/tmp/${MOATS}/PLAYER.json 'application/json' \
--output ~/.zen/tmp/${IPFSNODEID}/TW/${PLAYER} \
--render "$:/core/save/all" "newindex.html" "text/plain"
if [[ -s ~/.zen/tmp/${IPFSNODEID}/TW/${PLAYER}/newindex.html ]]; then
cp ~/.zen/tmp/${IPFSNODEID}/TW/${PLAYER}/newindex.html ~/.zen/tmp/${IPFSNODEID}/TW/${PLAYER}/index.html
rm ~/.zen/tmp/${IPFSNODEID}/TW/${PLAYER}/newindex.html
else
echo "ERROR - CANNOT IMPORT PLAYER.json - ERROR"
fi
echo "Player $PLAYER class updated to $class"
```
#### Explications
1. **Initialisation et Configuration** :
* Le script commence par définir le chemin du script (`MY_PATH`) et le normalise pour obtenir un chemin absolu.
* Il source un fichier de configuration commun (`my.sh`) pour utiliser des fonctions et des variables partagées.
2. **Extraction des Données du Joueur** :
* Le script récupère les informations du joueur à partir de son TiddlyWiki (TW) et de ses profils Cesium+ et Gchange.
* Il utilise des requêtes HTTP pour interroger les API de Cesium+ et Gchange et obtenir les données du joueur.
3. **Détermination de la Classe du Joueur** :
* Le script analyse les données récupérées pour déterminer la classe du joueur. Les critères peuvent inclure :
* La présence d'un profil Cesium+ valide.
* La présence d'un profil Gchange valide.
4. **Mise à Jour des Données du Joueur** :
* Le script met à jour les informations du joueur dans le TiddlyWiki en fonction de la classe déterminée.
* Il importe les données mises à jour dans le TiddlyWiki.

59
astroport-20h12/uplanet.refresh.sh/README.md Normal file
View File

@ -0,0 +1,59 @@
---
description: Mise à Jour des Clés Géographiques
---
# UPLANET.refresh.sh
Le script `UPLANET.refresh.sh` est un composant essentiel de l'écosystème Astroport.ONE, permettant de maintenir à jour les informations géographiques des joueurs en utilisant IPFS et des scripts de gestion.
Il assure la synchronisation des données géographiques, la génération de clés dérivées pour les différentes zones géographiques, et la publication des données mises à jour sur IPFS. Ces fonctionnalités permettent de garantir que les informations géographiques des joueurs sont toujours à jour et accessibles dans l'écosystème décentralisé.
#### Fonctionnalités Principales
1. **Initialisation et Configuration** :
* Le script commence par définir le chemin du script (`MY_PATH`) et le normalise pour obtenir un chemin absolu.
* Il source un fichier de configuration commun (`my.sh`) pour utiliser des fonctions et des variables partagées.
2. **Extraction des Coordonnées Géographiques** :
* Le script extrait les coordonnées géographiques des joueurs à partir de leurs TiddlyWiki (TW).
* Il vérifie et met à jour les informations géographiques des joueurs, y compris les coordonnées de latitude et de longitude.
3. **Mise à Jour des Clés Géographiques** :
* Le script génère des clés dérivées pour les différentes zones géographiques (UMAP, SECTOR, REGION) en utilisant les coordonnées géographiques.
* Il met à jour les informations associées à ces clés dans les caches locaux et distants.
4. **Publication des Données Géographiques** :
* Le script publie les données géographiques mises à jour sur IPFS et met à jour les caches locaux et distants.
* Il génère des QR codes pour différents liens associés aux zones géographiques.
#### Étapes du Script
1. **Définition des Variables et Chemins** :
```bash
MY_PATH="`dirname \"$0\"`"
MY_PATH="`( cd \"$MY_PATH\" && pwd )`"
. "${MY_PATH}/../tools/my.sh"
```
2. **Extraction des Coordonnées Géographiques** :
```bash
tiddlywiki --load ~/.zen/tmp/${IPFSNODEID}/TW/${PLAYER}/index.html \
--output ~/.zen/tmp/${MOATS} \
--render '.' 'GPS.json' 'text/plain' '$:/core/templates/exporters/JsonFile' 'exportFilter' 'GPS'
```
3. **Mise à Jour des Clés Géographiques** :
```bash
LAT=$(cat ~/.zen/tmp/${MOATS}/GPS.json | jq -r .[].lat)
LON=$(cat ~/.zen/tmp/${MOATS}/GPS.json | jq -r .[].lon)
LAT=$(makecoord ${LAT})
LON=$(makecoord ${LON})
${MY_PATH}/../tools/keygen -t duniter -o ~/.zen/tmp/${MOATS}/UMAP.priv "${UPLANETNAME}${LAT}${LON}" "${UPLANETNAME}${LAT}${LON}"
UMAPG1PUB=$(cat ~/.zen/tmp/${MOATS}/UMAP.priv | grep "pub:" | cut -d ' ' -f 2)
```
4. **Publication des Données Géographiques** :
```bash
UMAPNS=$(ipfs key import ${UMAPG1PUB} -f pem-pkcs8-cleartext ~/.zen/tmp/${MOATS}/UMAP.priv)
ipfs --timeout 180s name publish -k ${UMAPG1PUB} /ipfs/${UMAPFLUX}
```
Les clés spatio-temporelles dans l'écosystème Astroport.ONE sont mises à jour quotidiennement en utilisant les données de la veille. Les scripts récupèrent les données existantes, les mettent à jour avec les nouvelles informations, génèrent de nouvelles clés dérivées, et publient les données mises à jour sur IPFS. Cela permet de maintenir une synchronisation continue et précise des informations géographiques et temporelles dans l'écosystème décentralisé.

76
astroport-20h12/uplanet.refresh.sh/region.refresh.sh.md Normal file
View File

@ -0,0 +1,76 @@
# REGION.refresh.sh
Le script `REGION.refresh.sh` est conçu pour actualiser les données des régions géographiques dans l'écosystème Astroport.ONE en agrégeant les flux RSS produits par les secteurs internes. Voici une analyse détaillée de son fonctionnement :
#### Fonctionnalités Principales
1. **Initialisation et Configuration** :
* Le script commence par définir le chemin du script (`MY_PATH`) et le normalise pour obtenir un chemin absolu.
* Il source un fichier de configuration commun (`my.sh`) pour utiliser des fonctions et des variables partagées.
2. **Détermination des Régions** :
* Le script identifie les régions géographiques à partir des coordonnées des UMAPs (Unités de Mesure de l'Activité Planétaire).
* Il génère une liste unique de régions à partir des UMAPs disponibles.
3. **Génération et Gestion des Clés** :
* Le script génère des clés Duniter et IPFS pour chaque région.
* Il importe ces clés dans le keystore IPFS et les utilise pour publier les données de la région.
4. **Récupération et Mise à Jour des Données** :
* Le script récupère les données de la région à partir de la clé IPNS de la veille.
* Il met à jour les données de la région avec les nouvelles informations collectées.
5. **Agrégation des Flux RSS** :
* Le script collecte les flux RSS des secteurs internes et les agrège pour créer un flux RSS régional.
* Il utilise des outils pour convertir les flux RSS en fichiers JSON et les fusionner.
6. **Publication des Données** :
* Le script publie les données mises à jour sur IPFS et met à jour les caches locaux et distants.
* Il génère des QR codes et des images pour visualiser les informations de la région.
#### Étapes du Script
1. **Définition des Variables et Chemins** :
```bash
MY_PATH="`dirname \"$0\"`"
MY_PATH="`( cd \"$MY_PATH\" && pwd )`"
. "${MY_PATH}/../tools/my.sh"
```
2. **Détermination des Régions** :
```bash
for UMAP in ${UMAPS[@]}; do
LAT=$(echo ${UMAP} | cut -d '_' -f 2)
LON=$(echo ${UMAP} | cut -d '_' -f 3)
RLAT="${LAT::-1}"
RLON="${LON::-1}"
MYREGIONS=("_${RLAT}_${RLON}" ${MYREGIONS[@]})
done
REGIONS=($(echo "${MYREGIONS[@]}" | tr ' ' '\n' | sort -u))
```
3. **Génération et Gestion des Clés** :
```bash
${MY_PATH}/../tools/keygen -t duniter -o ~/.zen/tmp/${MOATS}/REGION.priv "${UPLANETNAME}${REGION}" "${UPLANETNAME}${REGION}"
REGIONG1PUB=$(cat ~/.zen/tmp/${MOATS}/REGION.priv | grep 'pub:' | cut -d ' ' -f 2)
REGIONNS=$(ipfs key import ${REGIONG1PUB} -f pem-pkcs8-cleartext ~/.zen/tmp/${MOATS}/REGION.priv)
```
4. **Récupération et Mise à Jour des Données** :
```bash
ipfs --timeout 240s get --progress=false -o ~/.zen/tmp/${MOATS}/${REGION}/ /ipns/${YESTERDATEREGIONNS}/
```
5. **Agrégation des Flux RSS** :
```bash
RSSNODE=($(ls ~/.zen/tmp/${IPFSNODEID}/UPLANET/SECTORS/_${RLAT}*_${RLON}*/_${RLAT}*_${RLON}*/_${RLAT}*_${RLON}*.week.rss.json 2>/dev/null))
for RSS in ${RSSNODE[@]}; do
[[ $(cat ${RSS}) != "[]" ]] && cp ${RSS} ~/.zen/tmp/${MOATS}/${REGION}/RSS/ && ${MY_PATH}/../tools/RSS2WEEKnewsfile.sh ${RSS} >> ~/.zen/tmp/${MOATS}/${REGION}/JOURNAL
done
```
6. **Publication des Données** :
```bash
IPFSPOP=$(ipfs add -rwq ~/.zen/tmp/${MOATS}/${REGION}/* | tail -n 1)
ipfs --timeout 180s name publish -k ${TODATE}${REGIONG1PUB} /ipfs/${IPFSPOP}
```
A VENIR
ollama

106
astroport-20h12/uplanet.refresh.sh/sector.refresh.sh.md Normal file
View File

@ -0,0 +1,106 @@
# SECTOR.refresh.sh
Le script `SECTOR.refresh.sh` permet de maintenir à jour les informations des secteurs géographiques en utilisant IPFS et des scripts de gestion. Il assure la rotation des clés spatio-temporelles, la synchronisation des données, et la copie des flux RSS des nouveaux tiddlers du secteur. Voici une analyse détaillée de son fonctionnement :
#### Fonctionnalités Principales
1. **Initialisation et Configuration** :
* Le script commence par définir le chemin du script (`MY_PATH`) et le normalise pour obtenir un chemin absolu.
* Il source un fichier de configuration commun (`my.sh`) pour utiliser des fonctions et des variables partagées.
2. **Détermination des Secteurs** :
* Le script identifie les secteurs géographiques à partir des coordonnées des UMAPs (Unités de Mesure de l'Activité Planétaire).
* Il génère une liste unique de secteurs à partir des UMAPs disponibles.
3. **Génération et Gestion des Clés** :
* Le script génère des clés Duniter et IPFS pour chaque secteur.
* Il importe ces clés dans le keystore IPFS et les utilise pour publier les données du secteur.
4. **Récupération et Mise à Jour des Données** :
* Le script récupère les données du secteur à partir de la clé IPNS de la veille.
* Il met à jour les données du secteur avec les nouvelles informations collectées.
5. **Publication des Données** :
* Le script publie les données mises à jour sur IPFS et met à jour les caches locaux et distants.
* Il génère des QR codes et des images pour visualiser les informations du secteur.
#### Étapes du Script
1. **Définition des Variables et Chemins** :
```bash
MY_PATH="`dirname \"$0\"`"
MY_PATH="`( cd \"$MY_PATH\" && pwd )`"
. "${MY_PATH}/../tools/my.sh"
```
2. **Détermination des Secteurs** :
```bash
for UMAP in ${UMAPS[@]}; do
LAT=$(echo ${UMAP} | cut -d '_' -f 2)
LON=$(echo ${UMAP} | cut -d '_' -f 3)
SLAT="${LAT::-1}"
SLON="${LON::-1}"
MYSECTORS=("_${SLAT}_${SLON}" ${MYSECTORS[@]})
done
SECTORS=($(echo "${MYSECTORS[@]}" | tr ' ' '\n' | sort -u))
```
3. **Génération et Gestion des Clés** :
```bash
${MY_PATH}/../tools/keygen -t duniter -o ~/.zen/tmp/${MOATS}/${SECTOR}.dunikey "${UPLANETNAME}${SECTOR}" "${UPLANETNAME}${SECTOR}"
G1PUB=$(cat ~/.zen/tmp/${MOATS}/${SECTOR}.dunikey | grep 'pub:' | cut -d ' ' -f 2)
${MY_PATH}/../tools/keygen -t ipfs -o ~/.zen/tmp/${MOATS}/${SECTOR}.priv "${UPLANETNAME}${SECTOR}" "${UPLANETNAME}${SECTOR}"
SECTORNS=$(ipfs key import ${G1PUB} -f pem-pkcs8-cleartext ~/.zen/tmp/${MOATS}/${SECTOR}.priv)
```
4. **Récupération et Mise à Jour des Données** :
```bash
ipfs --timeout 180s get --progress=false -o ~/.zen/tmp/${MOATS}/${SECTOR}/ /ipns/${YESTERDATENS}/
```
5. **Publication des Données** :
```bash
IPFSPOP=$(ipfs add -rwq ~/.zen/tmp/${MOATS}/${SECTOR}/* | tail -n 1)
ipfs --timeout 240s name publish -k ${TODATE}${G1PUB} /ipfs/${IPFSPOP}
```
#### Rotation des Clés Spatio-Temporelles
Le script gère la rotation des clés spatio-temporelles en générant de nouvelles clés pour chaque jour et en les publiant sur IPFS. Voici comment cela se fait :
1. **Génération des Clés pour la Date du Jour et de la Veille** :
```bash
${MY_PATH}/../tools/keygen -t ipfs -o ~/.zen/tmp/${MOATS}/${TODATE}.priv "${TODATE}${UPLANETNAME}${SECTOR}" "${TODATE}${UPLANETNAME}${SECTOR}"
TODATENS=$(ipfs key import ${TODATE}${G1PUB} -f pem-pkcs8-cleartext ~/.zen/tmp/${MOATS}/${TODATE}.priv)
```
2. **Récupération des Données de la Veille** :
```bash
ipfs --timeout 180s get --progress=false -o ~/.zen/tmp/${MOATS}/${SECTOR}/ /ipns/${YESTERDATENS}/
```
3. **Publication des Nouvelles Données** :
```bash
IPFSPOP=$(ipfs add -rwq ~/.zen/tmp/${MOATS}/${SECTOR}/* | tail -n 1)
ipfs --timeout 240s name publish -k ${TODATE}${G1PUB} /ipfs/${IPFSPOP}
```
#### Copie des Flux RSS des Nouveaux Tiddlers du Secteur
Le script copie les flux RSS des nouveaux tiddlers du secteur en les récupérant et en les ajoutant au TiddlyWiki du secteur. Voici comment cela se fait :
1. **Récupération des Flux RSS** :
```bash
RSSNODE=($(ls ~/.zen/tmp/${IPFSNODEID}/UPLANET/__/_*_*/_${SLAT}_${SLON}/_*_*/RSS/*.rss.json 2>/dev/null))
RSSWARM=($(ls ~/.zen/tmp/swarm/12D*/UPLANET/__/_*_*/_${SLAT}_${SLON}/_*_*/RSS/*.rss.json 2>/dev/null))
combinedrss=("${RSSNODE[@]}" "${RSSWARM[@]}")
RSSALL=($(echo "${combinedrss[@]}" | tr ' ' '\n' | sort -u))
```
2. **Ajout des Tiddlers au TiddlyWiki du Secteur** :
```bash
for RSS in ${RSSALL[@]}; do
${MY_PATH}/RSS2UPlanetSECTORTW.sh "${RSS}" "${SECTOR}" "${MOATS}" "${INDEX}"
done
```
####

100
astroport-20h12/voeux.create.sh/README.md Normal file
View File

@ -0,0 +1,100 @@
---
description: Gestion des Vœux
---
# VOEUX.create.sh
Les scripts `VOEUX.create.sh` et `VOEUX.refresh.sh` sont des composants essentiels de l'écosystème Astroport.ONE, permettant de gérer les vœux des joueurs. Voici une analyse détaillée de leurs fonctionnalités et de leur fonctionnement :
### VOEUX.create.sh
#### Fonctionnalités Principales
1. **Initialisation et Configuration** :
* Le script commence par définir le chemin du script (`MY_PATH`) et le normalise pour obtenir un chemin absolu.
* Il source un fichier de configuration commun (`my.sh`) pour utiliser des fonctions et des variables partagées.
2. **Création de la Clé Derivée pour le Vœu** :
* Le script génère une clé dérivée pour le vœu en utilisant le titre du vœu, le joueur, et un sel.
* Il utilise `keygen` pour créer une clé Duniter et une clé IPFS pour le vœu.
3. **Mise à Jour de la Base de Données des Vœux** :
* Le script met à jour la base de données mondiale des vœux avec les informations du nouveau vœu.
* Il génère des QR codes pour différents liens associés au vœu (par exemple, lien IPNS, lien G1).
4. **Création de Tiddlers** :
* Le script crée des tiddlers spécifiques pour le vœu, incluant des informations comme le titre, le joueur, et les clés associées.
#### Étapes du Script
1. **Définition des Variables et Chemins** :
```bash
MY_PATH="`dirname \"$0\"`"
MY_PATH="`( cd \"$MY_PATH\" && pwd )`"
. "${MY_PATH}/../tools/my.sh"
```
2. **Création de la Clé Derivée** :
```bash
${MY_PATH}/../tools/keygen -t duniter -o ~/.zen/tmp/${MOATS}/wish.dunikey "${SECRET1}${UPLANETNAME}" "${SECRET2}${UPLANETNAME}"
WISHG1PUB=$(cat ~/.zen/tmp/${MOATS}/wish.dunikey | grep "pub:" | cut -d ' ' -f 2)
```
3. **Mise à Jour de la Base de Données des Vœux** :
```bash
mkdir -p ~/.zen/game/world/${VoeuName}/${WISHG1PUB}/
echo ${VoeuName} > ~/.zen/game/world/${VoeuName}/${WISHG1PUB}/.pepper
echo ${WISHG1PUB} > ~/.zen/game/world/${VoeuName}/${WISHG1PUB}/.wish
```
4. **Création de QR Codes** :
```bash
qrencode -s 12 -o "$HOME/.zen/game/world/${VoeuName}/${WISHG1PUB}/QR.WISHLINK.png" "$LIBRA/ipns/${VOEUNS}"
```
### VOEUX.refresh.sh
#### Fonctionnalités Principales
1. **Initialisation et Configuration** :
* Le script commence par définir le chemin du script (`MY_PATH`) et le normalise pour obtenir un chemin absolu.
* Il source un fichier de configuration commun (`my.sh`) pour utiliser des fonctions et des variables partagées.
2. **Extraction des Vœux depuis le TiddlyWiki du Joueur** :
* Le script extrait les vœux du joueur depuis son TiddlyWiki en utilisant des filtres spécifiques.
* Il vérifie si le joueur a suffisamment de G1 pour continuer à actualiser ses vœux.
3. **Mise à Jour des Vœux** :
* Pour chaque vœu, le script vérifie et met à jour les informations associées, y compris les clés IPNS et les soldes des portefeuilles.
* Il exécute des programmes spécifiques pour chaque type de vœu, si disponibles.
4. **Publication des Vœux** :
* Le script publie les vœux mis à jour sur IPFS et met à jour les caches locaux et distants.
#### Étapes du Script
1. **Définition des Variables et Chemins** :
```bash
MY_PATH="`dirname \"$0\"`"
MY_PATH="`( cd \"$MY_PATH\" && pwd )`"
. "${MY_PATH}/../tools/my.sh"
```
2. **Extraction des Vœux** :
```bash
tiddlywiki --load ${INDEX} --output ~/.zen/tmp/${IPFSNODEID}/WISH/${PLAYER}/g1voeu --render '.' "${PLAYER}.g1voeu.json" 'text/plain' '$:/core/templates/exporters/JsonFile' 'exportFilter' '[days:created[-360]tag[G1Voeu]]'
```
3. **Mise à Jour des Vœux** :
```bash
while read WISH do
WISHNAME=$(cat ~/.zen/tmp/${IPFSNODEID}/WISH/${PLAYER}/g1voeu/${PLAYER}.g1voeu.json | jq .[] | jq -r 'select(.wish=="'${WISH}'") | .title')
# Autres mises à jour...
done < ~/.zen/tmp/${IPFSNODEID}/WISH/${PLAYER}/g1voeu/${PLAYER}.g1wishes.txt
```
4. **Publication des Vœux** :
```bash
WISHFLUX=$(ipfs add -qHwr ~/.zen/tmp/${IPFSNODEID}/WISH/${PLAYER}/g1voeu/${WISHNAME}/* | tail -n 1)
ipfs --timeout 180s name publish -k $VOEUKEY /ipfs/$WISHFLUX
```
#### Conclusion
Les scripts `VOEUX.create.sh` et `VOEUX.refresh.sh` sont conçus pour gérer la création et la mise à jour des vœux des joueurs dans l'écosystème Astroport.ONE. Ils permettent de générer des clés dérivées, de mettre à jour les bases de données des vœux, de créer des tiddlers spécifiques, et de publier les vœux sur IPFS. Ces scripts assurent une gestion efficace et sécurisée des vœux, tout en maintenant la synchronisation avec les caches locaux et distants.

66
astroport-20h12/voeux.create.sh/g1voeu.sh.md Normal file
View File

@ -0,0 +1,66 @@
# G1Voeu.sh
Le script `G1Voeu.sh` permet de créer et de publier un vœu sur la blockchain Ğ1 pour un joueur spécifique. Il génère une clé dérivée pour le vœu, met à jour le TiddlyWiki du joueur avec les informations du vœu, et publie le TiddlyWiki mis à jour sur IPFS.&#x20;
#### Fonctionnalités Principales
1. **Initialisation et Configuration** :
* Le script commence par définir le chemin du script (`MY_PATH`) et le normalise pour obtenir un chemin absolu.
* Il source un fichier de configuration commun (`my.sh`) pour utiliser des fonctions et des variables partagées.
2. **Paramètres et Variables** :
* Le script prend trois paramètres principaux : le titre du vœu (`TITRE`), le joueur (`PLAYER`), et le chemin vers l'index TiddlyWiki (`INDEX`).
* Si le joueur ou l'index ne sont pas fournis, le script tente de les récupérer à partir des fichiers de configuration locaux.
3. **Création de la Clé Derivée pour le Vœu** :
* Le script utilise une clé dérivée pour le vœu, générée à partir du titre du vœu, du joueur, et d'un sel (SALT).
* Il utilise l'outil `keygen` pour générer cette clé dérivée et obtenir la clé publique Ğ1 associée (`WISHG1PUB`).
4. **Mise à Jour du TiddlyWiki** :
* Le script met à jour le TiddlyWiki du joueur avec les informations du vœu.
* Il crée un tiddler spécifique pour le vœu et l'ajoute au TiddlyWiki.
5. **Publication sur IPFS** :
* Le script publie le TiddlyWiki mis à jour sur IPFS et met à jour les caches locaux et distants.
* Il génère des QR codes et des images pour visualiser les informations du vœu.
#### Étapes du Script
1. **Définition des Variables et Chemins** :
```bash
MY_PATH="`dirname \"$0\"`"
MY_PATH="`( cd \"$MY_PATH\" && pwd )`"
. "${MY_PATH}/../tools/my.sh"
```
2. **Paramètres et Variables** :
```bash
TITRE="$1"
PLAYER="$2"
INDEX="$3"
[[ ${PLAYER} == "" ]] && PLAYER=$(cat ~/.zen/game/players/.current/.player 2>/dev/null)
[[ ${PLAYER} == "" ]] && echo "Second paramètre PLAYER manquant" && exit 1
PSEUDO=$(cat ~/.zen/game/players/${PLAYER}/.pseudo 2>/dev/null)
[[ $G1PUB == "" ]] && G1PUB=$(cat ~/.zen/game/players/${PLAYER}/.g1pub 2>/dev/null)
[[ $G1PUB == "" ]] && echo "Troisième paramètre G1PUB manquant" && exit 1
[[ ! $INDEX ]] && INDEX="$HOME/.zen/game/players/${PLAYER}/ipfs/moa/index.html"
```
3. **Création de la Clé Derivée pour le Vœu** :
```bash
source ~/.zen/game/players/${PLAYER}/secret.june
[[ ${PEPPER} ]] && echo "Using PLAYER PEPPER AS WISH SALT" && SECRET1="${PEPPER}"
SECRET2="${VoeuName} ${PLAYER} ${SALT}"
${MY_PATH}/../tools/keygen -t duniter -o ~/.zen/tmp/${MOATS}/wish.dunikey "${SECRET1}${UPLANETNAME}" "${SECRET2}${UPLANETNAME}"
WISHG1PUB=$(cat ~/.zen/tmp/${MOATS}/wish.dunikey | grep 'pub:' | cut -d ' ' -f 2)
```
4. **Mise à Jour du TiddlyWiki** :
```bash
tiddlywiki --load ${INDEX} --output ~/.zen/tmp/${MOATS} --render '.' 'G1Voeu.json' 'text/plain' '$:/core/templates/exporters/JsonFile' 'exportFilter' '[tag[G1Voeu]]'
```
5. **Publication sur IPFS** :
```bash
TW=$(ipfs add -Hq ~/.zen/game/players/${PLAYER}/ipfs/moa/index.html | tail -n 1)
ipfs --timeout 720s name publish --key=${PLAYER} /ipfs/${TW}
```
####