CM – Tether (USDT) la devise qui reste stable malgré la baisse du Bitcoin (BTC)

Les pièces stables sont-elles menacées ? Contrairement au Bitcoin (BTC) et aux autres crypto-monnaies, dont les valeurs fluctuent dans le temps, les pièces stables restent stables. Mais cette stabilité ne pouvait être qu’un problème. Dans le cas de Tether (USDT), cela semble être bien cru. L’offre est restée stable depuis début juin, selon The Block.

Au cours des 17 premiers mois de juin, l’offre d’USDT est restée constante à une valeur de 64,25 milliards de dollars américains. Il y avait donc peu (ou pas) de demande de stablecoin sur le marché. De plus, cette stabilité inquiète de nombreux professionnels car elle suggère que peu de personnes sont au courant de l’existence de ce stablecoin.

Cependant, le directeur technique de Tether, M. Paolo Ardonio, trouve une explication parfaitement rationnelle à cette stabilité. Il pense que la demande d’USDT a été affectée en raison de la « baisse significative » de l’intérêt ouvert des utilisateurs de crypto-monnaie pour les contrats à terme Bitcoin. Il souligne que l’USDT est le « stablecoin dominant » sur la plupart des échanges de dérivés de crypto-monnaie.

Techniquement, on pourrait penser que le raisonnement de M. Ardomio n’est pas faux. En fait, il y a eu une baisse notable de l’intérêt ouvert pour les contrats à terme Bitcoin depuis la mi-mai en raison des fluctuations de Bitcoin. Le 18 juin, il y avait une baisse de plus de 13 milliards de dollars.

Qu’est-ce que l’intérêt ouvert ? Il indique la valeur des contrats dérivés en cours qui doivent être réglés. Une augmentation de ces taux signifie que l’argent circule bien sur le marché. La baisse notable de cet intérêt va de pair avec la tendance baissière du marché des crypto-monnaies, notamment du Bitcoin. En fait, la crypto mère est passée d’un sommet de 64 000 $ à la mi-avril à 36 000 $ à la mi-juin.

Revenons à la déclaration de M. Ardonio selon laquelle l’USDT est le  » stablecoin dominant « . Là aussi, il a bien sûr raison, car malgré la baisse de sa part depuis la fin de l’année dernière, l’USDT détient une part de marché de plus de 60%.

Si vous regardez le marché dans son ensemble, vous pouvez voir que les pièces stables, malgré leur stabilité, font les 100 milliards de dollars – ont dépassé la barre de l’inventaire. L’offre totale de pièces stables est actuellement d’environ 106 milliards de dollars. C’est la première fois que cela se produit.

Les analystes aiment être tentés par l’idée que les pièces stables ont un bel avenir. En effet, ils présentent plusieurs avantages. Par exemple, ils permettent des transferts plus rapides qu’avec de l’argent fiduciaire.

En fin de compte, l’avenir des pièces stables n’est pas aussi sombre qu’on pourrait le penser. Au contraire, selon de nombreux experts, de beaux jours arrivent. Mais jusqu’à ces jours-ci, la demande de tether (USDT) n’a jamais été aussi faible. En fait, l’offre est restée à 64,25 milliards de dollars.

var intérêts = [];
const addInterest = ($, intérêts) => {
Intérêts = $ (document) .data (‘tct-ws-interests’);
if (interests.map (e => e.name) .indexOf (interest.name) === -1) {
interessen.push (intérêt);
}
$ (Document) .data (‘tct-ws-interests’, intérêts);
} ;
const envoyer = (ws, json) => {
// console.log (‘enverra json’, json, ws);
ws.send (JSON.stringify (json));
} ;

/ **
* Outil WS de base
* @Constructeur
* /
Outil de fonction () {
this.interestTools = {};

this.id = null;

this.ws = null;

/ ********************
* CARACTÉRISTIQUES DE BASE WS *
******************** /

/ **
* enregistrer
* une fois appelé, l’enregistrement est la première action pour démarrer la connexion ws
* /
this.register = (ws, $) => {
this.ws = ws;
$ = $;
envoyer (this.ws, {method: ‘register’,});
} ;
/ **
* Enregistré
* Le serveur envoie une réponse au client qui inclut le
* fonction enregistrée avec l’ID dans les données JSON
* /
this.registered = (id) => {
this.id = id;
this.registerInteressen ()
} ;

/ **
* Mettre à jour
* Mettez à jour la connexion au serveur pour vous assurer que nous ne sommes pas supprimés des futures réponses
* Appelé toutes les minutes
* /
this.refresh = () => {
// console.log (‘demandera la mise à jour’);
envoyer (this.ws, {
Méthode : ‘Mettre à jour’,
Données: {
id : this.id,
},
});
} ;

/ *********************************
* INTÉRÊTS SPÉCIFIQUES FONCTIONS WS *
********************************* /

/ **
* createInterestTool
* Retournera l’outil JS si vous êtes intéressé
* Chaîne d’intérêt @param (‘top winner’, …)
* @return objet | faux
* /
this.createInterestTool = (intérêt) => {
laisser outil = null;
échanger (intérêt) {
CAS du gagnant INTERESTS.top :
Affaire INTERESSEN.top.Loser :
Cas INTERESTS.top.unusualVolume :
Cas INTERESSEN.top.newAth :
Cas INTERESSEN.top.newAtl :
Outil = nouveau sommet (dies. $, intérêt);
Interruption;
Cas INTERESTS.ticker.table :
Outil = nouveau TableTicker (dies. $);
Interruption;
}
si (! outil) {
retour faux ;
}
Outil de récupération ;
} ;

/ **
* enregistrer l’intérêt
* Dites au serveur que nous sommes intéressés par ces données sur &
* Créer et enregistrer un outil d’intérêts
*
* Chaîne d’intérêt @param (‘top winner’, …)
* /
this.registerInterest = (intérêt) => {
let InterestTool = this.createInterestTool (intérêt);
if (interestTool! == false) {
const websocketData = {
Méthode : « Enregistrer les intérêts »,
Données: {
id : this.id,
Intérêt,
}
} ;
envoyer (this.ws, websocketData);
this.interestTools [Intérêt] = InterestTool;
}
} ;

/ **
* enregistrer les intérêts
* Obtenez des intérêts à partir de $ (‘Document’). Données (‘tct-ws-interests’)
* et l’envoyer au serveur
* /
this.registerInteressen = () => {
const $ = ceci. $ ;
// $ (document) .data (‘tct-ws-interests’) =’ {[{Nom : ‘Top-Winner’, Durée : ‘7d’}, {Nom : ‘Table-Ticker’,}, {. ..}]}
let interessen = $ (document) .data (‘tct-ws-interests’);
si (intérêts) {
Interests.forEach ((intérêt, indice, objet) => {
let InterestTool = this.createInterestTool (Interest.name);
if (interestTool! == false) {
// est valide, économisez les intérêts
this.interestTools [Interest.name] = InterestTool;
} autrement {
// invalide, supprimer l’intérêt
Objet.Épissage (index, 1);
}
});
si (intérêts.longueur> 0) {
// envoyer des intérêts valides au serveur
envoyer (this.ws, {method : ‘register-multi-interests’, data : {id : this.id, Interests}})
}
}
} ;

/ **
* Mettre à jour
* Le serveur a envoyé une mise à jour, nous demandons votre bon intérêt
* /
this.update = (données) => {
const specificData = getSpecificDataByInterest (data.interest, data);
this.interestTools [data.interest] .update (specificData);
} ;

this.updateTicker = (données) => {
// const specificData = getSpecificDataByInterest (data.interest, data);
// console.log (‘this.interestTools’, this.interestTools);
// this.interestTools [data.interest] .update (specificData);
this.interestTools [‘tickers’] updateTicker (données);

} ;

const getSpecificDataByInterest = (intérêt, données) => {
échanger (intérêt) {
CAS du gagnant INTERESTS.top :
Affaire INTERESSEN.top.Loser :
Cas INTERESTS.top.unusualVolume :
Cas INTERESSEN.top.newAth :
Cas INTERESSEN.top.newAtl :
Renvoie data.cryptos;
Cas INTERESTS.ticker.table :
Retour data.ticker;
}
} ;

/ **
* Mise à jourMulti
* Fonction de prise Web
* Le serveur a envoyé une mise à jour multiple
* /
this.updateMulti = (données) => {
for (const [Interest, InterestData] de Object.entries (data.interests)) {
IntérêtDonnées.Intérêt = Intérêt ;
this.update (IntérêtDonnées);
}
envoyer (this.ws, {method : ‘Interests-received’, data : {id : this.id}} );
} ;
/ **
* Créer plusieurs
* Le serveur a envoyé une création multiple
* /
this.createMulti = (données) => {
// si (données.intérêt ===  »)
// @ todo faire la mise à jour plusieurs fois
} ;

}

const websocketUrl = ‘wss: //data-api.thecointribune.fr/ws’;
// const websocketUrl = ‘ws: // localhost: 4100’;

const INTÉRÊTS = {
dessus: {
Gagnant : ‘Top Gagnant’, –
Perdant : « Top perdant », –
volume inhabituel : ‘top-unusual-volume’,
newAth : ‘top-new-ath’,
newAtl: ‘top-neu-atl’,
},
Téléscripteur : {
Tableau : « Ticker »
},
} ;

const-tool = nouvel outil ();

const initWS = (ws) => {
ws = zéro ;
renvoyer un nouveau WebSocket (websocketUrl);
} ;
jQuery (document) .data (‘tct-ws-interests’, []);

jQuery (document) .ready (fonction ($) {
$ (‘. Cointribune-chargé’). cacher ();

Tenter {
soit ws = initWS (zéro);
ws.onerror = fonction (s) {
// out.innerHTML = e;
console.error (‘Erreur :’, e);

} ;
ws.onclose = fonction (s) {
// console.log (‘closed:’, e);
setTimeout (() => {
ws = initWS (ws);
}, 5000);

} ;
ws.onopen = fonction () {
// console.log (‘connecté’);
tool.register (ws, $);
setInterval (() => {
Outil.Mise à jour ();
}, 60 000);
} ;
ws.onmessage = fonction (message) {
const json = JSON.parse (message.data);
// console.log (‘Message’, json);
Commutateur (json.method) {
Cas ‘enregistré’ :
tool.registered (json.data.id);
Interruption;
Cas ‘mise à jour-multi’ :
tool.updateMulti (json.data);
Interruption;
Cas « registre-multi-intérêts-est-vide » :
tool.registerInteressen ();
Interruption;
Cas « multi-intérêts enregistrés » :
$ (‘. Cointribune-Chargement’). cacher ();
$ (‘. Cointribune-chargé’). Spectacle ();
tool.updateMulti (json.data);
Interruption;
Cas ‘rafraîchi’ :
Interruption;
Cas ‘Mise à jour’ :
// console.log (‘json.data’, json.data);
tool.update (json.data);
Interruption;
Cas ‘ticker mis à jour’ :
tool.updateTicker (json.data);
Interruption;
}
} ;
} attraper (err) {
console.error (‘impossible de se connecter au serveur ws’, err);
}

});

/ **
* Outil supérieur
* @param $ jQuery
* Chaîne de type @param ‘Top Winner’ || « Top perdant »
* @Constructeur
* /
Fonction Haut ($, Type) {
this.table = $ (`# $ {type}`);
this.tbody = $ (`# $ {type} tbody`);

/ **
*
* @param pourcentage de changement {nombre}
* @return {chaîne}
* /
const getPercentChangeClass = (percentChange) => PercentChange <0 ? 'négatif positif';

const getUrlName = (crypto) => `$ {crypto.name.replaceAll (/ s / g, ‘-‘).toLowerCase ()} – $ {crypto.symbol.toLowerCase ()}`;
const getCGUrl = (crypto) => «  https://www.coingecko.com/en/coins/$$crypto.name.replaceAll (/ → s . Danemark / g, ‘-‘). en minuscule ()} `;

Affichage de la fonction () {

const addOperator = (valeur) => valeur> 0 ? `$ {Valeur}` : valeur ;
// const reverseString = (str) => str.toString (). diviser («  »). sens inverse (). rejoindre («  »);
// const addNumberDelimiter = (str, delimiter) => {
// const [nombre, décimal] = str.toString().split (« . »);
// let result = reverseString (reverseString (nombre) .replace (/ ([^ .] {3}) / g, `$ 1`)). garniture (). remplacer (/ s / g, `$ {separator}`);
// si (décimal) {
// résultat = `. $ {décimal} `;
//}
// renvoie le résultat ;
//} ;
/ **
*
* @param {chaîne} chaîne
* @return {chaîne}
* /
const removeExtraZero = (str) => str.replace (/ ^ ([ d .] * [^ 0]) 0 * $ /, ‘$ 1’);
// this.volume24h = (volume24h) => `$ $ {addNumberDelimiter (volume24h, ‘,’)}`;
this.volume24h = (volume24h) => nouveau Intl.NumberFormat (‘en-US’, {style: ‘currency’, Currency: ‘USD’, minimumFractionDigits: 0}).format (volume24h);
this.percentChange24h = (percentChange) => `$ {addOperator (removeExtraZero (percentChange.toFixed (4)))}%`;
this.ticker = (image, icône, nom, url) => {
const isUrl = (texte) => URL ? ` $ {text}` : text ;
/ **
* Je l’ai fait parce que wp (je pense que c’est wp) encode src attr quand il est reconnu
* @typ {chaîne}
* /
laissez imageSrc = `src`;
imageSrc = `= » $ {image} « `;
Renvoie isUrl (` $ {symbol}`);
} ;
// this.price = (price) => `$ $ {addNumberDelimiter (removeExtraZero (price.toFixed (4)), ‘,’)}`;
this.price = (price) => nouveau format Intl.NumberFormat (‘en-US’, {style: ‘currency’, Currency: ‘USD’}) format (removeExtraZero (price.toFixed (4)));
}