NXTER MAGAZINE

Codage pour la Plateforme de la Cryptomonnaie Nxt #1

Codage pour la Plateforme de la Cryptomonnaie Nxt #1: Configuration

Mise en place du fichier de configuration

Le fichier de configuration de Nxt est un outil important pour mettre en place le fonctionnement de Nxt sur votre ordinateur.

Avec le fichier de configuration vous pouvez configurer votre Nxt pour utiliser le SSL, Mise en place du NXT sur un Raspberry PI ou configurer votre Nxt pour le développement, comme l’exemple utilisé ici.

Le Fichier de Configuration

Vous avez déjà un fichier de configuration, vous pouvez voir tous les paramètres actuels

nxt/conf/nxt-default.properties

Pour les objectifs de développement, créez un fichier dans nxt / conf / et nommez-le nxt.properties

Copiez le code ci-dessous dans votre fichier nxt.properties.

# Enable Cross Origin Filter for the API server.
nxt.apiServerCORS=true

# Enable Cross Origin Filter for NRS user interface server.
nxt.uiServerCORS=true

Si vous souhaitez développer sur testnet, ajoutez

# Never unlock your real accounts on testnet! Use separate accounts for testing only.
# When using testnet, all custom port settings will be ignored,
# and hardcoded ports of 6874 (peer networking), 6875 (UI) and 6876 (API) will be used.
nxt.isTestnet=true

Au lieu d’héberger Nxt vous-même, vous pouvez décider d’obtenir des informations à partir de n’importe quel autre nœud du réseau Nxt. Dans mes exemples, je vais utiliser http://localhost:7876. C’est lorsque vous utilisez Nxt sur votre ordinateur personnel ou serveur. Une liste des autres noeuds que vous pouvez utiliser pour afficher des données sur votre site Web ou accéder à Nxt peut être trouvée sur les sites Web qui offrent un accès au réseau Nxt comme: PeerExplorer.com

Au lieu d’utiliser http://localhost:7876, vous pourriez par exemple entrer une adresse IP comme http://x.x.x.x:7876 pour obtenir des informations à partir d’un noeud au lieu du localhost.

Lorsque vous souhaitez contrôler le nœud, la version qu’il exécute, les informations qui peuvent être consultées ou le nombre d’ensembles de données de l’API, il est logique que votre propre nœud fonctionne avec la configuration que vous préférez.

Si vous cherchez plus d’informations sur l’API, la documentation ou plus je recommande le Nxt Wiki.

Découvrez également comment créer votre propre nœud public ou héberger votre nœud avec Amazon AWS.

Par: Tosch

Voir aussi : Codage pour la Plateforme de la Cryptomonnaie Nxt #2: Premier Pas

Codage pour la Plateforme de la Cryptomonnaie NXT # 2

Codage pour la Plateforme de la Cryptomonnaie NXT # 2 : Premier Pas

À propos de Nxt

Avez-vous jamais voulu participer à un domaine financier avec votre logiciel sans prendre de grands risques et avoir un accès facile et anonyme? Avez-vous essayé d’accéder à des systèmes monétaires et d’obtenir des données transparentes à partir d’Échanges d’actifs, Marchés, Nuages de données? Nxt est un logiciel Peer-to-Peer de Chaîne de Blocs qui permet un service financier global que vous pouvez utiliser sur votre serveur ou votre ordinateur. Pas d’enregistrement, pas de bureaucratie.

Qu’est-ce que la Chaine de Blocs Nxt apporte à la table qui est nouveau?

Dans les systèmes bancaires traditionnels, vous rencontrez des banques de confiance qui gèrent votre argent et vos avoirs en tant que service. Mais quand vous voulez accéder à votre argent, ils ne le rendent pas facile pour vous. Surtout en tant que développeur, il n’y a aucune chance que vous pouvez récupérer les données des exploitations ou avoir accès aux données historiques de Wall Street gratuitement.

Avec le système de blocs Peer-to-Peer, Nxt a commencé à construire un écosystème entier autour d’une gestion de données sécurisée et transparente. Vous pouvez démarrer vos propres services, créer des devises, créer des actifs et les échanger, un marché intégré, un nuage de données et bien plus encore!

Débutons

Avec les lignes de code suivantes, j’aimerais démontrer comment obtenir un premier accès aux données Nxt, puis vous montrer comment écrire sur le bloc et obtenir des données prêtes pour votre page d’accueil.

De là, vous pourriez commencer à construire tout ce que vous pouvez imaginer autour de  »Blockchain »,  »Account Ledger » et des outils en vedette.

Si vous ne l’avez pas encore installé, voir ici comment installer et configurer Nxt pour commencer à se développer.

“Bonjour le Monde”

Dans cet exemple, nous choisissons la configuration la plus simple qui vous permet d’afficher les données de la Chaine de Blocs sur votre site Web.

Nous allons utiliser JQuery pour simplifier l’appel de l’API mais vous pouvez obtenir les mêmes résultats avec d’autres structures ou un peu plus de code.

Créons le premier fichier html, nous l’appelons transaction.html et y insérons le code suivant.

<!DOCTYPE html>
<html>
<body>
  <div id="result"></div>
  <script src="https://code.jquery.com/jquery-2.2.0.min.js"></script>
  <script>
      $.getJSON('http://localhost:7876/nxt', {"requestType": "getTransaction", "transaction": "8520011591947303971"}, function(request) 
      {
        $("#result").html(request.attachment.message);
      });
  </script>
</body>
</html>

Nxt a une documentation API très utile qui est adressable sur http://localhost:7876/test. Nous utilisons l’appel getTransaction dans cet exemple, que vous pouvez également tester sur la page API.

Lorsque vous exécutez le script ci-dessus, vous devriez voir la réponse suivante dans votre navigateur:

Bonjour le monde
Félicitations à vous! Vous avez reçu les premières données de la chaîne de blocs

Mais que s’est-il passé ici?

Tout d’abord, nous avons utilisé l’appel API « getTransaction » qui nous permet d’avoir un regard détaillé sur les informations de toute transaction qui est sur la Chaine de Blocs. Jetez un oeil à votre console de navigateur pour voir l’ensemble des informations de transaction.

Dans le code ci-dessus nous avons accédé à la sortie du marché de la réponse JSON Nxt API nous a donné. Ici vous pouvez voir l’objet entier renvoyé par l’API.

{
                            "senderPublicKey": "7969c2ec61af9bedd3260c9b2cd4a292ba01ecbc2901a86851fa6c68208b0766",
                            "signature": "d13ad29034e56ae58b7f1eee4979cd6dffff38a7a26094c86103e431faf0bd06084be1e42534efd8e76b8a59c12630b52d851c571a25bc54af9ebdb56ca6df14",
                            "feeNQT": "100000000",
                            "requestProcessingTime": 0,
                            "type": 0,
                            "fullHash": "23bc3ae466293d7690b426173445e5b87423ea798b1d9c2913feda5d0d52a5b6",
                            "version": 1,
                            "phased": false,
                            "ecBlockId": "15499194118663359315",
                            "signatureHash": "9ea43451798a0144bd6cea58cbbba479c24ed7cdc29a4077a9aeb49a063498a7",
                            "attachment": {
                                "version.Message": 1,
                                "messageIsText": true,
                                "message": "Hello World",
                                "version.OrdinaryPayment": 0
                            },
                            "senderRS": "NXT-5RB8-KJD3-BT3B-E2QWW",
                            "subtype": 0,
                            "amountNQT": "10000000000",
                            "sender": "14876164227056393510",
                            "recipientRS": "NXT-P439-YVBD-VUEQ-A3S2T",
                            "recipient": "10124938546868029479",
                            "ecBlockHeight": 614717,
                            "deadline": 1440,
                            "transaction": "8520011591947303971",
                            "timestamp": 67508752,
                            "height": 2147483647
                        }

Pourquoi utiliser getJSON?

Comme nous utilisons la fonction getJSON de JQuery, nous n’avons plus besoin d’analyser le JSON et d’accéder directement aux retours de l’API JSON Nxt. Lorsque vous utilisez un appel ajax ou une méthode get de JQuery, vous pouvez avoir besoin de JSON.parse (request) pour accéder à l’objet.

La transaction 8520011591947303971 nous avons accédé dans le code, était une transaction que j’ai envoyée précédemment. Chaque transaction dans Nxt est transparente dont tout le monde peut voir. Jetez un oeil au ‘JSON retourné à partir de l’API Nxt et avec votre script à portée de main, vous pouvez déjà afficher toutes les informations qui vous intéressent dans toute transaction.

Remplacez request.attachment.message (avec, par exemple, request.accountRS) pour afficher l’ID du compte et continuer à ajouter une belle vue aux informations.

Dans les articles suivants je vais vous montrer comment soumettre les premières données sur la chaîne de blocs. Comment récupérer les données de l’actif, calculer les prix et voir les ordres en cours.

Atteindre pour les étoiles

Nxt vous accompagne dans la création de logiciels qui permettent de négocier sur un espace global dans un réseau peer-to-peer où chaque participant est égal au pouvoir. Commencez à construire des choses extraordinaires avec Nxt.

Voir aussi : http://test.nxter.org/developers

Codage pour la Plateforme de la Cryptomonnaie NXT # 3: Sortie de l’Échange des Atouts

Codage pour la Plateforme de la Cryptomonnaie NXT # 3: Sortie de l’Échange des Atouts

L’étoile des Chaînes de Blocs

Bienvenue sur le troisième article sur le codage avec NXT. Dans les articles précédents, je vous ai montré comment configurer votre fichier de configuration Nxt pour développer facilement avec JavaScript et comment obtenir la première sortie des données de la Chaîne de Blocs. Dans cet article, je voudrais continuer avec l’un des outils les plus utilisés dans Nxt: L’Échange des Atouts ou bien aussi connu sous le nom  »Asset Exchange ».

Qu’est-ce que l’Asset Exchange?

L’Asset Exchange est un Exchange basé sur la technologie Blockchain. Tout le monde peut créer ses propres jetons d’actifs sur la Chaîne de Blocs. L’actif peut représenter n’importe quoi, qu’il s’agisse de services financiers, financement participatif, le soutien d’un site Web, les adhésions, les produits de base ou d’autres choses que vous pouvez imaginer.

L’avantage d’utiliser un jeton d’actifs sur le Nxt Blockchain est que vous disposez directement d’un public mondial, car l’Internet et les monnaies numériques comme Nxt ou Bitcoin ne connaissent pas les frontières. Un autre avantage que je voudrais souligner est que personne n’a besoin d’un compte bancaire réel; Une fois que vous détenez votre première monnaie virtuelle, il est facile de passer d’une dénomination à l’autre et parce que la technologie Blockchain est accessible à tout le monde, il n’y a aucune difficulté à les déplacer de personne à personne. (Vous devez quand même vous informer sur votre juridiction locale et si la création d’un tel actif est autorisée.)

Comment récupérer les premières Données d’Actifs

Pour obtenir votre première Donnée, nous choisissons d’abord un Actif; Vous pouvez voir une liste de tous les actifs Nxt existants ici: Mynxt.info Asset List

Une fois que vous avez choisi un actif, vous pouvez voir l’ID de l’actif dans le coin supérieur gauche. Nous aurons besoin de cet ID pour obtenir des données d’un actif. J’ai choisi le SuperNET Asset dans cet exemple car il est fréquemment échangé et a beaucoup de données historiques que nous pouvons regarder.

N’oubliez pas que vous devez avoir votre instance de Nxt en cours d’exécution sur votre système pour suivre le reste de ce didacticiel.

Tout d’abord, examinons les métadonnées d’un actif. Le script suivant vous donnera la sortie de l’Asset Setup original. Comme toujours, je vous recommande la page http://localhost:7876/test lors de la recherche des appels API. Sur cette page, vous pouvez voir quels appels sont destinés à recevoir des données (GET) ou à soumettre des données (POST) à la Chaîne de Blocs. Nous commencerons par les requêtes GET et l’appel getAsset.

Vous pouvez utiliser ce script pour afficher des informations sur les actifs de votre site Web, pour connaître les actifs qui ont été créés à court ou à long terme ou simplement pour une liste personnelle d’actifs et leurs fonctions.

<!DOCTYPE html>
<html>
<head>
<!-- Latest compiled and minified CSS -->
<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/css/bootstrap.min.css" integrity="sha384-1q8mTJOASx8j1Au+a5WDVnPi2lkFfwwEAa8hDDdjZlpLegxhjVME1fgjWPGmkzs7" crossorigin="anonymous">
</head>
<body>
  <h2>Asset Data</h2>
  <table class="table table-striped">
    <thead>
      <tr>
        <th>Key</th>
        <th>Data</th>
      </tr>
    </thead>
    <tbody id="result">
      
    </tbody>
  </table>
<script src="https://code.jquery.com/jquery-2.2.0.min.js"></script>
<!-- Latest compiled and minified JavaScript -->
<script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/js/bootstrap.min.js" integrity="sha384-0mSbJDEHialfmuBBQP6A4Qrprq5OVfW37PRR3j5ELqxss1yVqOtnepnHVP9aJ7xS" crossorigin="anonymous"></script>

  <script>
      $.getJSON('http://localhost:7876/nxt', {"requestType": "getAsset", "asset": "12071612744977229797", "includeCounts": "true"}, function(request) {
        var rows;
        $.each(request, function(key, data) {
          rows += '<tr>';
          rows += '<td>'+key+'</td>';
          rows += '<td>'+data+'</td>';
          rows += '</tr>';
        });
        $("#result").html(rows);
      });
  </script>
</body>
</html>

The code above will display a table on your HTML page with the following information:

programming-nxt-3-1

Je veux prendre un certain temps pour vous apprendre quelques abréviations dans Nxt à ce point:

Vous voyez deux variables « initialQuantityQNT » et « quantityQNT« . QNT signifie « Quantité« , la valeurinitiale est configurée par le créateur d’actifs au début. Comme certains des actifs peuvent être supprimés, la « quantityQNT » nous montre combien d’actifs existent pour le moment. Nous avons également besoin de la variable «décimales». L’actif que nous considérons a 4 décimales, ce qui signifie que le nombre d’actifs figurant dans le tableau doit être divisé par 10 000 (4 zéros) pour obtenir le nombre réel. L’Actif ci-dessus se traduirait par une quantité d’actifs actuellement de 816 061,0000.

Le compte est le compte Nxt numérique du créateur d’actifs et le accountRS le même identificateur de compte en format Reed-Solomon (RS)

Le numberOfTrades, numberOfTransfers et numberOfAccounts sont calculés au moment où vous exécutez l’appel.

Vous pouvez raccourcir l’appel de l’API « getAsset » en laissant de côté « includeCounts »: « true » à l’appel $ .getJSON ci-dessus. Par conséquent, vous ne recevrez pas le nombre de détenteurs d’actifs, de transferts et de transactions.

Les Commandes de Demande et d’Offres

Après avoir pris connaissance des détails de l’actif et de l’obtention des métadonnées, nous voulons savoir s’il existe des commandes d’achat ou d’offres pour cet actif et à quel prix l’actif est actuellement négocié. Les méthodes d’utilisation des calculs à partir de quantités ou de décimales Nxt ne sont pas toujours optimales. Parfois, je choisis les méthodes de ce tutoriel pour être plus compréhensible plutôt que optimale. Habituellement, je recommande de faire des calculs avec les numéros d’origine de l’API. Vous n’aurez pas à traiter avec des décimales et c’est là que la plupart des erreurs résultent. Les appels API que nous utilisons pour cela est getAskOrders et getBidOrders. Encore une fois, nous avons besoin de l’ID de l’actif pour obtenir les ordres de demande et d’offres pour l’actif qui vous intéresse. En outre, nous allons raccourcir la sortie en ajoutant les paramètres firstIndex et lastIndex. Voici le code permettant de récupérer les commandes Ask et Bid de l’actif SuperNET:

<!DOCTYPE html>
<html>
<head>
<!-- Latest compiled and minified CSS -->
<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/css/bootstrap.min.css" integrity="sha384-1q8mTJOASx8j1Au+a5WDVnPi2lkFfwwEAa8hDDdjZlpLegxhjVME1fgjWPGmkzs7" crossorigin="anonymous">
</head>
<body>
  <div class="col-md-6">
    <h2>Ask Orders</h2>
    <table class="table table-striped">
      <thead>
        <tr>
          <th>Account</th>
          <th>Quantity</th>
          <th>Price</th>
          <th>Total</th>
        </tr>
      </thead>
      <tbody id="askTable">
      
      </tbody>
    </table>
  </div>
  <div class="col-md-6">
    <h2>Bid Orders</h2>
    <table class="table table-striped">
      <thead>
        <tr>
          <th>Account</th>
          <th>Quantity</th>
          <th>Price</th>
          <th>Total</th>
        </tr>
      </thead>
      <tbody id="bidTable">
      
      </tbody>
    </table>
  
  </div>
  <script src="https://code.jquery.com/jquery-2.2.0.min.js"></script>
  <!-- Latest compiled and minified JavaScript -->
  <script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/js/bootstrap.min.js" integrity="sha384-0mSbJDEHialfmuBBQP6A4Qrprq5OVfW37PRR3j5ELqxss1yVqOtnepnHVP9aJ7xS" crossorigin="anonymous"></script>
  <script>
  
  $.getJSON('http://localhost:7876/nxt', {"requestType": "getAsset", "asset": "12071612744977229797"}, function(request) {
    var decimals = request.decimals;
    var NQTdivider = 8 - decimals;
    
    
      $.getJSON('http://localhost:7876/nxt', {"requestType": "getAskOrders", "asset": "12071612744977229797", "firstIndex": 0, "lastIndex": 4}, function(requestAskOrders) {
        var rows;
        $.each(requestAskOrders.askOrders, function(key, data) {
        
          var quantity = data.quantityQNT / Math.pow(10, decimals);
          var accountRS = data.accountRS;
          var priceNXT = data.priceNQT / Math.pow(10,NQTdivider);
          var total = quantity * priceNXT;
          
          rows += '<tr>';
          rows += '<td>'+accountRS+'</td>';
          rows += '<td>'+quantity+'</td>';
          rows += '<td>'+priceNXT+'</td>';
          rows += '<td>'+total+'</td>';
          rows += '</tr>';
        });
        $("#askTable").html(rows);
      });
        
      
      $.getJSON('http://localhost:7876/nxt', {"requestType": "getBidOrders", "asset": "12071612744977229797", "firstIndex": 0, "lastIndex": 4}, function(requestBidOrders) {
        var rows;
          $.each(requestBidOrders.bidOrders, function(key, data) {
          
            var quantity = data.quantityQNT / Math.pow(10, decimals);
            var accountRS = data.accountRS;
            var priceNXT = data.priceNQT / Math.pow(10,NQTdivider);
            var total = quantity * priceNXT;
            
            rows += '<tr>';
            rows += '<td>'+accountRS+'</td>';
            rows += '<td>'+quantity+'</td>';
            rows += '<td>'+priceNXT+'</td>';
            rows += '<td>'+total+'</td>';
            rows += '</tr>';
        });
        $("#bidTable").html(rows);
      });
    
    
    });
      
  </script>
</body>
</html>

With this call you are expected to receive 2 tables on your HTML page:

programming-nxt-3-2

Le script ci-dessus peut être utilisé pour afficher les prix actuels et les offres pour un actif sur votre site Web, et de montrer l’ensemble du carnet de commandes d’un actif. En outre, vous pouvez l’utiliser et analyser les tendances. Comme vous avez en plus les comptes pour toutes les offres et demande, vous pouvez analyser les offres et demande le montant des comptes qui sont des transactions sur la plate-forme.

Cette fois, nous avons dû faire plus de requêtes $ .getJSON pour obtenir les informations que nous voulons. Tout d’abord, nous avons besoin des décimales de l’actif pour faire le calcul de la quantité comme mentionné avec le premier appel. Deuxièmement, nous voulons obtenir à la fois: Les commandes de Demande et Offres. Cela nécessite une requête pour chacun des appels API.

Nous voyons également une nouvelle variable qui doit être expliquée. « PriceNQT » est le prix d’un Actif par QuantitéQNT.

Le prix sur l’API est affiché dans priceNQT par QuantityQNT. Alors, qu’est-ce que NQT et quelle est la différence avec QNT? NQT se réfère à NXTQuant, le plus petit nombre que nous avons dans NXT, qui est 0,00000001 NXT (8 décimales). Nous devons également prendre en compte les décimales, que nous devons multiplier à nouveau pour obtenir le prix par actif réel. J’ai utilisé la variable var NQTdivider = 8 – décimales; Pour obtenir le nombre de puissance dont nous avons besoin pour diviser la Quantité par et obtenir le prix actuel en NXT par Quantité.

J’espère que vous avez apprécié ce troisième volet de « Codage la plateforme de la cryptomonnaie NXT ». Dans l’article suivant, je vais couvrir les données historiques et les informations du compte. Si vous avez des questions, n’hésitez pas à me contacter par email ou mon compte Forum Nxt.

 

Codage pour la Plateforme de la Cryptomonnaie NXT #4: Historique des Actifs

Dans le dernier sujet, je vous ai montré comment récupérer des données de base sur les actifs de Nxt Asset Exchange.

Dans cet article, je veux couvrir comment recevoir l’historique des Échanges.
L’appel API que nous utilisons ici est « “getTrades”.

Historique des Échanges

Les historiques des Échanges peuvent être soit à partir de n’importe quel compte ou de tout actif, nous allons continuer comme nous l’avons fait avant et obtenir les derniers métiers de l’actif SuperNET.

Encore une fois nous utiliserons les paramètres firstIndex et lastIndex pour récupérer seulement les 10 dernières entrées. Si vous voulez obtenir plus d’échanges, il suffit de changer lastIndex à un nombre plus élevé ou d’effacer firstIndex et lastIndex complètement.

Si vous effacez firstIndex et lastIndex, il est possible que vous obteniez un nombre limité d’entrées – cela peut être configuré dans votre fichier de configuration Nxt. Jetez un oeil à la propriété: nxt.maxAPIRecords = 100 et configurez-la selon vos besoins (juste quand vous travaillez sans un mot de passe administrateur).

Maintenant, revenons au code.

<!DOCTYPE html>
<html>
<head>
<!-- Latest compiled and minified CSS -->
<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/css/bootstrap.min.css" integrity="sha384-1q8mTJOASx8j1Au+a5WDVnPi2lkFfwwEAa8hDDdjZlpLegxhjVME1fgjWPGmkzs7" crossorigin="anonymous">
</head>
<body>
  <div class="col-md-12">
    <h2>Trade History</h2>
    <table class="table table-striped">
      <thead>
        <tr>
          <th>Date</th>
          <th>Type</th>
          <th>Quantity</th>
          <th>Price</th>
          <th>Total</th>
          <th>Buyer</th>
          <th>Seller</th>
        </tr>
      </thead>
      <tbody id="tradeHistory">
      
      </tbody>
    </table>
  </div>
  <script src="https://code.jquery.com/jquery-2.2.0.min.js"></script>
  <!-- Latest compiled and minified JavaScript -->
  <script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/js/bootstrap.min.js" integrity="sha384-0mSbJDEHialfmuBBQP6A4Qrprq5OVfW37PRR3j5ELqxss1yVqOtnepnHVP9aJ7xS" crossorigin="anonymous"></script>
  <script>
  
  $.getJSON('http://localhost:7876/nxt', {"requestType": "getTrades", "asset": "12071612744977229797", "firstIndex": 0, "lastIndex": 9, "includeAssetInfo": "true"}, function(request) {
        
    var trades = request.trades;
    var rows;
    var nxtTime = 1385294400;
    $.each(trades, function(key, data) {
      var decimals = data.decimals;
      var NQT_QNT = 8 - decimals;
      var quantityQNT = data.quantityQNT / Math.pow(10, decimals);
      var priceNQT = data.priceNQT / Math.pow(10, NQT_QNT);
      var total = data.quantityQNT * data.priceNQT / Math.pow(10,8);
      var NxtTimestamp = (+data.timestamp + +nxtTime) * 1000;
      var d = new Date(NxtTimestamp);
      rows += '<tr>';
        rows += '<td>'+d.toDateString()+'</td>';
        rows += '<td>'+data.tradeType+'</td>';
        rows += '<td>'+quantityQNT+'</td>';
        rows += '<td>'+priceNQT+'</td>';
        rows += '<td>'+total+'</td>';
        rows += '<td>'+data.buyerRS+'</td>';
        rows += '<td>'+data.sellerRS+'</td>';
      rows += '</tr>';
    });
    $("#tradeHistory").html(rows);
    
  });
      
  </script>
</body>
</html>

Pour la requête API, comme indiqué ci-dessus, nous avons limité la réponse en définissant firstIndex et lastIndex à 10 entrées. En outre, l’includeAssetInfo défini à  »true » montrera la décimale pour l’actif et le nom de l’actif. Cela rendra l’appel un peu plus lent, mais surtout lorsque nous regardons plus d’un actif un ajout très utile.

Au lieu d’inclure includeAssetInfo, nous pourrions faire un appel getAsset pour recevoir ces paramètres (quand on regarde juste un atout cela pourrait être recommandé). Mais quand vous regardez un dernier compte des métiers au lieu d’un actif, cela peut économiser beaucoup de travail et de temps.

Les calculs les plus importants à mentionner pour ce script sont l’horodatage Nxt, la quantité et le prix. Ils sont calculés comme déjà expliqué ci-dessus.

Horodatage NXT

Nxt a son propre horodatage. Nxt a été lancé le 24 Novembre 2013 12:00 am. Dans Nxt cela serait timestamp 0. Dans Javascript c’est 1385294400 (comme Javascript a commencé le 1 janvier 1970, 00:00:00), mais JavaScript utilise des Milisecondes, donc nous devons multiplier par 1000 pour y arriver. En conséquence, nous devons ajouter l’horodatage donné de Nxt à 1385294400 et ajouter les milisecondes pour récupérer l’horodatage en JavaScript.

L’analyse des données historiques vous donnera beaucoup d’informations sur la fréquence de négociation et combien de comptes ont été en négociation d’un actif. Plus de comptes sont impliqués dans le commerce, mieux un actif est réparti entre les commerçants, ce qui est généralement bon signe. Bien sûr, vous devez être conscient que vous ne connaissez pas l’origine des comptes. Il est possible qu’une personne crée plusieurs comptes et négocie à partir de tous ces comptes. L’actif semble être négocié par d’autres parties, ce qui semble bénéfique pour le propriétaire de l’actif, d’autre part les gens pourraient créer plusieurs comptes pour suivre les différents types d’exploitations. Dans de nombreux cas, il est logique pour un utilisateur d’avoir plus d’un seul compte.

Le script ci-dessus vous montrera une table comme celle-ci:

programming-nxt-4-1

Information du Compte

Comme vous le savez déjà, une Chaîne de Blocs est entièrement transparente; Vous pouvez voir toute les transactions dans le réseau et tous les actifs d’un compte. Il vous permet toujours d’écrire des messages chiffrés, qui ne peuvent être lus par personne, sauf la personne qui détient la phrase secrète de l’expéditeur ou du destinataire.
La prochaine étape pour vous est de savoir comment créer une interface agréable pour afficher les comptes. Toutes les étapes nécessaires pour y arriver sont expliquées ici.

L’appel API nécessaire pour obtenir les informations du compte est getAccount. Vous pouvez également utiliser getAccountAssets pour surveiller les avoirs, mais getAccount vous montrera tous les avoirs d’un compte.

Un indice: comme dans l’API getTrades, vous pouvez décider d’inclure des informations précises avec includeLessors, includeAssets, includeCurrencies ou includeEffectiveBalance.

Bon développement avec Nxt! Dans l’article suivant, nous allons explorer la création de transactions et plus de détails sur sur la Blockchain. Si vous avez des questions, n’hésitez pas à me contacter par email ou mon compte Forum Nxt.

Voir aussi : http://test.nxter.org/developers

Codage pour la Plateforme de la Cryptomonnaie NXT #5: Transactions sur la Blockchain Nxt

La Blockchain Nxt

La Blockchain Nxt est le cœur de Nxt. Chaque Transaction effectuée est enregistrée sur la Blockchain. La Blockchain est une base de données décentralisée qui est enregistrée sur votre ordinateur. Pour éviter le spam, pour chaque transaction, vous devez payer des frais dans la devise native, qui sera NXT pour nous en utilisant la Blockchain Nxt. Dans les articles précédents, j’ai montré comment  installer et configurer votre logiciel Nxt ainsi que la façon de lire les données, cette fois nous écrivons des données sur le Blockchain, en commençant par un exemple simple. Tout au long de l’article, je veux me concentrer sur les outils que vous pouvez utiliser lors de la création des Transactions sur Nxt.

Envoyer des Nxt

La création d’une transaction sur Nxt est très similaire à la lecture des données de la Blockchain; Il ya quelques sujets que nous devons couvrir avant de créer notre première transaction. Pour créer une transaction, nous avons besoin d’un compte Nxt et de certains NXT, afin de payer les frais de la Blockchain. Alors, laissez-nous vous connecter à Nxt et créer notre premier compte.

Créer un compte NXT

Pour avoir un compte Nxt sécurisé, vous avez besoin d’une phrase secrète forte. En travaillant avec les monnaies virtuelles, nous utilisons la phrase de passe au lieu du mot de passe, cela décrit la forte entropie et devrait être plus sûr qu’un mot de passe régulier. Lorsque vous utilisez le client officiel Nxt, vous pouvez utiliser la fonction de création de phrase de passe implémentée, qui vous donnera une phrase secrète qui contient 12 mots.

Créer votre propre Phrase de Passe

Vous pouvez également créer votre propre phrase secrète, assurez-vous qu’elle contient suffisamment de caractères et d’entropie. Pour générer une phrase de passe, il est recommandé d’utiliser des logiciels tels que KeePass, LastPass, Dashlane ou des outils en ligne comme PasswordsGenerator.net ou Fourmilab.ch.

Générateur de Phrase de Passe Nxt

Lorsque vous exécutez Nxt sur http://localhost:7876 vous obtiendrez au client, un clic sur le lien citant

DON’T HAVE AN ACCOUNT? CLICK HERE TO CREATE ONE!

vous amènera donc au générateur de mots de passe. Ensuite (ou avec votre phrase de passe créée par vous-même), vous pouvez vous connecter à votre compte. Si vous n’avez pas de NXT encore, la méthode la plus rapide est quand vous avez déjà quelques monnaies virtuelles comme Bitcoin, Litecoin, Ethereum ou autres. Vous pouvez les échanger via Shapeshift ou acheter vos pièces sur un autre échange et de les transférer à votre portefeuille.

Dans les prochaines étapes, nous utilisons votre phrase de passe pour signer et diffuser des transactions. Votre phrase de passe peut aussi être considérée comme votre clé privée.

Créer la Transaction

Avec une phrase secrète sécurisée, nous pouvons maintenant examiner le code de création d’une transaction d’envoi-NXT. Nous envoyons 1 NXT à un destinataire, que vous voyez dans le code et le modifiez là pour un autre destinataire. Insérez votre mot de passe dans le code suivant et exécutez-le pour créer la transaction.

<!DOCTYPE html>
<html>
<head>
<!-- Latest compiled and minified CSS -->
<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/css/bootstrap.min.css" integrity="sha384-1q8mTJOASx8j1Au+a5WDVnPi2lkFfwwEAa8hDDdjZlpLegxhjVME1fgjWPGmkzs7" crossorigin="anonymous">
</head>
<body>
    <div class="col-md-12">
        <h2>Outgoing Transaction JSON</h2>
        
    <div class="well" style="word-wrap:break-word;" id="transactionJSON"></div>
    </div>
  <script src="https://code.jquery.com/jquery-2.2.0.min.js"></script>
  <!-- Latest compiled and minified JavaScript -->
  <script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/js/bootstrap.min.js" integrity="sha384-0mSbJDEHialfmuBBQP6A4Qrprq5OVfW37PRR3j5ELqxss1yVqOtnepnHVP9aJ7xS" crossorigin="anonymous"></script>
  <script>
  
  $.post('http://localhost:7876/nxt', {"requestType": "sendMoney", "recipient": "NXT-5RB8-KJD3-BT3B-E2QWW", "amountNQT": "100000000", "secretPhrase": "YourPassphrase", "feeNQT": "0", "deadline": "800", "broadcast": false}, function(request) {
  
        var response = JSON.parse(request);
        $("#transactionJSON").html(JSON.stringify( response , null, 4));
  
      });
      
  </script>
</body>
</html>

Ce script crée une transaction sendMoney. Comme vous le voyez, nous avons modifié la fonction utilisée dans les articles précédents $.getJSON à $.post. Lors de la création de transactions, il est nécessaire de passer au format POST au lieu des requêtes GET comme pour les fonctions précédentes. Pour plus d’informations sur les détails de l’API, consultez http://localhost:7876/test?requestType=sendMoney

La sortie que vous voyez sur la page contient diverses informations, la variable feeNQT a été rempli avec les informations correctes, vous pouvez vérifier combien les frais sont pour la transaction que vous avez créé. Vous voyez l’ensemble transactionJSON vous avez inséré en format JSON et vous recevez la transaction transactionBytes. La transactionBytes intègre toutes les informations de transaction que vous avez dans la transactionJSON.

La transaction créée ci-dessus ne sera pas diffusée sur le réseau encore, parce que nous avons mis « broadcast »: false dans notre objet. Lorsque cette valeur est définie à  »True », la transaction sera diffusée et vous coûtera 1 NXT. Comme vous pouvez le voir, nous n’avons pas besoin de beaucoup de variables pour créer notre première transaction.

La recette d’une transaction est la suivante:

requestType sendMoney
Recipient Vous pouvez utiliser soit le format RS, NXT-XXX-XXX-XXX-XXXX ou le format de compte numérique
AmountNQT Le montant que vous voulez envoyer doit être calculé en NQT, le plus petit nombre en NXT (1 NXT / 10⁸ = 1 NQT)
SecretPhrase Votre phrase de passe secrète
FeeNQT Placez 0 si vous voulez que le serveur calcule les frais minimums pour vous
Deadline mesurée en minutes, lorsque la transaction expire
Broadcast La diffusion false ne diffusera pas et créera simplement la transaction. Défini sur true, la transaction sera diffusée à d’autres pairs et vous coûtera NXT

Transaction de Diffusion

Maintenant que nous savons comment créer une transaction sendMoney qui n’a pas encore été diffusée, nous pouvons utiliser un script semblable à celui ci-dessus pour diffuser la transaction. Pour le rendre plus compréhensible, je prolonge le script ci-dessus avec un bouton qui prend la transaction précédemment créée et le transfère au réseau lors de la soumission du bouton. En effet, lors de l’exécution du script, vous avez votre premier portefeuille interactif Nxt (petit, pas encore sécurisé!).

<!DOCTYPE html>
<html>
<head>
<!-- Latest compiled and minified CSS -->
<link rel="stylesheet" href="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/css/bootstrap.min.css" integrity="sha384-1q8mTJOASx8j1Au+a5WDVnPi2lkFfwwEAa8hDDdjZlpLegxhjVME1fgjWPGmkzs7" crossorigin="anonymous">
</head>
<body>
    <div class="col-md-12">
        <h2>Outgoing Transaction JSON</h2>
        
    <div class="well" style="word-wrap:break-word;" id="transactionJSON"></div>
    <button class="btn btn-primary" id="submitTransaction">Submit this transaction</button>
   
    <hr>
    <div id="broadcastedTransaction"></div>
    </div>
  <script src="https://code.jquery.com/jquery-2.2.0.min.js"></script>
  <!-- Latest compiled and minified JavaScript -->
  <script src="https://maxcdn.bootstrapcdn.com/bootstrap/3.3.6/js/bootstrap.min.js" integrity="sha384-0mSbJDEHialfmuBBQP6A4Qrprq5OVfW37PRR3j5ELqxss1yVqOtnepnHVP9aJ7xS" crossorigin="anonymous"></script>
  <script>
  
  $.post('http://localhost:7876/nxt', {"requestType": "sendMoney", "recipient": "NXT-5RB8-KJD3-BT3B-E2QWW", "amountNQT": "100000000", "secretPhrase": "YourPassphrase", "feeNQT": "0", "deadline": "800", "broadcast": false}, function(request) {
  
        var response = JSON.parse(request);
        $("#transactionJSON").html(JSON.stringify( response , null, 4));
        $("#submitTransaction").on("click", function() {
          $.post('http://localhost:7876/nxt', {"requestType": "broadcastTransaction", "transactionBytes": response.transactionBytes}, function(broadcast) {
            var broadcastResponse = JSON.parse(broadcast);
            $("#broadcastedTransaction").html(JSON.stringify( broadcastResponse , null, 4));
          }); 
        });
      });
  </script>
</body>
</html>

Le chargement du site chargera directement la transaction non encore diffusée. Comme la fonction de clic de bouton est imbriquée dans le premier appel, elle peut accéder aux données de la transaction non diffusée. Pour diffuser la transaction, nous utilisons la recette suivante

requestType broadcastTransaction
TransactionBytes La transactionBytes que nous avons créée avec la fonction déclarée précédente.

Avec ces quelques lignes de code, nous pouvons créer une transaction et la diffuser. Pourtant, nous définissons toujours toutes les variables directement dans le code. Dans les articles suivants, je vais vous montrer comment ajouter des messages chiffrés à une transaction et comment obtenir ces données à partir d’une entrée utilisateur que vous avez sur la page. Nous aurons un examen plus approfondi de l’échelonnement et de l’élagage des transactions.

Voir aussi: http://test.nxter.org/developers

Par Tosch

La bière, le pari et la Chaîne-de-Blocs NXT

Supposons que vous ayez un cercle d’amis que vous rencontrez dans un bar sportif pour boire de la bière, regarder des sports et faire des paris. Vous pouvez faire des paris sur la chaîne-de-blocs NXT et avoir une application Python de base l’automatiser pour vous.

Dans mon premier article j’ai présenté les bases d’une chaîne de blocs. Comme nous l’avons appris, la proposition de valeur la plus importante de la chaîne de blocs est l’immutabilité des données soumises dans les transactions enregistrées en blocs, à partir desquelles une chaîne de blocs est construite.

Aujourd’hui, je veux vous montrer comment construire une application de paris simple mais entièrement fonctionnel en python. Pour l’application de pari que je présente, l’immutabilité des données peut être nécessaire, mais dans le cas où un pari doit être annulé, l’application peut être modifiée pour tenir compte de cette fonctionnalité supplémentaire.

Conditions préalables:
NRS (logiciel de référence Nxt) 1.10.2:
https://bitbucket.org/JeanLucPicard/nxt/downloads/, Python 3 (ou Python 2 avec la moindre modification). Une bière ou deux (facultatif).

Logique d’Application

Un utilisateur soumet un pari (transfère tout montant de pièces de monnaie NXT) au compte de pari et ajoute un attachement public non chiffré. Dans la pièce jointe il doit écrire l’id de la mise, un deux-points et un nombre indiquant son choix dans le pari correspondant. Prenons un exemple: le bar des sports exécute un pari que l’équipe de football gagne. Ils attribuent un ID à ce jeu, disons «30».

Les choix sont les suivants:
« 1 » – équipe à domicile gagne. «2» – l’autre équipe gagne. « 3 » – cravate.

Pour parier sur la victoire de l’équipe locale, le joueur doit soumettre une transaction de n’importe quelle quantité de NXT, et joindre un message public non chiffré (pour  »auditabilité ») avec le contenu: 30: 1

Lorsque le moment est venu, l’hôte de pari exécute l’application pour trouver les gagnants et traiter les paiements. L’hôte peut prendre un petit supplément pour le service.

Implémentation

Le serveur Nxt écoute les requêtes sur le port 7876. Si vous l’exécutez sur la même machine que votre code python par défaut, vous devez soumettre des requêtes à http://127.0.0.1:7876/nxt

Pour notre application, nous devrons importer quelques modules et écrire la fonction pour soumettre des requêtes qui seront utilisées à plusieurs reprises dans l’application.

import sys, json, re
def sendQuery(Query):
  from urllib import parse, request
  params = parse.urlencode(Query)
  headers = {"Content-type": "application/x-www-form-urlencoded", 
"Accept": "text/plain"}
  req = request.Request("http://127.0.0.1:7876/nxt", 
params.encode('utf-8'))
  response = request.urlopen(req)
  return response.read()
	
myAccount = "NXT-AAAA-BBBB-CCCC-DDDDD"
totalAmount = 0
serviceFee = 0.05
players = []
secretPhrase = "bla bla bla''

La fonction renvoie une chaîne JSON à décoder, avec les transactions et les pièces jointes à analyser. De plus, quelques variables sont initialisées.

Ensuite, nous devons interroger le compte de pari pour récupérer toutes les transactions entrantes.
Il s’agit de la requête que vous pouvez envoyer au serveur NXT pour l’exécuter:

Query = {'requestType': 'getBlockchainTransactions', 
'account': myAccount, 'type': '0', 'subtype': '0', 'executedOnly': 'true'}

Décoder JSON et le charger sur une variable pour un traitement ultérieur.

output = sendQuery(Query)
data = json.loads(output.decode('utf-8'))

Comme nous avons maintenant toutes les données, nous parcourons la liste et rejetons certaines des transactions dont nous n’avons pas besoin. Par exemple, nous n’avons pas besoin de traiter les transactions sortantes, donc nous continuons la boucle de l’élément suivant.

for i in data['transactions']:
  txAmount = i['amountNQT']
  txSender = i['senderRS']
  if txSender == myAccount:
      continue
  txRecipient = i['recipientRS']
  if txRecipient != myAccount:
      continue

Ensuite, nous retirons la pièce jointe, vérifions si elle n’est pas chiffrée et dépouille les blancs.

line = i['attachment']['message']
  lineIsText = i['attachment']['messageIsText']
  if line.strip() != "" and lineIsText == True:
    line = line.strip()

L’étape suivante consiste à faire correspondre le message soumis à l’expression régulière. Il doit satisfaire au format «Number: Number», le premier nombre peut comporter jusqu’à 3 chiffres.

 matchLine = re.match(r'(d{1,3}:d{1})(.*)', line, re.M|re.I)

Si le message ci-joint est de format correct, nous le traitons plus loin …

L’application de pari accepte jusqu’à 3 arguments de ligne de commande: id du jeu, le numéro de choix qui a gagné, et le troisième paramètre optionnel entre guillemets pour nommer le choix du gagnant pour la verbosité dans le message de paiement.

Par exemple, l’hôte de pari doit l’exécuter comme ceci:
Python3 bet.py 30 1 « L’équipe locale gagne »

L’application traite les transactions avec l’ID de jeu 30 et récompense les joueurs qui ont choisi ‘1’.
Le troisième argument peut être omis: python3 bet.py 30 1

Ensuite, nous devons calculer la somme d’argent soumise pour notre jeu, faire une liste de dictionnaires de joueurs qui ont deviné le nombre correct, et calculer la somme totale pour la distribution après l’hôte de paris reçoit son service facultatif coupé.

  if matchLine:
      if matchLine.group(1).split(':')[0] == sys.argv[1]:
        totalAmount += int(txAmount)
        if matchLine.group(1).split(':')[1] == sys.argv[2]:
          d = {txSender: matchLine.group(1).split(':')[1], 
'amount': txAmount}
          players.append(dict(d))
afterFee = float(totalAmount - totalAmount * serviceFee)

Nous avons des gagnants dans la liste des joueurs de dictionnaires, nous avons de l’argent à distribuer dans ‘afterFee’, nous allons maintenant traiter les paiements.

sumCorrect = 0
for i in players:
  for key in i:
    if i[key] == sys.argv[2]:
      sumCorrect += float(i['amount'])
for i in players:
  for key in i:
    if i[key] == sys.argv[2]:
      t = float(i['amount']) * (afterFee / sumCorrect)
      if t > afterFee:
        strSendAmount = str(int(afterFee))
      else:
        strSendAmount = str(int(t))
      if len(sys.argv) > 3:
        reply = sys.argv[3]
      else:
        reply = sys.argv[2]
      message = "Payout for correct bet in poll " 
+ sys.argv[1] + "; your reply: " + reply
      Query = {'requestType': 'sendMoney', 'recipient': key, 
      'amountNQT': strSendAmount, 'secretPhrase': secretPhrase, 
      'feeNQT': '100000000', 'deadline': '1440', 'broadcast': 'true', 
'message': message, 'messageIsText': 'true', 'messageIsPrunable': 'true'}
      sendQuery(Query)

Inutile de dire que l’application peut être améliorée pour traiter les erreurs, annuler les paris ou éventuellement permettre d’autres paramètres dans les messages attachés. Les messages joints peuvent être soumis avec le Nxt Client (NRS) ou à partir d’un portefeuille Web qui permet l’envoi de pièces jointes.

Pour effectuer des transactions sur le Nxt Blockchain, vous avez besoin de pièces NXT, que vous pouvez acheter directement, en échangeant des Bitcoins pour des NXT ou en assistant au projet Lucky Node en exécutant un nœud public Nxt (serveur Nxt).

Pour savoir comment participer au projet de nœud Lucky, veuillez visiter https://nxtforum.org.

Il ya plus d’une centaine d’appels API que vous pouvez faire sur le serveur Nxt, une liste complète avec des paramètres obligatoires et facultatifs et des exemples sont disponibles à https://nxtwiki.org/wiki/The_Nxt_API.

À votre santé!

blockchain-betting

Programmation de la Blockchain Nxt pour le plaisir et le profit

Les Blockchains peuvent être utiles dans diverses applications, en faisant face à l’audience mondiale et en soutenant l’infrastructure interne d’une entreprise. Une chaîne de blocs est une base de données distribuée, une copie de la chaîne de blocs est stockée sur chaque noeud dans un réseau pair à pair. Cette redondance extrême peut être considérée comme inefficace, mais s’il vous plaît rester avec moi pour quelques minutes de la théorie des blocs de chaîne.

Comme chaque nœud valide toutes les transactions enregistrées dans la chaîne de blocs et que les transactions passées ne peuvent pas être annulées ou falsifiées comme dans un  »RDBMS » traditionnel, cette redondance rend le bloc-chaîne * immuable *, et c’est une proposition de valeur très importante de chaîne de blocs. L’immutabilité des données est quelque chose que les bases de données traditionnelles ne peuvent pas fournir. Vous pouvez ou ne pas avoir besoin d’immutabilité des données et de la confiance sans confirmation que les données n’ont pas été modifiées.

Dans ce tutoriel je suppose que vous avez besoin de ceci;

L’une des blockchains les plus polyvalentes et flexibles est la Nxt Blockchain (https://nxt.org). Il a plus d’une centaine d’appels API https://nxtwiki.org/wiki/The_Nxt_API

Aujourd’hui, vous apprendrez les bases de la programmation de la chaîne de blocs Nxt. Je n’utiliserai que deux appels API dans ce didacticiel. Avec plus d’une centaine d’appels API, les possibilités pour les programmeurs sont illimitées.

Logique d’Application

Un client d’une entreprise ou un employé d’une organisation télécharge un fichier via un formulaire Web.
Le fichier est renommé en un nom unique et est enregistré dans un emplacement quelconque sur le serveur.

Un an plus tard, le client / employé doit vérifier, à l’aide de de la chaîne de blocs Nxt, que le fichier n’a pas été modifié. Par exemple, cela peut être requis à des fins légales. Il n’a pas besoin d’être des fichiers. Les mémoires d’entreprise internes peuvent être hachés et stockés dans la base de données, pour être vérifiés lors d’une vérification ultérieure.

Nxt nous permet d’envoyer et d’enregistrer des messages arbitraires (AM) dans sa chaîne de blocs.

Chaque transaction sur la chaîne de blocs est payante. Si la taille de la transaction est importante, elle peut être coûteuse; Heureusement Nxt a un sous-type de AM appelé messages pouvant être supprimés. Ceux-ci sont taillés après 90 jours qui les rendent bon marché, ils sont disponibles pour la récupération des noeuds d’archives après 90 jours.

La taille maximale d’un message arbitraire dans la chaîne de blocs  Nxt est d’environ 42 Ko, la taille d’un bloc. Un message pouvant être supprimé de 1 KB coûte 1 NXT (0,03 $). 1 Ko est suffisant pour stocker un hachage d’un fichier et c’est notre coût final pour enregistrer de façon permanente un hachage dans le bloc distribué immuable Nxt.

Lorsque le client télécharge un fichier, je crée un hachage SHA256 du fichier et stocke le hachage dans la base de données du serveur de l’organisation. Pour simplifier j’ai choisi SQlite, mais vous pouvez utiliser Mysql, Postgresql, Oracle. Je vais utiliser PDO pour accéder à la base de données SQlite en PHP.

Lorsque nous n’utilisons pas la base de données immuable (blockchain), le fichier peut être modifié, le nouveau hash du fichier modifié enregistré dans la base de données, ce qui rend difficile de prouver que le fichier était comme ça depuis le début.

La chaîne de blocs vient à la rescousse

Chaque message pouvant être supprimé peut être récupéré à partir des noeuds d’archivage. Chaque enregistrement dans la chaîne de blocs est immuable. Vous pouvez être sûr que le hachage du fichier que vous avez téléchargé il ya un an, quand il est extrait de la chaîne de blocs, est le même hachage. Tout ce que vous avez besoin maintenant est de le comparer avec le hachage dans le RDBMS interne de l’organisation.

Conditions préalables:
PHP avec curl, json et certaines extensions db (j’utilise sqlite3). Un serveur web est facultatif, vous pouvez utiliser php-cli. Java 8 (Oracle ou OpenJDK pour exécuter Nxt). Logiciel de référence Nxt: https://nxtforum.org/nrs-releases/nrs-v1-10-1/.

Installez le NRS (logiciel de référence Nxt (en fonction du contexte indistinctement appelé Nxt Client ou Nxt Server)) et créez un compte. Financer le avec quelques pièces de monnaie. Vous pouvez échanger des Bitcoin vers NXT à un service d’échange comme https://shapeshift.io ou échanger avec quelqu’un sur https://nxtforum.org. Il est également possible de « détruire » certains NXT gratuits comme récompense pour l’exécution d’un nœud; Http://nxter.org/the-forging-bounty-lottery-campaign-will-pay-5-million-in-rewards-to-forgers-and-nxt-nodes/ 
Tout d’abord, nous créons une table de base de données simple pour notre application, rien de fantaisiste, vous pouvez ajouter d’autres types de colonnes si vous devez stocker plus d’informations. J’aime utiliser DB Browser pour SQLite de http://sqlitebrowser.org.
Faisons une base de données vide ‘files.db’ et l’enregistrons dans /home/lurker10/phptutorial/files.db
À l’aide de DB Browser pour SQLite, créez le tableau suivant.
CREATE TABLE "files" (
`id` INTEGER PRIMARY KEY AUTOINCREMENT,
`txid` TEXT,
`hash` TEXT,
`uploadtime` TEXT,
`filename` TEXT
)

‘Txid’ est le champ pour stocker l’id d’une transaction que nous recevons des Nxt lorsque la transaction est acceptée. Il est unique. ‘Hash’ est le sha256 hash du fichier.

Dans ce didacticiel je saute la partie de téléchargement de fichier du code pour la garder concise.

Supposons que le fichier est déjà téléchargé et stocké sur le serveur Web. Nous définissons la variable d’emplacement du fichier dans le code.

$uploadDir = "/home/lurker10/phptutorial/tmp/";
$fileName = "copy12345.tar"; 

Par défaut, le serveur Nxt écoute les demandes d’API sur le port 7876. Si vous l’exécutez sur la même machine que votre code php, votre code doit envoyer des requêtes à http://127.0.0.1:7876/nxt

Les autres variables importantes sont la phrase de passe du compte Nxt que vous avez créé et financé et le compte du destinataire.

Vous pouvez envoyer le message à vous-même, le destinataire peut être votre propre compte.

$host = "http://127.0.0.1:7876/nxt";
$secretPhrase = "your passphrase";
$recipientID = "NXT-XXXX-XXXX-XXXX-XXXXX";

La partie suivante du code est la fonction qui soumet une requête en utilisant curl dans une requête POST.

Pour effectuer une requête, nous devons définir les variables $payload et $payload_string et les envoyer à sendRequest(). Il est possible d’exécuter le Nxt Server via HTTPS et d’utiliser une boucle pour vérifier le certificat SSL, mais pour cette application simple, nous avons désactivé la vérification SSL dans la connexion en boucle.

Un autre point d’intérêt est le $errorDescription, json-decoded à partir de la réponse du serveur.

S’il ya un problème avec la requête ( « Pas assez de fonds » dans votre compte lorsque votre solde est zéro),
Vous devez ajouter une routine de gestion des erreurs. Je l’omet aussi. Pour cette application, je suppose que le serveur a répondu correctement et renvoyer la réponse dans l’application pour un traitement ultérieur.

function sendRequest($host, $payload, $payload_string) {
$ch = curl_init();
curl_setopt($ch, CURLOPT_URL, $host);
curl_setopt($ch, CURLOPT_CUSTOMREQUEST, "POST");
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
curl_setopt($ch, CURLOPT_SSL_VERIFYPEER, FALSE);
curl_setopt($ch, CURLOPT_SSL_VERIFYHOST, FALSE);
curl_setopt($ch, CURLOPT_CONNECTTIMEOUT_MS, 10000);
curl_setopt($ch, CURLOPT_TIMEOUT_MS, 10000);
curl_setopt($ch, CURLOPT_POST, count($payload));
curl_setopt($ch, CURLOPT_POSTFIELDS, $payload_string);
$output = curl_exec($ch);
$curl_error = curl_error($ch);
curl_close($ch);
$errorDescription = trim(@json_decode($output)->errorDescription);
if ($errorDescription != "") { // perform error handling; return false; }
return $output;
}

Comme le fichier est déjà téléchargé, je crée un hachage sha256 du fichier et de l’horodatage.

$fileHash = hash_file("sha256", $uploadDir.$fileName);
$txTime = time();

Je vais utiliser PDO pour travailler avec la base de données.

Ouvrez le DB et insérez un nouvel enregistrement.

Nous ne savons pas le txid jusqu’à ce que nous parlons au serveur Nxt qui peut nous le donner quand la transaction est acceptée sur le réseau NXT, donc pour l’instant, je vais insérer null pour le txid.

$pdo = new PDO('sqlite:/home/lurker10/phptutorial/files.db');
$sql = "INSERT INTO files (txid, hash, uploadtime, filename)
VALUES (null, '$fileHash', '$txTime', '$fileName')";
$result = $pdo->exec($sql);

Ensuite, nous créons une requête à envoyer au serveur NXT.

Cette requête particulière est « sendMessage », vous pouvez trouver beaucoup plus de requêtes pour interagir avec la blockchain et leurs paramètres obligatoires et facultatifs à https://nxtwiki.org/wiki/The_Nxt_API.

Comme je l’ai dit plus tôt, les frais de transaction sont de 1 NXT. 1 NXT = 100 000 000 NQT (nanoquants).
1 NQT est la plus petite unité de dénomination en NXT identique à 1 satoshi en Bitcoin.
Le Nxt Server accepte les frais en NQT, nous payons donc exactement 100 millions de NQT (0,03 $)

Le paramètre « broadcast » peut être changé en false, dans ce cas, vous recevrez ‘transactionBytes’ dans la réponse, qui peut être diffusée sur le réseau plus tard en utilisant la requête ‘broadcastTransaction’. Mais aujourd’hui, je l’ai mis à «vrai» pour diffuser la transaction instantanément.

N’oubliez pas d’urlencode() le message. J’insère le nom de fichier séparé du hachage avec un deux-points dans le message.

$payload = array(
"requestType" => "sendMessage",
"recipient" => $recipientID,
"secretPhrase" => urlencode($secretPhrase),
"feeNQT" => 100000000,
"deadline" => 1440,
"broadcast" => "true",
"message" => urlencode($fileName . ":" . $fileHash),
"messageIsPrunable" => "true"
);
$payload_string = "";
foreach ($payload as $key => $value) {
$payload_string .= $key . "=" . $value . "&";
}
rtrim($payload_string, "&");

Envoyez la requête au serveur NXT en utilisant la fonction sendRequest ():

$output = sendRequest($host, $payload, $payload_string);

Et décoder la réponse JSON du serveur pour obtenir l’id de transaction:

if ($output != false) {
$txId = json_decode($output)->transaction;
}

Maintenant qu’il ya une réponse positive sur la transaction acceptée et que son ID est connu, mettons à jour l’enregistrement dans le db interne.

$lastId = $pdo->lastInsertId();
$sql = "UPDATE files SET txid = '$txId' where id = '$lastId'";
$result = $pdo->exec($sql);

Nous pouvons éventuellement fournir ces liens au client pour des références futures et pour prouver que le hash a été téléchargé:

echo "NXT Transaction ID: " . $txId . ",
JSON response";
echo "

Utilisez ces liens pour vérifier le hash Sha256 de votre fichier enregistré dans notre base de données interne contre l’enregistrement permanent dans le bloc block NXT:

" . $fileHash;

En option, envoyez un e-mail au client, le $txId, qui pourra ensuite être utilisé pour vérifier le hachage ou, autrement, leur donner des informations de base sur la récupération du hachage à partir du db interne et le comparer au hachage stocké par la blockchain à l’avenir, par horodatage ou avec d’autres critères.

Cette application n’inclut pas l’authentification des utilisateurs. Normalement, le client ou l’utilisateur d’un service intranet pourrait voir ses fichiers après s’être authentifié sur le site.

Cette application suppose également que l’application de vérification est hors de portée du responsable de la base de données interne pour éviter de falsifier les résultats de la vérification.

Maintenant, l’enregistrement est enregistré dans la base de données de l’entreprise. Afficher l’enregistrement db pour confirmer qu’il est là.

$sth = $pdo->prepare("SELECT id, txid, hash, uploadtime, filename FROM files ORDER BY id DESC");
$sth->execute();
$result = $sth->fetch(PDO::FETCH_OBJ);
if ($result != false) {
var_dump($result);
}

L’Application de Vérification

Pour utiliser l’application de vérification de hachage, le client doit avoir l’ID de transaction dans la chaîne de blocs NXT
Transmis à la Nxt Blockchain.

Supposons que le client ne l’a, enregistré dans l’archive de courrier ou récupéré par d’autres moyens.

$txId = "111111111111111111";


Voyons ce que notre base de données interne a pour le hash du fichier. Fetch et l’enregistrer dans $ hashInDb.

$pdo = new PDO('sqlite:/home/lurker10/phptutorial/files.db');
$sth = $pdo->prepare("SELECT hash FROM files where txid = '$txId'");
$sth->execute();
$result = $sth->fetch(PDO::FETCH_OBJ);
if ($result != false) {
$hashInDb = $result->hash;
}

Envoyer une requête au serveur NXT et extraire toutes les informations stockées dans le bloc NXT pour la transaction avec l’ID donné.

$payload = array (
"requestType" => "getTransaction",
"transaction" => $txId
);
$payload_string = "";
foreach ($payload as $key => $value) {
$payload_string .= $key . "=" . $value . "&";
}
rtrim($payload_string, "&");

$output = sendRequest($host, $payload, $payload_string);

Décoder la réponse JSON et extraire le champ de la pièce jointe où le hachage est stocké.

Dans la première partie de l’application, nous avons enregistré le nom de fichier séparé du hachage avec un deux-points.
Maintenant, nous extrayons simplement la partie de hachage du message arbitraire.

$attachmentPlainData = json_decode($output)->attachment->message;
$hashInBlockchain = explode(":", $attachmentPlainData)[1];

Et comparer ce que nous avons dans la base de données de l’entreprise avec ce qui a été enregistré il ya un an dans la chaîne de blocs Nxt.

if ($hashInDb == $hashInBlockchain)
echo "Hashes are identical";
else
echo "Hashes are not identical";

NXT-crypto-developer