[JAVA] IOTA: [Explication technique] Le tableau d'ensemble du paquet de transferts de fonds.

English here. Special thanks to Take san for translating it!

Articles passés, * IOTA: [Explication technique] Transaction grande dissection! Que fait le portefeuille dans les coulisses? * Je ne pouvais pas l'expliquer dans le maniaque, mais je l'ai fait au point où ça me démangeait. En effet, la base de ce bundle est la connaissance préalable pour comprendre la technologie chaude IOTA, la MAM et la multi-signature à l'avenir. Le code source de l'article utilisait Java. La raison en est que Java est mon préféré et il est plus facile de comprendre si vous pouvez voir le type de la variable. Bien sûr, IOTA peut être développé dans divers environnements, donc si vous êtes intéressé, jetez un œil à IOTA Official Github.

Qu'est-ce que l'IOTA?

Une collection de liens pour vous aider à comprendre les bases de l'IOTA, car l'IOTA n'est pas encore bien connue.

** Site de fans japonais IOTA ** Site officiel actuel d'IOTA Japon. En effet, les informations officielles de l'IOTA sont traduites en japonais et publiées. De nombreuses informations destinées aux débutants sont également publiées. ** Livre blanc ** anglais [japonais](https://www.dropbox.com / s / 1w5vtu7s4idquc9 / IOTA_Whitepaper% 20v1.1% 20in% 20Japanese.pdf? Dl = 0) Les contours de Tangle étaient jusqu'au début, et après cela, la sécurité, les attaques attendues et leur résistance ont été expliquées en mathématiques avancées. ing. La seconde moitié ne convient pas aux débutants. ** Fil de discussion pour débutants Reddit (anglais) ** J'ai commencé ici. ** Guide IOTA (anglais) ** Si le livre blanc est la Faculté des sciences, c'est la Faculté d'ingénierie.

La communauté IOTA s'est développée sur la base de Slack. Il existe également une chaîne japonaise ** #japanese **, alors n'hésitez pas à nous rejoindre et à poser des questions.

Structure de transaction

Il peut être plus facile à comprendre en regardant les [articles] passés (https://qiita.com/ABmushi/items/e271ff05884a7d47658d#transaction%E5%A4%A7%E8%A7%A3%E5%89%96). La source ci-dessous est extraite de Transaction.java. J'ai commenté les plus importants.

Transaction.java

public class Transaction {

    private static final transient Logger log = LoggerFactory.getLogger(Transaction.class);

    private transient ICurl customCurl;

    private String hash;                //Hachage de transaction (identité)
    private String signatureFragments;  //Un champ d'une longueur de 2187 trites utilisé pour signer etc.
    private String address;             //Précisez l'adresse
    private long value;                 //Précisez le montant
    private String obsoleteTag;
    private long timestamp;             //Devenu obligatoire
    private long currentIndex;          //Quel numéro est ce Tx dans le Bundle? (À partir de 0)
    private long lastIndex;             //Qu'est-ce que l'indice Tx à la fin du Bundle?
    private String bundle;              //Spécifie à quel bundle appartient cette transaction
    private String trunkTransaction;    //Approuver Tx Partie 1
    private String branchTransaction;   //Approuver Tx Partie 2
    private String nonce;               //Rechercher PoW
    private Boolean persistence;        //Vrai si approuvé. Faux si non approuvé
    private long attachmentTimestamp;
    private String tag;                 //27 balises banales
    private long attachmentTimestampLowerBound;
    private long attachmentTimestampUpperBound;

Au moins deux, ** adresse de réception (destination) ** et ** adresse source d'envoi (expéditeur) **, sont nécessaires pour le versement. Cependant, comme vous pouvez le voir, chaque objet Transaction n'a qu'une seule adresse. Par conséquent, IOTA a introduit le concept de Bundle. En incluant plusieurs objets Transaction dans le Bundle, divers éléments nécessaires tels que l'adresse de réception, l'adresse d'envoi et la signature sont gérés en divisant les rôles en objets Transaction distincts.

Transférer l'API

L'API pour envoyer de l'argent est facile à voir.

Classe de transfert

Conservez les informations de versement.

Transfer.java

public class Transfer {

    private String timestamp;      //Horodatage
    private String address;        //Adresse de réception (destination)
    private String hash;
    private Boolean persistence;   // true:Approuvé, faux:Désapprouvé
    private long value;            //Montant de la remise
    private String message;        //Tout banal
    private String tag;            //Étiquette (27 trites)

    //Génération d'objets de transfert
    //Adresse de destination, montant du versement, astuce de message arbitraire, balise
    public Transfer(String address, long value, String message, String tag) {
        this.address = address;
        this.value = value;
        this.message = message;
        this.tag = tag;
    }
...

sendTransfer, fonction

Une fonction appelée sendTransfer est utilisée pour envoyer de l'argent. Effectuez plusieurs transferts à la fois en prenant une liste d'objets Transfer comme arguments.

IotaApi.java

/**
 * Wrapper function that basically does prepareTransfers, as well as attachToTangle and finally, it broadcasts and stores the transactions locally.
 *
 * @param seed               Tryte-encoded seed
 * @param security           The security level of private key / seed.
 * @param depth              The depth.
 * @param minWeightMagnitude The minimum weight magnitude.
 * @param transfers          Array of transfer objects.
 * @param inputs             Optional: List of inputs used for funding the transfer.
 * @param remainderAddress   Optional: If defined, this remainderAddress will be used for sending the remainder value (of the inputs) to.
 * @param validateInputs     Whether or not to validate the balances of the provided inputs.
 * @param validateAddresses  Whether or not to validate if the destination address is already used and if a key reuse is detect.
 * @return Array of valid Transaction objects.
 * @throws ArgumentException is thrown when the specified input is not valid.
 */
public SendTransferResponse sendTransfer(
        String seed,
        int security, int depth, int minWeightMagnitude,
        final List<Transfer> transfers,
        List<Input> inputs,
        String remainderAddress,
        boolean validateInputs, boolean validateAddresses) throws ArgumentException {
....
}

transfert d'argent

** Jetez un coup d'œil à l'exemple «M. A met un message sur M. B et envoie 100 devises» **.

//Le message est un banal de toute taille
String message = "MESSAGE..."

//Le tag est 27 banals
String tag = "SAMPLE9TAG99999999999"

//L'adresse est 81 Trite. Adresse de M. B.
String address = "B9ADDRESS..."

//Générer un objet de transfert (envoyer 100 devises à l'adresse de M. B avec message)
Transfer transfer = new Transfer(address,100,message,tag);
List<Transfer> list = new List<>();
list.add(transfer);

//transfert d'argent
sendTransfer("Précisez la semence de M. A",security,depth,minWeightMagnitude,list,null,null,true,true);

J'ai essayé de simplifier la partie remise du code source du portefeuille officiel. Je n'ai pas essayé cela, donc je ne peux rien dire, mais le transfert se fait dans le flux ci-dessus. Dans cet article, je voudrais faire attention à ce qu'il y a à l'intérieur de cette fonction sendTransfer. La bonne façon d'envoyer de l'argent est de regarder la source officielle, je vais donc mettre un lien ici.

Python iota.lib.py/examples/send_transfer.py Android android-wallet-app/app/src/main/java/org/iota/wallet/ui/fragment/NewTransferFragment.java

Structure du paquet

Premièrement, IOTA crée un Bundle pour les transferts de fonds. Un Bundle est une collection de "Transaction", qui est la plus petite unité d'IOTA. Les informations nécessaires pour un versement, telles que le montant du versement et la signature, sont résumées. Le Bundle comprend trois parties principales.

① Section de sortie-'sortie' (spécifiez où et combien d'argent envoyer) ② Section d'entrée - 'entrée' (spécifiez où apporter le montant) ③ Unité de sortie de différence - 'reste' (spécifiez où envoyer la modification)

Un exemple d'envoi de "13i" à l'adresse "DEFBQV ...". (Sécurité = 2)

Sortie - sortie

L'envoi d'argent à une adresse de destination spécifiée est appelé ** sortie **. La section de sortie, qui est la première moitié du Bundle, entreprend la sortie. L'unité de sortie a les rôles suivants.

① Précisez le montant de la remise ② Désignation de la destination de transfert ③ Stockage de message arbitraire (message)

L'exemple de ** "M. A met un message sur M. B et envoie 100 devises" ** est le suivant.

• «sigF» signifie «fragments de signature» dans la transaction ci-dessus.
• Par souci de clarté, M. B est affecté à «adresse», mais veuillez considérer ceci comme l'adresse de M. B.
• 0 et 1 dans Tx.0 et Tx.1 indiquent «currentIndex» dans la transaction ci-dessus.

Comme vous pouvez le voir sur la figure, spécifiez le montant de la remise à «valeur» de ** Tx.0 ** et la destination à «adresse». Ensuite, la partie message est divisée en morceaux de taille 2187 trites et stockée dans sigF de Tx.0, Tx.1, ... dans l'ordre de l'avant. Si message est plus court que 2187 trites, la section de sortie est uniquement Tx.0, c'est-à-dire qu'une transaction suffit. De plus, si le message est long, la transaction augmentera et la section de sortie elle-même sera longue. Puisque «message» n'est presque jamais exactement un multiple de 2187, nous remplissons généralement la fraction de «sigF» par «9». De plus, bien que chaque "message" soit représenté par un banal dans "sigF", il peut bien sûr être converti d'un banal en caractère, de sorte que le contenu de la phrase est manquant sur le Tangle. Par conséquent, une méthode d'utilisation appelée ** MAM (Masked Authenticated Message) **, qui fournit un espace privé sur Tangle en chiffrant ce sigF, a été proposée et est en cours de recherche et développement (section suivante).

Pertinence pour MAM

MAM est l'une des fonctions les plus prometteuses de l'IOTA, et c'est une fonction qui peut enregistrer des données sur Tangle tout en préservant la confidentialité. En bref, il crypte le contenu de ce sigF, qui est maintenant exposé sur Tangle et peut être consulté par n'importe qui. Avec IOTA, qui n'a pas de frais, vous pouvez envoyer zéro yen, vous pouvez donc utiliser activement le sigF de cette transaction comme zone de données privée. Publier un article de commentaire est mon dernier rêve cette année.

Section d'entrée - entrée

La collecte du montant de la remise à l'adresse avec le solde sur le Tangle s'appelle ** input **. Vous devez avoir assez d'argent quelque part pour exécuter la sortie spécifiée dans la section de sortie. Vous devez également éviter les doubles paiements en signant que vous avez été payé à partir de l'adresse. L'unité d'entrée qui les entreprend a les rôles suivants.

① Spécifiez le montant d'entrée ② Spécifiez l'adresse d'entrée ③ Signe de l'adresse d'entrée

** En continuant avec l'exemple de "M. A met un message sur M. B et envoie 100 devises" **, précisez où apporter plus de 100 devises. Je dis «plus que» ici parce que le surplus peut être collecté à la prochaine section de sortie de différence.

Dans cet exemple, il y a deux entrées (entrée 1 et entrée 2). La raison des deux est que le montant total de chaque «adresse» détenue (M. A ① + M. A ② = ** - 144 **) peut enfin couvrir le montant du versement ** 100 **. L'excédent ** 44 ** sera traité dans la section suivante, la section de sortie de différence. Si M. A a un solde de 100 ou plus à une certaine adresse, par exemple, il suffit de saisir l'un d'entre eux et, par conséquent, la longueur de la section d'entrée devient plus courte. Plus important que cela est le «sigF». Il y a deux signatures pour une adresse d'entrée. Cela dépend de l'argument security de la fonction sendTransfer. Si security = 1, seul" 1 "est généré. En d'autres termes, dans cette figure, un total de deux signatures est requis pour M. A ① et M. A ②. Si security = 3, chaque adresse d'entrée doit être inscrite à" Part 3 ", et un total de 2 * 3 = 6 transactions est généré dans la section d'entrée. La formule est la suivante.

$ Numéro de transaction = sécurité * numéro d'entrée $

Pour la méthode de signature, voir [Articles précédents](https://qiita.com/ABmushi/items/422d1bf94be0c919583a#%E7%BD%B2%E5%90%8D%E3%81%AE%E6%96% Je l'ai mentionné dans B9% E6% B3% 95), alors j'apprécierais que vous y fassiez référence.

Section de sortie de différence - restante

Comme il n'y a généralement pas d'adresse d'entrée dont le solde correspond au montant de sortie, un solde qui dépasse le montant de sortie est collecté à partir de plusieurs adresses d'entrée. Par conséquent, le changement se produit. Dans IOTA, si une adresse une fois signée est utilisée comme adresse d'entrée et nouvellement signée, cela entraînera une fuite de clé privée. En d'autres termes, ne recevez pas d'argent à une adresse une fois signée. Si la modification est renvoyée à l'adresse d'entrée d'origine, elle enfreint ce principe. La modification est ensuite envoyée à une autre nouvelle adresse. L'unité de sortie de différence a les rôles suivants.

① Désignation de la différence ② Spécifiez l'adresse de sortie

** Dans l'exemple de "M. A met un message sur M. B et envoie 100 devises" **, le reste des ** 44 ** devises est finalement sorti. Jetez un œil à la figure ci-dessous.

C'est très simple. L'unité de sortie de différence génère un seul TX s'il y a une différence. Le montant de la monnaie n'est envoyé qu'à la nouvelle adresse de M. A (M. A ③). Pour ceux qui se demandent quelle est la nouvelle adresse, [Articles précédents](https://qiita.com/ABmushi/items/e271ff05884a7d47658d#%E3%82%A2%E3%83%89%E3%83%AC%E3 Veuillez relire% 82% B9). À propos, si le changement est nul (l'adresse d'entrée exacte est trouvée), l'unité de sortie de différence elle-même n'est pas générée.

Lors de l'envoi d'argent à plusieurs adresses

Lorsque vous envoyez de l'argent à plusieurs adresses différentes, ** augmentez la section de sortie du nombre d'adresses. ** **

Il est facile de gérer la section d'entrée et la section de sortie de différence. Dans cet exemple, la section d'entrée recherche les adresses d'entrée pour (100 + 1000 + 634 = 1734) ou plus, et la différence est simplement de placer le changement dans un Tx, et rien de spécial n'est fait.

L'image complète de Bundle

Désormais, la transaction de l'IOTA ne se contente pas de générer, elle a pour tâche d'approuver deux transactions appelées «trunkTransaction» et «branchTransaction».

Sélection de conseils à approuver

Les transactions appelées Astuces pour approuver peuvent être facilement obtenues avec une fonction appelée getTransactionToApprove. C'est trop facile, mais il y a un haut niveau de mathématiques derrière cela, ce qui dérange la tête des amateurs comme moi. C'est très difficile à manier, alors j'aimerais demander à quelqu'un qui peut faire des mathématiques d'expliquer cela.

Relation d'approbation du bundle

Comme je l'ai mentionné dans l'article précédent, j'ai osé redessiner la figure. 　 Appliquez respectivement les fonctions «trunkTransaction» et «branchTransaction» renvoyées par la fonction «getTransactionsToApprove» aux «Milestone» et «other Tx» de la figure. Jetez un œil aux transactions et bundles appropriés dans Tangle Explorer tels que https://iotasear.ch/. Il doit être exactement comme présenté dans cet article. (Veuillez signaler si c'est différent)

Cheet sheet

Taille imprimable. Je veux le mettre à jour de temps en temps pour le rendre beau.

Les références

** Bibliothèque Java IOTA JOTA ** iotaledger / iota.lib.java

Comme toujours, nous attendons avec impatience vos commentaires sur l'article.