2022-12-26 23:24:52 +01:00
|
|
|
#shellcheck shell=sh disable=SC2034
|
2022-12-26 21:43:33 +01:00
|
|
|
|
2022-12-30 01:08:09 +01:00
|
|
|
Base32Normalize() {
|
2023-01-03 16:40:07 +01:00
|
|
|
awk '{printf $0}' | basenc --base32 | Normalize
|
2022-12-30 01:08:09 +01:00
|
|
|
}
|
|
|
|
|
|
2022-12-29 14:51:05 +01:00
|
|
|
Normalize() {
|
2023-01-03 16:40:07 +01:00
|
|
|
awk '{print tolower($1)}' | sed 's/\(_\|+\)/./g; s/=//g;'
|
2022-12-29 14:51:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
Revert() {
|
2023-01-03 16:40:07 +01:00
|
|
|
awk -F. '{for (i=NF; i>1; i--) printf("%s.",$i); print $1;}'
|
2022-12-29 14:51:05 +01:00
|
|
|
}
|
|
|
|
|
|
2022-12-26 21:43:33 +01:00
|
|
|
isLan() {
|
2023-05-06 02:35:06 +02:00
|
|
|
local isLan=$(ip route | awk '$1 == "default" {print $3}' | grep -E "/(^127\.)|(^192\.168\.)|(^10\.)|(^172\.1[6-9]\.)|(^172\.2[0-9]\.)|(^172\.3[0-1]\.)|(^::1$)|(^[fF][cCdD])/" \
|
2023-01-03 16:40:07 +01:00
|
|
|
|| route -n |awk '$1 == "0.0.0.0" {print $2}' | grep -E "/(^127\.)|(^192\.168\.)|(^10\.)|(^172\.1[6-9]\.)|(^172\.2[0-9]\.)|(^172\.3[0-1]\.)|(^::1$)|(^[fF][cCdD])/" \
|
|
|
|
|
|| true)
|
2023-07-19 10:46:28 +02:00
|
|
|
|
|
|
|
|
#~ local myZip=$(zIp)
|
|
|
|
|
#~ [ -n "$myZip" ] && echo "$myZip" && exit 0
|
|
|
|
|
|
|
|
|
|
# [ -n "$isLan" ] && echo "$isLan" || true
|
2022-12-26 21:43:33 +01:00
|
|
|
} 2>/dev/null
|
|
|
|
|
|
2022-12-27 19:35:43 +01:00
|
|
|
isPlayerLegal() {
|
2023-01-03 16:40:07 +01:00
|
|
|
local isPlayerLegal=$(cat "$(myPlayerPath)"/.legal 2>/dev/null || true)
|
|
|
|
|
[ -n "$isPlayerLegal" ] && echo "$isPlayerLegal" || true
|
2022-12-27 19:35:43 +01:00
|
|
|
}
|
|
|
|
|
|
2022-12-30 01:08:09 +01:00
|
|
|
myAstroFeedKey() {
|
2023-01-03 16:40:07 +01:00
|
|
|
local myAstroFeedKey=$(ipfs --api "$(myIpfsApi)" key list -l | awk '$2 == "'"$(myPlayerFeed)"'" {print $1}')
|
|
|
|
|
[ -n "$myAstroFeedKey" ] && echo "$myAstroFeedKey"
|
2022-12-30 01:08:09 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
myAstroFeedKeyFile() {
|
2023-01-03 16:40:07 +01:00
|
|
|
local myAstroFeedKeyFile="$(myIpfsKeyStore)/key_$(myPlayerFeed | Base32Normalize)"
|
|
|
|
|
[ -f "$myAstroFeedKeyFile" ] && echo "$myAstroFeedKeyFile"
|
2022-12-30 01:08:09 +01:00
|
|
|
}
|
|
|
|
|
|
2022-12-29 14:51:05 +01:00
|
|
|
myAstroKey() {
|
2023-01-03 16:40:07 +01:00
|
|
|
local myAstroKey=$(ipfs --api "$(myIpfsApi)" key list -l | awk '$2 == "'"$(myPlayer)"'" {print $1}')
|
|
|
|
|
[ -n "$myAstroKey" ] && echo "$myAstroKey"
|
2022-12-27 19:35:43 +01:00
|
|
|
}
|
|
|
|
|
|
2022-12-30 01:08:09 +01:00
|
|
|
myAstroKeyFile() {
|
2023-01-03 16:40:07 +01:00
|
|
|
local myAstroKeyFile="$(myIpfsKeyStore)/key_$(myPlayer | Base32Normalize)"
|
|
|
|
|
[ -f "$myAstroKeyFile" ] && echo "$myAstroKeyFile"
|
2022-12-30 01:08:09 +01:00
|
|
|
}
|
|
|
|
|
|
2022-12-29 14:51:05 +01:00
|
|
|
myAstroPath() {
|
2023-01-03 16:40:07 +01:00
|
|
|
local myAstroPath=$(cd ~/.zen/Astroport.ONE/ && pwd -P)
|
|
|
|
|
[ -n "$myAstroPath" ] && echo "$myAstroPath"
|
2022-12-26 21:43:33 +01:00
|
|
|
}
|
|
|
|
|
|
2023-01-12 23:42:49 +01:00
|
|
|
#~ myAstroPlayersPage() {
|
|
|
|
|
#~ local myAstroPlayersPage=$(cat ~/.zen/tmp/myAstroPlayersPage)
|
|
|
|
|
#~ if [[ ! "$myAstroPlayersPage" ]]; then
|
|
|
|
|
#~ counter=1
|
|
|
|
|
#~ for tw in ls ~/.zen/game/players/*/ipfs/moa/index.html; do
|
2023-11-16 18:07:55 +01:00
|
|
|
#~ tiddlywiki --load $tw --output ~/.zen/tmp --render '.' "${counter}ZenCard.json" 'text/plain' '$:/core/templates/exporters/JsonFile' 'exportFilter' 'ZenCard'
|
2023-01-12 23:42:49 +01:00
|
|
|
|
|
|
|
|
#~ ((counter++))
|
|
|
|
|
#~ done
|
|
|
|
|
#~ echo "$myAstroPlayersPage"
|
|
|
|
|
#~ }
|
|
|
|
|
|
2022-12-29 14:51:05 +01:00
|
|
|
myDate() {
|
2023-01-03 16:40:07 +01:00
|
|
|
local myDate=$(date -u +"%Y%m%d%H%M%S%4N")
|
|
|
|
|
[ -n "$myDate" ] && echo "$myDate"
|
2022-12-29 14:51:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
myDomainName() {
|
2023-01-03 16:40:07 +01:00
|
|
|
local myDomainName=$(domainname 2>/dev/null) && [ "$myDomainName" = "(none)" ] && myDomainName=$(hostname -d 2>/dev/null) && [ -z "$myDomainName" ] && myDomainName="localhost"
|
|
|
|
|
[ -n "$myDomainName" ] && echo "$myDomainName"
|
2022-12-26 21:43:33 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
myHttp() {
|
2023-01-03 16:40:07 +01:00
|
|
|
[ -n "$(myHttpHeader)" ] \
|
|
|
|
|
&& local myHttp="$(myHttpHeader)
|
2022-12-26 21:43:33 +01:00
|
|
|
|
2022-12-29 14:51:05 +01:00
|
|
|
" || local myHttp=""
|
2023-01-03 16:40:07 +01:00
|
|
|
[ -n "$(myHttpContent)" ] && myHttp="${myHttp}$(myHttpContent)"
|
|
|
|
|
[ -n "$myHttp" ] && echo "$myHttp"
|
2022-12-26 21:43:33 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
myHttpContent() {
|
2023-01-03 16:40:07 +01:00
|
|
|
[ -n "$(myIpfsHash)" ] \
|
|
|
|
|
&& local myHttpContent="<html><head><title>302 Found</title></head><body><h1>Found</h1>
|
2022-12-27 19:35:43 +01:00
|
|
|
<p>The document is <a href=\"ipfs/$(myIpfsHash)\">here</a> in IPFS.</p></body></html>" \
|
2022-12-28 23:11:16 +01:00
|
|
|
&& echo "$myHttpContent"
|
2022-12-26 21:43:33 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
myHttpHeader() {
|
2023-01-03 16:40:07 +01:00
|
|
|
[ -n "$(myIpfsHash)" ] \
|
|
|
|
|
&& local myHttpHeader="HTTP/1.0 302 Found
|
2022-12-26 21:43:33 +01:00
|
|
|
Content-Type: text/html; charset=UTF-8
|
|
|
|
|
Content-Length: $(myHttpContent |wc -c)
|
|
|
|
|
Date: $(date -R)
|
2022-12-27 19:35:43 +01:00
|
|
|
Location: ipfs/$(myIpfsHash)
|
2022-12-29 14:51:05 +01:00
|
|
|
Server: and" \
|
2023-01-03 16:40:07 +01:00
|
|
|
&& [ -n "$(myIpfsKey)" ] && myHttpHeader="${myHttpHeader}
|
2022-12-27 19:35:43 +01:00
|
|
|
set-cookie: AND=$(myIpfsKey); expires=$(date -R -d "+1 month"); path=/; domain=.$(myDomainName); Secure; SameSite=lax"
|
2022-12-28 23:11:16 +01:00
|
|
|
[ -n "$myHttpHeader" ] && echo "$myHttpHeader"
|
2022-12-26 21:43:33 +01:00
|
|
|
}
|
|
|
|
|
|
2022-12-27 19:35:43 +01:00
|
|
|
myHome() {
|
2023-01-03 16:40:07 +01:00
|
|
|
local myHome=$(cd ~ && pwd -P)
|
|
|
|
|
[ -n "$myHome" ] && echo "$myHome"
|
2022-12-27 19:35:43 +01:00
|
|
|
}
|
|
|
|
|
|
2022-12-26 21:43:33 +01:00
|
|
|
myHostName() {
|
2023-01-03 16:40:07 +01:00
|
|
|
local myHostName=$(hostname |sed 's/\.'"$(myDomainName)"'$//')
|
|
|
|
|
[ -n "$(myDomainName)" ] && myHostName="${myHostName}.$(myDomainName)"
|
|
|
|
|
[ -n "$myHostName" ] && echo "$myHostName"
|
2022-12-26 21:43:33 +01:00
|
|
|
}
|
|
|
|
|
|
2023-01-15 16:10:15 +01:00
|
|
|
myHName() {
|
|
|
|
|
local myHName=$(hostname -s)
|
|
|
|
|
[ -n "$myHName" ] && echo "$myHName"
|
|
|
|
|
}
|
|
|
|
|
|
2023-05-06 02:54:37 +02:00
|
|
|
zIp() {
|
2024-02-09 16:28:24 +01:00
|
|
|
zipit=$(cat ~/.zen/♥Box 2>/dev/null | head -n 1 )
|
|
|
|
|
[ -n "$zipit" ] && echo "$zipit" || false
|
2023-05-06 02:54:37 +02:00
|
|
|
}
|
|
|
|
|
|
2024-01-07 12:23:05 +01:00
|
|
|
UPlanetSharedSecret() {
|
|
|
|
|
UPlanetSharedSecret=$(cat ~/.zen/UPlanetSharedSecret 2>/dev/null | head -n 1 )
|
|
|
|
|
[ -n "$UPlanetSharedSecret" ] && echo "$UPlanetSharedSecret" || false
|
|
|
|
|
}
|
|
|
|
|
|
2022-12-26 21:43:33 +01:00
|
|
|
myIp() {
|
2023-01-03 16:40:07 +01:00
|
|
|
local myIp=$(hostname -I | awk '{print $1}' | head -n 1)
|
2023-05-06 02:54:37 +02:00
|
|
|
local myZip=$(zIp)
|
2023-05-06 03:15:09 +02:00
|
|
|
[ -n "$myZip" ] && echo "$myZip" && exit 0
|
2023-01-03 16:40:07 +01:00
|
|
|
[ -n "$myIp" ] && echo "$myIp" || echo "127.0.0.1"
|
2022-12-26 21:43:33 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
myIpfs() {
|
2023-01-03 16:40:07 +01:00
|
|
|
[ -n "$(myIpfsHash)" ] \
|
2023-01-15 17:40:52 +01:00
|
|
|
&& local myIpfs="${myIPFSGW}/ipfs/$(myIpfsHash)" \
|
2023-01-03 16:40:07 +01:00
|
|
|
&& echo "$myIpfs"
|
2022-12-26 21:43:33 +01:00
|
|
|
}
|
|
|
|
|
|
2022-12-27 19:35:43 +01:00
|
|
|
myIpfsApi() {
|
2023-10-23 15:06:58 +02:00
|
|
|
ipfs --timeout 10s --api "$(cat "$(myHome)"/.ipfs/api)" swarm peers >/dev/null 2>&1 \
|
2023-01-03 16:40:07 +01:00
|
|
|
&& local myIpfsApi=$(cat "$(myHome)"/.ipfs/api)
|
|
|
|
|
[ -n "$myIpfsApi" ] && echo "$myIpfsApi"
|
2022-12-29 14:51:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
myIpfsApiGw() {
|
2023-01-03 16:40:07 +01:00
|
|
|
[ -n "$isLAN" ] \
|
|
|
|
|
&& local myIpfsApiGw="http://ipfs.localhost:5001" \
|
|
|
|
|
|| local myIpfsApiGw="https://ipfs.$(myHostName)/api"
|
|
|
|
|
[ -n "$myIpfsApiGw" ] && echo "$myIpfsApiGw"
|
2022-12-29 14:51:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
myIpfsBootstrapNode() {
|
2023-01-03 16:40:07 +01:00
|
|
|
[ -n "$(myIpfsBootstrapNodes)" ] \
|
|
|
|
|
&& local myIpfsBootstrapNode=$(myIpfsBootstrapNodes | shuf | head -1)
|
|
|
|
|
[ -n "$myIpfsBootstrapNode" ] && echo "$myIpfsBootstrapNode"
|
2022-12-29 14:51:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
myIpfsBootstrapNodes() {
|
2023-01-03 16:40:07 +01:00
|
|
|
[ -f "$(myAstroPath)/A_boostrap_nodes.txt" ] \
|
|
|
|
|
&& local myIpfsBootstrapNodes=$(awk -F/ '$6 != "" {print}' "$(myAstroPath)/A_boostrap_nodes.txt")
|
|
|
|
|
[ -n "$myIpfsBootstrapNodes" ] && echo "$myIpfsBootstrapNodes"
|
2022-12-29 14:51:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
myIpfsGw() {
|
2023-01-03 16:40:07 +01:00
|
|
|
[ -f "$(myAstroPath)/A_boostrap_nodes.txt" ] \
|
2024-04-14 17:37:53 +02:00
|
|
|
&& local myIpfsGw=$(head -n2 "$(myAstroPath)/A_boostrap_nodes.txt" | tail -n 1 | xargs | cut -d ' ' -f 2)
|
2023-01-03 16:40:07 +01:00
|
|
|
[ -n "$myIpfsGw" ] && echo "$myIpfsGw"
|
2022-12-29 14:51:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
myIpfsHash() {
|
2023-01-03 16:40:07 +01:00
|
|
|
[ -f "$(myPath)"/localhost/latest ] \
|
|
|
|
|
&& local myIpfsHash=$(cat "$(myPath)"/localhost/latest) \
|
|
|
|
|
|| local myIpfsHash=$(myHtml |ipfs add -q)
|
|
|
|
|
[ ! -f "$(myPath)"/localhost/latest ] \
|
|
|
|
|
&& echo "$myIpfsHash" > "$(myPath)"/localhost/latest
|
|
|
|
|
[ -n "$myIpfsHash" ] && echo "$myIpfsHash"
|
2022-12-26 21:43:33 +01:00
|
|
|
}
|
|
|
|
|
|
2022-12-27 19:35:43 +01:00
|
|
|
myIpfsKey() {
|
2023-01-03 16:40:07 +01:00
|
|
|
local myIpfsKey=$(ipfs --api "$(myIpfsApi)" key list -l | awk '$2 == "self" {print $1}')
|
|
|
|
|
[ -n "$myIpfsKey" ] && echo "$myIpfsKey"
|
2022-12-27 19:35:43 +01:00
|
|
|
}
|
|
|
|
|
|
2022-12-30 01:08:09 +01:00
|
|
|
myIpfsKeyStore() {
|
2023-01-03 16:40:07 +01:00
|
|
|
local myIpfsKeyStore=$(cd "$(myHome)"/.ipfs/keystore && pwd -P)
|
|
|
|
|
[ -n "$myIpfsKeyStore" ] && echo "$myIpfsKeyStore"
|
2022-12-27 19:35:43 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
myIpfsPeerId() {
|
2023-01-03 16:40:07 +01:00
|
|
|
local myIpfsPeerId=$(jq -r .Identity.PeerID "$(myHome)"/.ipfs/config)
|
|
|
|
|
[ -n "$myIpfsPeerId" ] && echo "$myIpfsPeerId"
|
2022-12-27 19:35:43 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
myIpns() {
|
2023-01-03 16:40:07 +01:00
|
|
|
[ -n "$(myIpfsKey)" ] \
|
|
|
|
|
&& local myIpns="${myIPFS}/ipns/$(myIpfsKey)" \
|
|
|
|
|
&& echo "$myIpns"
|
2022-12-26 21:43:33 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
myPath() {
|
2023-01-03 16:40:07 +01:00
|
|
|
local myPath=$(cd ~/.zen/game/players/ && pwd -P)
|
|
|
|
|
[ -n "$myPath" ] && echo "$myPath"
|
2022-12-26 21:43:33 +01:00
|
|
|
}
|
|
|
|
|
|
2022-12-27 19:35:43 +01:00
|
|
|
myPlayer() {
|
2023-01-03 16:40:07 +01:00
|
|
|
local myPlayer=$(cat "$(myPath)"/.current/.player 2>/dev/null)
|
|
|
|
|
[ -n "$myPlayer" ] && echo "$myPlayer"
|
2022-12-28 23:11:16 +01:00
|
|
|
}
|
|
|
|
|
|
2022-12-27 19:35:43 +01:00
|
|
|
myPlayerApi() {
|
2023-01-03 16:40:07 +01:00
|
|
|
ipfs --api "$(cat "$(myPlayerPath)"/.ipfs/api )" swarm peers >/dev/null 2>&1 \
|
|
|
|
|
&& local myPlayerApi=$(cat "$(myPlayerPath)"/.ipfs/api)
|
|
|
|
|
[ -n "$myPlayerApi" ] && echo "$myPlayerApi"
|
2022-12-27 19:35:43 +01:00
|
|
|
}
|
|
|
|
|
|
2022-12-29 14:51:05 +01:00
|
|
|
myPlayerApiGw() {
|
2023-01-03 16:40:07 +01:00
|
|
|
[ -n "$(myReyalp)" ] \
|
|
|
|
|
&& { [ -n "$isLAN" ] \
|
|
|
|
|
&& local myPlayerApiGw="http://ipfs.$(myHostName):5001" \
|
|
|
|
|
|| local myPlayerApiGw="https://ipfs.$(myReyalp).$(myHostName)/api" \
|
|
|
|
|
;}
|
|
|
|
|
[ -n "$myPlayerApiGw" ] && echo "$myPlayerApiGw"
|
2022-12-27 19:35:43 +01:00
|
|
|
}
|
|
|
|
|
|
2022-12-29 14:51:05 +01:00
|
|
|
myPlayerDomain() {
|
2023-01-03 16:40:07 +01:00
|
|
|
echo "$(myPlayer)" | grep "@" >/dev/null \
|
|
|
|
|
&& local myPlayerDomain=$(echo "$(myPlayer)" | awk -F "@" '{print $2}' | Normalize)
|
|
|
|
|
[ -n "$myPlayerDomain" ] && echo "$myPlayerDomain"
|
2022-12-27 19:35:43 +01:00
|
|
|
}
|
|
|
|
|
|
2022-12-30 01:08:09 +01:00
|
|
|
myPlayerFeed() {
|
2023-01-03 16:40:07 +01:00
|
|
|
[ -n "$(myPlayer)" ] \
|
|
|
|
|
&& local myPlayerFeed="$(myPlayer)_feed"
|
|
|
|
|
[ -n "$myPlayerFeed" ] && echo "$myPlayerFeed"
|
2022-12-30 01:08:09 +01:00
|
|
|
}
|
|
|
|
|
|
2022-12-27 19:35:43 +01:00
|
|
|
myPlayerFeedKey() {
|
2023-01-03 16:40:07 +01:00
|
|
|
local myPlayerFeedKey=$(ipfs --api "$(myPlayerApi)" key list -l | awk '$2 == "'"$(myPlayerFeed)"'" {print $1}')
|
|
|
|
|
[ -n "$myPlayerFeedKey" ] && echo "$myPlayerFeedKey"
|
2022-12-27 19:35:43 +01:00
|
|
|
}
|
|
|
|
|
|
2022-12-30 01:08:09 +01:00
|
|
|
myPlayerFeedKeyFile() {
|
2023-01-03 16:40:07 +01:00
|
|
|
local myPlayerFeedKeyFile="$(myIpfsKeyStore)/key_$(myPlayerFeed | Base32Normalize)"
|
|
|
|
|
[ -f "$myPlayerFeedKeyFile" ] && echo "$myPlayerFeedKeyFile"
|
2022-12-30 01:08:09 +01:00
|
|
|
}
|
|
|
|
|
|
2022-12-27 19:35:43 +01:00
|
|
|
myPlayerG1Pub() {
|
2023-01-03 16:40:07 +01:00
|
|
|
local myPlayerG1Pub=$(cat "$(myPlayerPath)"/.g1pub 2>/dev/null)
|
|
|
|
|
[ -n "$myPlayerG1Pub" ] && echo "$myPlayerG1Pub"
|
2022-12-27 19:35:43 +01:00
|
|
|
}
|
|
|
|
|
|
2022-12-29 14:51:05 +01:00
|
|
|
myPlayerHome() {
|
2023-01-03 16:40:07 +01:00
|
|
|
echo "$(myPlayer)" | grep "@" >/dev/null \
|
|
|
|
|
&& local myPlayerHome=$(cd "$(dirname "$(myHome)")/$(myPlayer)" && pwd -P)
|
|
|
|
|
[ -n "$myPlayerHome" ] && echo "$myPlayerHome"
|
2022-12-27 19:35:43 +01:00
|
|
|
}
|
|
|
|
|
|
2022-12-30 01:08:09 +01:00
|
|
|
myPlayerHost() {
|
2023-01-03 16:40:07 +01:00
|
|
|
[ -n "$(myReyalp)" ] \
|
|
|
|
|
&& { [ -n "$isLAN" ] \
|
|
|
|
|
&& local myPlayerHost="$(myHostName)" \
|
|
|
|
|
|| local myPlayerHost="$(myReyalp).$(myHostName)" \
|
|
|
|
|
;}
|
|
|
|
|
[ -n "$myPlayerHost" ] && echo "$myPlayerHost"
|
2022-12-30 01:08:09 +01:00
|
|
|
}
|
|
|
|
|
|
2022-12-27 19:35:43 +01:00
|
|
|
myPlayerKey() {
|
2023-01-03 16:40:07 +01:00
|
|
|
local myPlayerKey=$(ipfs --api "$(myPlayerApi)" key list -l | awk '$2 == "'"$(myPlayer)"'" {print $1}')
|
|
|
|
|
[ -n "$myPlayerKey" ] && echo "$myPlayerKey"
|
2022-12-27 19:35:43 +01:00
|
|
|
}
|
|
|
|
|
|
2022-12-30 01:08:09 +01:00
|
|
|
myPlayerKeyFile() {
|
2023-01-03 16:40:07 +01:00
|
|
|
local myPlayerKeyFile="$(myPlayerKeyStore)/key_$(myPlayer | Base32Normalize)"
|
|
|
|
|
[ -f "$myPlayerKeyFile" ] && echo "$myPlayerKeyFile"
|
2022-12-30 01:08:09 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
myPlayerKeyStore() {
|
2023-01-03 16:40:07 +01:00
|
|
|
local myPlayerKeyStore=$(cd "$(myPlayerPath)"/.ipfs/keystore && pwd -P)
|
|
|
|
|
[ -n "$myPlayerKeyStore" ] && echo "$myPlayerKeyStore"
|
2022-12-27 19:35:43 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
myPlayerNs() {
|
2023-01-03 16:40:07 +01:00
|
|
|
local myPlayerNs=$(cat "$(myPlayerPath)"/.playerns 2>/dev/null)
|
|
|
|
|
[ -n "$myPlayerNs" ] && echo "$myPlayerNs"
|
2022-12-27 19:35:43 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
myPlayerPath() {
|
2023-01-03 16:40:07 +01:00
|
|
|
[ -n "$(myPlayer)" ] \
|
|
|
|
|
&& local myPlayerPath=$(cd "$(myPath)"/"$(myPlayer)" && pwd -P)
|
|
|
|
|
[ -n "$myPlayerPath" ] && echo "$myPlayerPath"
|
2022-12-27 19:35:43 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
myPlayerPseudo() {
|
2023-01-03 16:40:07 +01:00
|
|
|
local myPlayerPseudo=$(cat "$(myPlayerPath)"/.pseudo 2>/dev/null)
|
|
|
|
|
[ -n "$myPlayerPseudo" ] && echo "$myPseudo"
|
2022-12-27 19:35:43 +01:00
|
|
|
}
|
|
|
|
|
|
2022-12-29 14:51:05 +01:00
|
|
|
myPlayerUser() {
|
2023-01-03 16:40:07 +01:00
|
|
|
echo "$(myPlayer)" | grep "@" >/dev/null \
|
|
|
|
|
&& local myPlayerUser=$(echo "$(myPlayer)" | awk -F "@" '{print $1}' | Normalize)
|
|
|
|
|
[ -n "$myPlayerUser" ] && echo "$myPlayerUser"
|
2022-12-29 14:51:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
myPlayerUserDomain() {
|
2023-01-03 16:40:07 +01:00
|
|
|
[ -n "$(myPlayerDomain)" ] \
|
|
|
|
|
&& local myPlayerUserDomain="$(myPlayerUser).$(myPlayerDomain)" \
|
|
|
|
|
&& echo "$myPlayerUserDomain"
|
2022-12-29 14:51:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
myReyalp() {
|
2023-01-03 16:40:07 +01:00
|
|
|
[ -n "$(myPlayerDomain)" ] \
|
|
|
|
|
&& local myReyalp="$(myPlayerUser).$(myPlayerDomain)" \
|
|
|
|
|
&& echo "$myReyalp" \
|
|
|
|
|
|| echo "$(myPlayer)"
|
2022-12-29 14:51:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
myReyalpHome() {
|
2023-01-03 16:40:07 +01:00
|
|
|
[ -n "$(myReyalpResuPath)" ] \
|
|
|
|
|
&& local myReyalpHome=$(cd "$(case ${RESU_HOME:-mail} in \
|
|
|
|
|
dns) echo /dns/$(myReyalpResuPath) ;; \
|
|
|
|
|
*) echo /home/$(myReyalpMail) ;; \
|
|
|
|
|
esac)" && pwd -P)
|
|
|
|
|
[ -n "$myReyalpHome" ] && echo "$myReyalpHome"
|
2022-12-29 14:51:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
myReyalpMail() {
|
2023-01-03 16:40:07 +01:00
|
|
|
[ -n "$(myPlayerDomain)" ] \
|
|
|
|
|
&& local myReyalpMail=$(echo "$(myPlayer)" | Normalize)
|
|
|
|
|
[ -n "$myReyalpMail" ] && echo "$myReyalpMail"
|
2022-12-29 14:51:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
myReyalpNiamod() {
|
2023-01-03 16:40:07 +01:00
|
|
|
[ -n "$(myPlayerDomain)" ] \
|
|
|
|
|
&& local myReyalpNiamod=$(echo "$(myPlayerDomain)" | Revert)
|
|
|
|
|
[ -n "$myReyalpNiamod" ] && echo "$myReyalpNiamod"
|
2022-12-29 14:51:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
myReyalpResu() {
|
2023-01-03 16:40:07 +01:00
|
|
|
[ -n "$(myPlayerUser)" ] \
|
|
|
|
|
&& local myReyalpResu=$(echo "$(myPlayerUser)" | Revert)
|
|
|
|
|
[ -n "$myReyalpResu" ] && echo "$myReyalpResu"
|
2022-12-29 14:51:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
myReyalpResuNiamod() {
|
2023-01-03 16:40:07 +01:00
|
|
|
[ -n "$(myReyalpNiamod)" ] \
|
|
|
|
|
&& local myReyalpResuNiamod="$(myReyalpNiamod).$(myReyalpResu)" \
|
|
|
|
|
&& echo "$myReyalpResuNiamod"
|
2022-12-29 14:51:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
myReyalpResuPath() {
|
2023-01-03 16:40:07 +01:00
|
|
|
[ -n "$(myReyalpResuNiamod)" ] \
|
|
|
|
|
&& local myReyalpResuPath=$(echo "$(myReyalpResuNiamod)" | sed 's/\./\//g';)
|
|
|
|
|
[ -n "$myReyalpResuPath" ] && echo "$myReyalpResuPath"
|
2022-12-29 14:51:05 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
myHtml() {
|
2023-01-03 16:40:07 +01:00
|
|
|
local myHtml=$($RUN sed \
|
|
|
|
|
-e "s~http://127.0.0.1:8080~${myIPFS}~g" \
|
2023-09-09 23:53:11 +02:00
|
|
|
-e "s~\"http://127.0.0.1:1234\"~\"${myASTROPORT}\"~g" \
|
2023-05-16 03:20:01 +02:00
|
|
|
-e "s~http://127.0.0.1:33101~http://${myHOST}:33101~g" \
|
2023-01-03 16:40:07 +01:00
|
|
|
-e "s~https://ipfs.copylaradio.com~${myIPFSGW}~g" \
|
2023-09-03 20:27:21 +02:00
|
|
|
-e "s~http://g1billet.localhost:33101~${myG1BILLET}~g" \
|
2023-01-03 16:40:07 +01:00
|
|
|
-e "s~_IPFSNODEID_~${IPFSNODEID}~g" \
|
2023-04-14 17:17:38 +02:00
|
|
|
-e "s~g1billet.localhost~${myIP}~g" \
|
2023-01-03 16:40:07 +01:00
|
|
|
-e "s~_HOSTNAME_~$(hostname)~g" \
|
2023-03-16 14:38:25 +01:00
|
|
|
-e "s~background.000.~background.$(printf '%03d' "$(seq 0 17 |shuf -n 1)").~g" \
|
2022-12-26 23:24:52 +01:00
|
|
|
~/.zen/Astroport.ONE/templates/register.html)
|
2023-01-03 16:40:07 +01:00
|
|
|
[ -z "$isLAN" ] \
|
|
|
|
|
|| myHtml=$($RUN echo "$myHtml" | sed \
|
2022-12-26 23:24:52 +01:00
|
|
|
-e "s~<input type='"'hidden'"' name='"'salt'"' value='"'0'"'>~<input name='"'salt'"' value='"''"'>~g" \
|
|
|
|
|
-e "s~<input type='"'hidden'"' name='"'pepper'"' value='"'0'"'>~<input name='"'pepper'"' value='"''"'>~g")
|
2023-01-03 16:40:07 +01:00
|
|
|
[ -n "$myHtml" ] && echo "$myHtml"
|
2022-12-26 21:43:33 +01:00
|
|
|
}
|
|
|
|
|
|
2023-10-06 15:20:55 +02:00
|
|
|
mySalt() {
|
|
|
|
|
local mySalt=$($RUN sed \
|
|
|
|
|
-e "s~http://127.0.0.1:8080~${myIPFS}~g" \
|
|
|
|
|
-e "s~\"http://127.0.0.1:1234\"~\"${myASTROPORT}\"~g" \
|
2023-10-09 16:50:14 +02:00
|
|
|
-e "s~http://127.0.1.1:1234~${myASTROPORT}~g" \
|
2023-10-06 15:20:55 +02:00
|
|
|
-e "s~http://127.0.0.1:33101~http://${myHOST}:33101~g" \
|
|
|
|
|
-e "s~https://ipfs.copylaradio.com~${myIPFSGW}~g" \
|
|
|
|
|
-e "s~http://g1billet.localhost:33101~${myG1BILLET}~g" \
|
|
|
|
|
-e "s~_IPFSNODEID_~${IPFSNODEID}~g" \
|
|
|
|
|
-e "s~g1billet.localhost~${myIP}~g" \
|
|
|
|
|
-e "s~_HOSTNAME_~$(hostname)~g" \
|
|
|
|
|
-e "s~background.000.~background.$(printf '%03d' "$(seq 0 17 |shuf -n 1)").~g" \
|
|
|
|
|
~/.zen/Astroport.ONE/templates/saltpepper.http)
|
|
|
|
|
[ -z "$isLAN" ] \
|
|
|
|
|
|| mySalt=$($RUN echo "$mySalt" | sed \
|
|
|
|
|
-e "s~<input type='"'hidden'"' name='"'salt'"' value='"'0'"'>~<input name='"'salt'"' value='"''"'>~g" \
|
|
|
|
|
-e "s~<input type='"'hidden'"' name='"'pepper'"' value='"'0'"'>~<input name='"'pepper'"' value='"''"'>~g")
|
|
|
|
|
[ -n "$mySalt" ] && echo "$mySalt"
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
2022-12-26 21:43:33 +01:00
|
|
|
myTs() {
|
2023-01-03 16:40:07 +01:00
|
|
|
local myTs=$(date +%s)
|
|
|
|
|
[ -n "$myTs" ] && echo "$myTs"
|
2022-12-26 21:43:33 +01:00
|
|
|
}
|
|
|
|
|
|
2022-12-29 14:51:05 +01:00
|
|
|
myTube() {
|
2023-01-03 16:40:07 +01:00
|
|
|
[ -f "$(myAstroPath)/A_boostrap_nodes.txt" ] \
|
2024-04-14 17:37:53 +02:00
|
|
|
&& local myTube=$(head -n2 "$(myAstroPath)/A_boostrap_nodes.txt" | tail -n 1 | xargs | cut -d ' ' -f 3)
|
2023-01-03 16:40:07 +01:00
|
|
|
[ -n "$myTube" ] && echo "$myTube"
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
myAstroTube() {
|
|
|
|
|
[ -f "$(myAstroPath)/A_boostrap_nodes.txt" ] \
|
2024-04-14 17:37:53 +02:00
|
|
|
&& local myAstroTube=$(head -n2 "$(myAstroPath)/A_boostrap_nodes.txt" | tail -n 1 | xargs | cut -d ' ' -f 3 | sed "s~ipfs~astroport~g")
|
2023-01-03 16:40:07 +01:00
|
|
|
[ -n "$myAstroTube" ] && echo "$myAstroTube"
|
2022-12-26 21:43:33 +01:00
|
|
|
}
|
|
|
|
|
|
2023-12-05 13:56:36 +01:00
|
|
|
function makecoord() {
|
|
|
|
|
local input="$1"
|
|
|
|
|
|
2024-03-12 17:00:51 +01:00
|
|
|
input=$(echo "${input}" | sed 's/\([0-9]*\.[0-9]\{2\}\).*/\1/') # Ensure has exactly two decimal places
|
|
|
|
|
|
2023-12-05 13:56:36 +01:00
|
|
|
if [[ ${input} =~ ^-?[0-9]+\.[0-9]$ ]]; then
|
|
|
|
|
input="${input}0"
|
2024-03-15 23:03:51 +01:00
|
|
|
elif [[ ${input} =~ ^\.[0-9]+$ ]]; then
|
2024-03-15 22:32:13 +01:00
|
|
|
input="0${input}"
|
2024-03-12 17:00:51 +01:00
|
|
|
elif [[ ${input} =~ ^-?[0-9]+\.$ ]]; then
|
|
|
|
|
input="${input}00"
|
2023-12-05 13:56:36 +01:00
|
|
|
elif [[ ${input} =~ ^-?[0-9]+$ ]]; then
|
|
|
|
|
input="${input}.00"
|
|
|
|
|
fi
|
|
|
|
|
echo "${input}"
|
|
|
|
|
}
|
|
|
|
|
|
2024-02-25 18:30:04 +01:00
|
|
|
# Fonction pour récupérer la météo depuis l'API OpenWeatherMap
|
|
|
|
|
recuperer_meteo() {
|
|
|
|
|
echo "En train de récupérer les données météo..."
|
|
|
|
|
# Récupérer la météo à l'aide de l'API OpenWeatherMap
|
|
|
|
|
ville="Paris" # Vous pouvez modifier la ville ici
|
|
|
|
|
api_key="310103dee4a9d1b716ee27d79f162c7e" # Remplacez YOUR_API_KEY par votre clé API OpenWeatherMap
|
|
|
|
|
url="http://api.openweathermap.org/data/2.5/weather?q=$ville&appid=$api_key&units=metric"
|
|
|
|
|
meteo=$(curl -s $url)
|
|
|
|
|
# Extraire les informations pertinentes de la réponse JSON
|
|
|
|
|
temperature=$(echo $meteo | jq -r '.main.temp')
|
|
|
|
|
description=$(echo $meteo | jq -r '.weather[0].description')
|
|
|
|
|
echo "La météo à $ville : $description, Température: $temperature °C"
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
# my_IPCity # Fonction pour récupérer la géolocalisation à partir de l'adresse IP
|
|
|
|
|
my_IPCity() {
|
|
|
|
|
local ip=$1
|
|
|
|
|
|
|
|
|
|
if [ -z "$ip" ]; then
|
|
|
|
|
ip=$(curl 'https://api.ipify.org?format=json' --silent | jq -r '.ip')
|
|
|
|
|
fi
|
|
|
|
|
|
|
|
|
|
local url="http://ip-api.com/json/$ip"
|
|
|
|
|
local geolocalisation=$(curl -s "$url")
|
|
|
|
|
|
|
|
|
|
local ville=$(echo "$geolocalisation" | jq -r '.city')
|
|
|
|
|
local pays=$(echo "$geolocalisation" | jq -r '.country')
|
|
|
|
|
|
2024-02-25 20:07:49 +01:00
|
|
|
echo "$ville,$pays"
|
2024-02-25 18:30:04 +01:00
|
|
|
}
|
|
|
|
|
|
2022-12-27 19:35:43 +01:00
|
|
|
IPFSNODEID="$(myIpfsPeerId)"
|
2023-01-11 20:18:09 +01:00
|
|
|
[[ ! $MOATS ]] && MOATS="$(myDate)"
|
2022-12-26 23:24:52 +01:00
|
|
|
isLAN="$(isLan)"
|
2023-07-01 21:44:29 +02:00
|
|
|
myIP="$(myIp)" # "127.0.0.1"
|
|
|
|
|
|
2023-07-20 20:55:26 +02:00
|
|
|
## PATCH
|
|
|
|
|
myIP=$(hostname -I | awk '{print $1}' | head -n 1)
|
|
|
|
|
isLAN=$(echo $myIP | grep -E "/(^127\.)|(^192\.168\.)|(^10\.)|(^172\.1[6-9]\.)|(^172\.2[0-9]\.)|(^172\.3[0-1]\.)|(^::1$)|(^[fF][cCdD])/")
|
|
|
|
|
|
2024-02-03 16:42:59 +01:00
|
|
|
myDOMAIN="copylaradio.com"
|
|
|
|
|
|
2024-02-27 20:48:07 +01:00
|
|
|
myASTROPORTW="http://$(hostname).local:1234" #astroport.localhost
|
|
|
|
|
myASTROPORT="http://127.0.0.1:1234" # BE ACCESSIBLE THROUGH LAN
|
|
|
|
|
myAPI="http://127.0.0.1:5001"
|
2022-12-29 14:51:05 +01:00
|
|
|
myDATA="https://data.gchange.fr"
|
|
|
|
|
myGCHANGE="https://www.gchange.fr"
|
2023-06-30 01:46:15 +02:00
|
|
|
myCESIUM="https://g1.data.e-is.pro"
|
2024-02-27 20:48:07 +01:00
|
|
|
myG1BILLET="http://127.0.0.1:33101"
|
2023-01-15 16:10:15 +01:00
|
|
|
myHOST="$(myHostName)"
|
2023-07-01 21:44:29 +02:00
|
|
|
|
2024-01-10 17:05:01 +01:00
|
|
|
myIPFSW="http://$(hostname).local:8080" ## ipfs.localhost (IP works better in LAN deported desktop), but not in docker.
|
2024-02-27 20:48:07 +01:00
|
|
|
myIPFS="http://127.0.0.1:8080" ## ipfs.localhost (IP works better in LAN deported desktop), but not in docker.
|
2022-12-29 14:51:05 +01:00
|
|
|
myIPFSGW="$(myIpfsGw)"
|
|
|
|
|
myTUBE="$(myTube)"
|
2023-01-03 16:40:07 +01:00
|
|
|
myASTROTUBE="https://$(myAstroTube)"
|
|
|
|
|
|
2022-12-26 21:43:33 +01:00
|
|
|
## WAN STATION
|
2022-12-26 23:24:52 +01:00
|
|
|
[ -z "$isLAN" ] \
|
2023-04-11 13:45:35 +02:00
|
|
|
&& myASTROPORT="https://astroport.$(myDomainName)" \
|
2024-03-05 03:02:34 +01:00
|
|
|
&& myAPI="https://ipfs.$(myHostName)/5001" \
|
2022-12-26 23:24:52 +01:00
|
|
|
&& myIPFS="https://ipfs.$(myDomainName)" \
|
2023-01-13 19:10:32 +01:00
|
|
|
&& myHOST="astroport.$(myHostName)" \
|
2024-02-03 16:42:59 +01:00
|
|
|
&& myG1BILLET="https://libra.${myDOMAIN}" \
|
|
|
|
|
&& myIPFSW="https://ipfs.${myDOMAIN}" \
|
2023-01-13 19:10:32 +01:00
|
|
|
|| true
|
2023-05-06 02:35:06 +02:00
|
|
|
|
2023-09-09 23:53:11 +02:00
|
|
|
## zIP :: PUT YOUR Internet Box IP IN ~/.zen/♥Box ( Forward PORTS 8080 4001 5001 33101 33102 1234 12345 45780 to 45790 )
|
2023-05-06 03:39:28 +02:00
|
|
|
[ -n "$(zIp)" ] \
|
2023-05-06 03:43:31 +02:00
|
|
|
&& myASTROPORT="http://$(zIp):1234" \
|
2023-05-06 03:39:28 +02:00
|
|
|
&& myAPI="http://$(zIp):5001" \
|
|
|
|
|
&& myIPFS="http://$(zIp):8080" \
|
|
|
|
|
&& myHOST="$(zIp)" \
|
|
|
|
|
&& myG1BILLET="http://$(zIp):33101" \
|
2023-05-06 03:43:31 +02:00
|
|
|
&& myIP="$(zIp)" \
|
2023-05-10 15:04:10 +02:00
|
|
|
&& myIPFSGW="$(zIp):8080" \
|
2023-05-06 02:35:06 +02:00
|
|
|
|| true
|
2023-07-10 11:51:36 +02:00
|
|
|
|
|
|
|
|
|
|
|
|
|
###
|
2024-01-11 16:59:16 +01:00
|
|
|
if [[ $XDG_SESSION_TYPE == 'x11' || $XDG_SESSION_TYPE == 'wayland' ]]; then
|
2023-07-10 11:51:36 +02:00
|
|
|
# GET SCREEN DIMENSIONS
|
|
|
|
|
screen=$(xdpyinfo | grep dimensions | sed -r 's/^[^0-9]*([0-9]+x[0-9]+).*$/\1/')
|
|
|
|
|
width=$(echo $screen | cut -d 'x' -f 1)
|
|
|
|
|
height=$(echo $screen | cut -d 'x' -f 2)
|
|
|
|
|
large=$((width-300))
|
|
|
|
|
haut=$((height-200))
|
|
|
|
|
###
|
|
|
|
|
fi
|
2023-11-12 20:12:51 +01:00
|
|
|
|
2024-02-15 01:47:40 +01:00
|
|
|
## https://git.p2p.legal/qo-op/OSM2IPFS
|
2024-04-20 00:42:21 +02:00
|
|
|
EARTHCID="/ipfs/QmcPxZAYw7YeMS5SqsCZPSo2NNnofRmneRPNJd4Vrudy9r"
|
2024-02-03 15:18:29 +01:00
|
|
|
FLIPPERCID="${EARTHCID}/coinflip" ### EASTER EGG
|
2023-11-17 15:50:08 +01:00
|
|
|
|
2024-02-15 16:07:01 +01:00
|
|
|
###########################
|
|
|
|
|
## VISIO ROOM APP
|
2024-02-15 01:47:40 +01:00
|
|
|
## https://github.com/steveseguin/vdo.ninja
|
|
|
|
|
VDONINJA="/ipfs/QmdGGAukDepUiH63YgnMsvb4BySNPqM2bLz81bx4rjqCJD"
|
2024-02-15 16:07:01 +01:00
|
|
|
###########################
|
|
|
|
|
## CESIUM APP
|
|
|
|
|
## https://cesium.app
|
|
|
|
|
CESIUMIPFS="/ipfs/QmXex8PTnQehx4dELrDYuZ2t5ag85crYCBxm3fcTjVWo2k"
|
2024-02-16 19:16:40 +01:00
|
|
|
HACKGIPFS="/ipfs/Qmemnmd9V4WQEQF1wjKomeBJSuvAoqFBS7Hoq4sBDxvV2F"
|
2024-02-15 16:07:01 +01:00
|
|
|
|
|
|
|
|
##########################
|
|
|
|
|
myUPLANET="${myIPFS}${EARTHCID}" ## UPLANET ENTRANCE
|
|
|
|
|
myLIBRA="https://ipfs.asycn.io" ## READ ONLY IPFS GATEWAY
|
|
|
|
|
##########################
|
|
|
|
|
## UPLANETNAME can be set ~/.zen/UPlanetSharedSecret
|
2024-01-07 12:23:05 +01:00
|
|
|
[ -n "$(UPlanetSharedSecret)" ] \
|
|
|
|
|
&& UPLANETNAME="$(UPlanetSharedSecret)" \
|
|
|
|
|
|| UPLANETNAME=""
|
2024-01-10 17:05:01 +01:00
|
|
|
|
2024-02-15 16:07:01 +01:00
|
|
|
## DETECT SWARM.KEY
|
|
|
|
|
## ACTIVATE SECONDARY PRIVATE IPFS SWARM
|
|
|
|
|
|
2024-02-10 12:55:29 +01:00
|
|
|
## DEV support@qo-op.com Unamed UPlanet World Keeper.
|
2024-03-15 20:56:30 +01:00
|
|
|
[[ ${UPLANETNAME} == "" ]] \
|
|
|
|
|
&& WORLDG1PUB=$(cat ~/.zen/game/players/.current/.g1pub 2>/dev/null) ## PLAYER ONE G1PUB
|
|
|
|
|
|
|
|
|
|
[[ ${WORLDG1PUB} == "" ]] \
|
|
|
|
|
&& WORLDG1PUB="2L8vaYixCf97DMT8SistvQFeBj7vb6RQL7tvwyiv1XVH"
|
2024-01-10 17:05:01 +01:00
|
|
|
## when UPlanetSharedSecret is set.
|
|
|
|
|
## All TW wallet are created with 1 G1 "primal transaction"
|
|
|
|
|
## making UPlanet blockchains secured.
|
|
|
|
|
########################################
|
2024-02-03 15:18:29 +01:00
|
|
|
TODATE=$(date -d "today 13:00" '+%Y-%m-%d')
|
|
|
|
|
YESTERDATE=$(date -d "yesterday 13:00" '+%Y-%m-%d')
|
2024-02-11 13:38:33 +01:00
|
|
|
DEMAINDATE=$(date -d "tomorrow 13:00" '+%Y-%m-%d')
|
2024-03-31 19:43:49 +02:00
|
|
|
|
|
|
|
|
## WRITE THE DIFFERENT REWARDS
|
|
|
|
|
G1LEVEL1="3.1"
|
