Geekly articles weekly

Hiérarchie de portefeuille multi-signée (système de confiance)

Ce texte décrit l'abstraction d'un système de confiance, qui vous permet d'intégrer les services d'entiercement dans n'importe quel domaine des relations économiques.
Le dépôt de fonds est un élément fondamental de toute transaction. Si les contreparties ne connaissent pas d'informations fiables les unes sur les autres, le risque de fraude augmente. Cette approche vous permet de programmer dans un réseau décentralisé un modèle de résolution des litiges, un modèle pour effectuer des transactions automatiques, des transactions sécurisées, etc. De plus, un tel modèle de système de confiance est ouvert. Toutes les transactions effectuées avec la participation de la hiérarchie des portefeuilles multi-abonnements nous permettent de vérifier la notation de la contrepartie et nous protègent également des stratagèmes frauduleux des nouveaux participants aux relations économiques.

Table des matières


1 Introduction
2 Description d'un portefeuille multi-signatures
3 façons de créer une hiérarchie de portefeuille
4 Interface de hiérarchie du portefeuille sur plusieurs jours
5 flux d'interaction
5.1 Flux d'interaction standard
5.2 Flux d'interaction sécurisé
5.3 Flux d'interaction controversé
6 Protocole ESCB9
7 Intégration d'un système de confiance et de contrats intelligents mettant en œuvre le protocole ESCB9
8 Exemples de contrats mettant en œuvre le SEBC9
8.1 Contrat intelligent pour le marché locatif privé, à l'instar d'AirBnb
8.2 Un contrat intelligent pour échanger n'importe quelle crypto-monnaie contre de la monnaie fiduciaire en retour en mode décentralisé
9 nœuds d'arbitrage
10 Dictionnaire

1. Introduction


Le principal problème des services d'entiercement est la création de relations de confiance entre tous les participants. De plus, les participants eux-mêmes ne doivent pas nécessairement être connus de chaque sujet de relations. Pour résumer tous les cas, nous tiendrons compte du fait qu'ils sont tous anonymes. Pour un tel système de relations de confiance, il est important de réguler les relations des nouveaux participants avec les anciens. Les anciens participants ont déjà une certaine note dans le système de relations et provoquent ainsi plus de confiance. Étant donné que personne ne connaît personne dans le système de confiance, cela entraîne des problèmes de vérification de la note précédente. Ce document décrit le système de confiance basé sur des crypto-portefeuilles multi-abonnement. Un tel système peut être programmé dans un contrat intelligent. Compte tenu de la large diffusion de la plate-forme Ethereum, nous choisirons cette plate-forme comme plate-forme pour décrire tous les contrats intelligents dans ce document.

2. Description d'un portefeuille multi-signatures


Une abstraction qui vous permet de confirmer ou d'annuler des transactions uniquement si un consensus est atteint entre les participants autorisés à prendre une telle décision s'appelle un portefeuille multi-signatures. Une transaction dans ce contexte est une opération atomique programmée pour exécuter une méthode dans un autre ou le même contrat intelligent.

L'interface pour le contrat Smart d'une telle abstraction peut être représentée comme:

  1. le constructeur accepte les adresses des membres fondateurs et le nombre de confirmations minimales requises pour les transactions
    constructor(address[]:members, uint256:requiredConfirmationCount)

  2. Interface de participant autorisé
    1. obtenir une liste des participants
       static getMembers() -> address[]:address

    2. afficher l'adresse du membre
       static getMember(uint256:indexNumber) -> address:address

    3. vérification de l'adresse d'adhésion
       static isMember(address:address) -> bool:value

    4. obtenir le nombre maximum de participants pour le portefeuille
       static getMaxMemberCount() -> uint256:value

    5. Confirmation du consensus minimum
       static getRequiredConfirmationCount() -> uint256:value

    6. en cas d'ajout d'un nouveau membre
       event MemberAddition() -> address:member

    7. événement de suppression de membre
       event MemberRemoval() -> address:member

    8. changement d'événement nombre de confirmations à exécuter
       event RequiredConfirmationCountChange() -> uint256:count

    9. ajouter un membre
       execute addMember(address:member) -> void:value

    10. suppression de membre
       execute removeMember(address:member) -> void:value

    11. remplacement de membre
       execute replaceMember(address:currentMember, address:newMember) -> void:value
    12. modification du nombre de confirmations obligatoires d'exécution
       execute changeRequiredConfirmationCount(uint256:count) -> void:value


  3. Interface de transaction
    1. vérification de la confirmation de transaction à l'adresse du participant
       static getConfirmationByAddress(uint256:indexNumber, address:addressMember) -> bool:value

    2. obtenir des informations d'une transaction
       static getTransactionInfo(uint256:indexNumber) -> [address:destination, uint256:value, bytes:data, bool:executed]
    3. obtenir le nombre total de transactions dans ce portefeuille
       static getTransactionCount() -> uint256:value
    4. recevoir le statut de confirmation de transaction
       static isConfirmed(uint256:transactionId) -> bool:value
    5. recevoir le nombre de confirmations
       static getConfirmationCount(uint256:transactionId) -> uint256:count
    6. obtenir le nombre de transactions par type
       static getTransactionCount(bool:pending, bool:executed) -> uint256:count
    7. obtenir la liste des participants qui ont confirmé la transaction
       static getConfirmations(uint256:transactionId) -> address[]:confirmations
    8. obtenir une liste d'ID de transaction par type dans un certain laps de temps
       static getTransactionIds(uint256:from, uint256:to, bool:pending, bool:executed) -> uint256[]:transactionIds
    9. événement de confirmation de transaction de partie
       event Confirmation() -> [address:sender, uint256:transactionId, uint256:timeStamp]
    10. événement de retrait de confirmation du participant avant la transaction
       event Revocation() -> [address:sender, uint256:transactionId, uint256:timeStamp]
    11. transaction d'ajout de file d'attente événement
       event Submission() -> [uint256:transactionId]
    12. événement d'exécution de transaction
       event Execution() -> [uint256:transactionId]
    13. événement d'erreur de transaction
       event ExecutionFailure -> [uint256:transactionId]
    14. événement de réapprovisionnement de portefeuille
       event Deposit -> [address:sender, uint256:amount]
    15. membre ajoutant une transaction
       execute submitTransaction(address:destination, uint256:value, bytes:data) -> uint256:transactionId
    16. confirmation de transaction par le participant
       execute confirmTransaction(uint256:transactionId) -> void:value
    17. retrait de la confirmation par le participant
       execute revokeConfirmation(uint256:transactionId) -> void:value
    18. transaction manuelle
       execute executeTransaction(uint256:transactionId) -> void:value



3 façons de créer une hiérarchie de portefeuille


Il existe deux façons principales de créer un système de confiance. Vertical et horizontal. La construction horizontale implique la création d'une liste de portefeuilles enfants par un parent principal. La construction verticale implique une chaîne composée de portefeuilles enfants en référence au parent. Dans ce cas, le portefeuille parent peut être un enfant d'un autre portefeuille parent.
Comme nous le voyons, le chemin de construction horizontal peut être une sous-espèce du chemin de construction vertical. Par conséquent, nous laissons cette approche sans surveillance.

4 Interface de hiérarchie du portefeuille sur plusieurs jours


Pour construire un système de confiance, il est nécessaire d'étendre l'interface simple du portefeuille multi-abonnement décrit ci-dessus, en ajoutant des mécanismes de régulation de la hiérarchie et de l'exécution automatique des confirmations, ainsi que la possibilité d'une exécution différée.
  1. Le constructeur accepte l'adresse du portefeuille parent, les adresses des membres fondateurs, le nombre de confirmations minimales requises pour les transactions, le délai standard pour les confirmations automatiques en secondes
     constructor(address:parent, address[]:members, uint256:requiredConfirmationCount, uint256:standardTimeAutoConfirmation)

  2. Interface membre
    1. obtenir une liste des participants
       static getMembers() -> address[]:address

    2. fonction pour afficher l'adresse du participant
       static getMember(uint256:indexNumber) -> address:address

    3. vérification de l'adresse d'adhésion
       static isMember(address:address) -> bool:value

    4. obtenir le nombre maximum de participants au portefeuille
       static getMaxMemberCount() -> uint256:value

    5. Confirmation du consensus minimum
       static getRequiredConfirmationCount() -> uint256:value

    6. en cas d'ajout d'un nouveau membre
       event memberAddition() -> address:member

    7. événement de suppression de membre
       event memberRemoval() -> address:member

    8. changement d'événement nombre de confirmations à exécuter
       event requiredConfirmationCountChange() -> uint256:count

    9. ajouter un membre
       execute addMember(address:member) -> void:value

    10. suppression de membre
       execute removeMember(address:member) -> void:value

    11. remplacement de membre
       execute replaceMember(address:currentMember, address:newMember) -> void:value

    12. modification du nombre de confirmations obligatoires d'exécution
       execute changeRequiredConfirmationCount(uint256:count) -> void:value


  3. Interface de hiérarchie
    1. obtenir une liste de portefeuilles pour enfants
       static getChildren() -> address[]:wallets

    2. vérifier si l'adresse du portefeuille est un enfant de l'actuelle
       static isChild() -> bool:value

    3. Vérifier si l'adresse du portefeuille est parentale à l'adresse actuelle se fait via isChild en la contrastant.
    4. événement de fixation de portefeuille d'affiliation
       event childAttachment() -> [address:address,uint256:timeStamp]

    5. événement de suppression de portefeuille enfant
       event childRemoval() -> [address:address,uint256:timeStamp]

    6. apposer un portefeuille enfant
       execute attachChild(addres:child) -> void:value

    7. supprimer le portefeuille enfant
       execute removeChild(address:address) -> void:value

    8. changer un portefeuille enfant à un autre
       execute replaceChild(address:newAddress) -> void:value


  4. Interface de transaction
    1. vérifier l'état de la transaction
       static getTransactionStatus(uint256:transactionId) -> enum:{submitted,completed,frozen,disputed,reverted}

    2. vérification de la conformité de l'état des transactions
       static isTransactionStatus(uint256:transactionId, uint256:enumStatusNumber) -> bool:value

    3. vérification de la confirmation de transaction à l'adresse du participant
       static getConfirmationByAddress(uint256:transactionId, address:addressMember) -> bool:value

    4. obtenir des informations d'une transaction
       static getTransactionInfo(uint256:transactionId) -> [address:destination, uint256:value, bytes:data, bool:executed]

    5. obtenir le nombre total de transactions dans le portefeuille
       static getTransactionCount() -> uint256:value

    6. recevoir le statut de confirmation de transaction
       static isConfirmed(uint256:transactionId) -> bool:value

    7. recevoir le nombre de confirmations
       static getConfirmationCount(uint256:transactionId) -> uint256:count

    8. obtenir le nombre de transactions par type
       static getTransactionCount(bool:pending, bool:executed) -> uint256:count

    9. obtenir la liste des participants qui ont confirmé la transaction
       static getConfirmations(uint256:transactionId) -> address[]:confirmations

    10. obtenir du temps pour la confirmation automatique
       static getTimeAutoConfirmation(uint256:transactionId) -> uint256:timestamp

    11. obtenir une liste d'ID de transaction par type dans un certain laps de temps
       static getTransactionIds(uint256:from, uint256:to, bool:pending, bool:executed) -> uint256[]:transactionIds

    12. événement de confirmation de transaction de partie
       event Confirmation() -> [address:sender, uint256:transactionId, uint256:timeStamp]

    13. événement de confirmation automatique de transaction
       event AutoConfirmation() -> [uint256:transactionId, uint256:timeStamp]

    14. événement de retrait de confirmation du participant avant la transaction
       event Revocation() -> [address:sender, uint256:transactionId, uint256:timeStamp]

    15. transaction d'ajout de file d'attente événement
       event Submission() -> [uint256:transactionId]

    16. événement d'exécution de transaction
       event Execution() -> [uint256:transactionId]

    17. événement d'erreur de transaction
       event ExecutionFailure -> [uint256:transactionId]

    18. changement d'état de transaction en événement gelé
       event TransactionFrozen -> [uint256:transactionId]

    19. changement de statut de transaction en événement controversé
       event TransactionDisputed -> [uint256:transactionId]

    20. changement de statut de transaction en événement retourné
       event TransactionReverted -> [uint256:transactionId]

    21. événement de réapprovisionnement de portefeuille
       event Deposit -> [address:sender, uint256:amount]

    22. ajouter une transaction à exécuter
       execute submitTransaction(address:destination, uint256:value, uint256:TimeAutoConfirmation, bytes:data) -> uint256:transactionId

    23. confirmation de transaction
       execute confirmTransaction(uint256:transactionId) -> void:value

    24. confirmation de révocation
       execute revokeConfirmation(uint256:transactionId) -> void:value

    25. changer le statut de la transaction en gelé
       execute setTransactionStatus(uint256:transactionId, uint256:enumStatusNumber) -> void:value

    26. transaction manuelle
       execute executeTransaction(uint256:transactionId) -> void:value


  5. Gestion des notations
    1. obtenir une note à
       static getRatingByAddress(address:agent) -> [uint256:negativeRating, uint256:positiveRating, uint256:countRatingRecords]

    2. obtenir l'historique des évaluations par adresse et numéro de série
       static getRatingRecordForAddress(address:agent, uint256:indexNumber) -> void:value

    3. en cas d’ajout d’un enregistrement au classement
       event RatingRecordAdded -> [address:author, address:agent, bytes32:smartContractAddress, bool:positiveOrNegative, uin256:ratingNumber, bytes:comment, uint256:indexNumber]

    4. ajouter un enregistrement à l'évaluation de l'adresse
       execute addRatingRecord(address:agent, bytes32:smartContractAddress, bool:positiveOrNegative, uin256:ratingNumber, bytes:comment) -> void:value


  6. Intégration avec le protocole ESCB9
    1. vérifier à l'adresse si le contrat intelligent attaché à ce portefeuille est un contrat intelligent avec implémentation ESCB9
        static isAttachedESCB9SmartContract(address:smartContract) -> bool:result

    2. vérifier l'état du dépôt pour un contrat intelligent avec ESCB9 attaché à ce portefeuille
        static getDepositStatusForESCB9SmartContract(address:smartContract) -> enum:{awaiting,founded,returned}

    3. en cas d'attachement d'un contrat intelligent avec la mise en œuvre du portefeuille ESCB9
       event AttachingESCB9SmartContract -> [address:smartContract]

    4. événement de dépôt pour un contrat intelligent avec mise en œuvre du portefeuille ESCB9 attaché
       event ConfirmationForDepositESCB9SmartContract -> [address:smartContract, uint256:sum, bytes:notice]

    5. attacher un contrat intelligent avec la mise en œuvre de ESCB9 au portefeuille
       execute attachESCB9SmartContract(address:smartContract) -> void:value

    6. confirmation de dépôt pour contrat intelligent avec mise en œuvre ESCB9. Si le dépôt est dans le système externe, l'avis aura une étiquette. Si le dépôt est en ETH, le montant du dépôt est envoyé lorsque la méthode est exécutée.
       execute fundDepositForESCB9SmartContract(address:smartContract, uint256:sum, bytes:notice) -> void:value




5 flux d'interaction


Tout contrat intelligent peut être intégré dans la hiérarchie des portefeuilles multi-signatures. Une telle intégration aura des flux d'interactions. De manière générale, on distingue plusieurs types de flux:
  • Standard . Sous cette forme, la transaction a lieu automatiquement. Sans la participation des membres autorisés de la hiérarchie des portefeuilles.
  • Protégé . Sous cette forme, le temps de transaction peut être augmenté de la norme de confirmation automatique de l'heure au nécessaire. Dans ce cas, la participation des membres autorisés de la hiérarchie du portefeuille est nécessaire.
  • Controverse . Dans ce formulaire, le participant à la transaction peut geler la transaction. Dans ce cas, la participation des membres autorisés de la hiérarchie du portefeuille est nécessaire pour parvenir à un consensus.

Chaque portefeuille du système de fiducie compte un certain nombre de participants plénipotentiaires, qui rendent un verdict. Pour un raisonnement simple, nous allons combiner tous les participants autorisés dans le portefeuille en un seul concept - l' arbitre .

5.1 Flux d'interaction standard


Pour simplifier la présentation, nous apportons les concepts de biens et services au concept d'objet de transfert (objet), et le concept de monnaie fiduciaire, les crypto-monnaies au concept de moyen de transfert (moyen).
La contrepartie, le propriétaire de l'objet conclut un accord avec la contrepartie, le propriétaire des fonds, à des fins d'échange. Dans ce cas, le propriétaire de l'objet crée un contrat d'entiercement intelligent en envoyant une transaction standardisée à l'un des portefeuilles autorisés dans la hiérarchie des portefeuilles multi-signatures. Dans ce cas, la transaction est enregistrée par un tiers en tant que système de confiance. Pour chaque transaction, l'heure standard de son exécution est déterminée. La contrepartie, le propriétaire des fonds, effectue un dépôt sur la transaction en transférant des fonds dans le système de fiducie. Après cela, le propriétaire de l'objet transfère l'objet au propriétaire des fonds. Le propriétaire des fonds vérifie la qualité de l'objet. Si avant la fin du temps de la transaction, il n'a pas confirmé la qualité, les fonds sont transférés au propriétaire de l'objet dans le cadre de la transaction. Les deux contreparties se donnent mutuellement des notes de confort. Ainsi, le propriétaire des fonds peut modifier le flux d'interaction jusqu'à ce que la transaction soit terminée. Après le transfert de fonds au propriétaire de l'objet, le propriétaire des fonds peut demander un porte-monnaie supérieur au niveau de la hiérarchie pour résoudre les litiges dans le délai spécifié par le règlement. Passé ce délai, les notations de la transaction sont appliquées aux deux parties et la transaction devient irrévocable.

5.2 Flux d'interaction sécurisé


Si, pour des raisons indépendantes de la volonté des contreparties, le délai de transaction doit être prolongé, alors, d'un commun accord des parties, le portefeuille de hiérarchie multi-signatures (arbitre) peut modifier le délai imparti pour la transaction. Après avoir modifié l'heure, le flux d'interaction alloué à la transaction revient au niveau logique du flux standard.

5.3 Flux d'interaction controversé


Si la qualité de l'objet lors de la transaction ne convient pas à la contrepartie, propriétaire des fonds qu'il contribue au système de confiance de la hiérarchie des portefeuilles multi-signatures, la transaction peut être gelée. Dans ce cas, le dépôt n'est pas transféré à la contrepartie, propriétaire de l'objet jusqu'à ce qu'un verdict sur la transaction soit émis. Le détenteur des fonds doit fournir des preuves substantielles à l'arbitre de la transaction. Après cela, l'arbitre rend un verdict en faveur de l'une des contreparties. Si une partie à la transaction n'est pas satisfaite du verdict, elle se tourne vers un portefeuille supérieur dans l'ordre de la hiérarchie des portefeuilles multi-signatures. Après avoir passé toutes les instances de la hiérarchie, chaque partie peut demander un vote public. Cette mesure exceptionnelle ne peut être attribuée que par un sac à main absolu.

6 Protocole ESCB9


Un exemple du protocole ESCB9 dans Solidity en tant que contrat intelligent abstrait (le protocole est en cours de développement et est susceptible de changer)
 contract ESCB9 { /** * Modificator for arbitrage */ modifier onlyArbitrage() { require(msg.sender == arbitrage()); _; } /** * Modificator for checking deposit status */ modifier isDeposited { uint i; bytes memory _funcName = bytes4(keccak256("getDepositStatusForESCB9SmartContract(address)")); bytes memory _concat = new bytes(_funcName.length + 32); for(i=0; i < address(this).length; i++) { _concat[i] = address(this)[i]; } require(arbitrage().call.value(0)(_concat) == 1); // “founded” for enum _; } event confirmed(uint256 unixtimestamp, bytes32 notice); event frozen(uint256 unixtimestamp, bytes32 notice); event disputed(uint256 unixtimestamp, bytes32 notice); event canceled(uint256 unixtimestamp, bytes32 notice); /** * @notice Function to approve escrow deal and confirm success * @return Success of operation **/ function confirm(notice) public onlyArbitrage returns(bool); /** * @notice Function to freeze escrow deal * @return Success of operation **/ function freeze(notice) public onlyArbitrage returns(bool); /** * @notice Function to dispute escrow deal * @return Success of operation **/ function dispute(notice) public onlyArbitrage returns(bool); /** * @notice Function to cancel escrow deal and confirm fail * @return Success of operation **/ function cancel(notice) public onlyArbitrage returns(bool); /** * @notice Function to get seller's address * @return Seller's address **/ function seller() public returns(address); /** * @notice Function to get custom type for ESCB9 smart contract * @return Type **/ function type() public returns(bytes); /** * @notice Function to get buyer's address * @return Buyer's address **/ function buyer() public returns(address); /** * @notice Function to get sum for deal * @return Sum of deal in wei **/ function depositedSum() public returns(uint256); /** * @notice Function to get arbitrage's address * @return Arbitrage's address **/ function arbitrage() public returns(address); }


7 Intégration d'un système de confiance et de contrats intelligents mettant en œuvre le protocole ESCB9


Pour utiliser le système de confiance de la hiérarchie des portefeuilles multi-signatures dans votre propre projet, vous devez créer un contrat intelligent qui implémente la norme ESCB9 et attacher un tel contrat intelligent à l'un des arbitres qui n'a pas de portefeuilles subsidiaires. Ces portefeuilles dans une hiérarchie à abonnements multiples sont appelés «nœuds d'entrée». Tous les portefeuilles multi-signatures en amont sont appelés «nœuds d'arbitrage».

8 Exemples de contrats mettant en œuvre le SEBC9


8.1 Contrat intelligent pour le marché locatif privé, à l'instar d'AirBnb


 // Don't use this code, it can be not working or contain the vulnerability, for demonstration purpose only pragma solidity ^0.4.21; /// @title rentMyApartmentESCB9 - Allows rent object on market with escrow service. The safe way to do deal for counterparties. /// @author Konstantin Viktorov - <ceo@escrowblock.net> contract rentMyApartmentESCB9 is ESCB9 { // 2018-05-10 18:25 in unix timestamp uint256 constant public checkInTime = 1525965900; // 2018-05-20 18:25 in unix timestamp uint256 constant public checkOutTime = 1526829900; // Coordinates in bytes format. For example 56.865129,35.881540 bytes constant public coordinates = "0x35362e3836353132392c33352e383831353430"; // Google maps link, as example, but better add Url to landing page bytes constant public externalUrl = "0x68747470733a2f2f676f6f2e676c2f6d6170732f6e783563396b6737384170"; /** * Encrypted information, see https://github.com/ethereumjs/ethereumjs-wallet and * https://github.com/pubkey/eth-crypto/blob/master/tutorials/encrypted-message.md * For example you can leave here information about pin-code for smart lock **/ bytes constant private privateInformation = '0x0dfef623523483245687234'; modifier only_before_check_in { require(getNow() < checkInTime); _; } modifier only_after_check_out { require(getNow() > checkOutTime); _; } modifier only_during_renting { require(getNow() > checkInTime && getNow() < checkOutTime); _; } modifier only_not_in_during_renting { require(getNow() < checkInTime && getNow() > checkOutTime); _; } /** * @notice ESCB9 interface * @notice Function to get address of apartment owner * @return Seller's address **/ function seller() public returns(address) { return "0x27a36731337cdee360d99b980b73e24f6e188618"; } /** * @notice ESCB9 interface * @notice Function to get custom type for ESCB9 smart contract * @return Type **/ function type() public returns(bytes) { return "rent"; } /** * @notice ESCB9 interface * @notice Function to get address of renter * @return Buyer's address **/ function buyer() public returns(address) { return "0xb582baaF7e749d6aA98A22355A9d08B4c4d013C8"; } /** * @notice ESCB9 interface * @notice Function to get sum for deal * @return Sum of deal in wei **/ function depositedSum() public returns(uint256) { return 1000000000000000000; //1 ETH in weis } /** * @notice ESCB9 interface * @notice Function to get arbitrage's address * @return Arbitrage's address **/ function arbitrage() public returns(address) { return "0xe91065d8bb2392121a8fbe6a81e79782fbc89dd4"; } /** * @notice ESCB9 interface * @notice Function to approve escrow deal and confirm success * @param Some comment * @return Success of operation **/ function confirm(notice) public onlyArbitrage only_after_check_out returns(bool) { confirmed(getNow(), notice); } /** * @notice ESCB9 interface * @notice Function to freeze escrow deal * @param Some comment * @return Success of operation **/ function freeze(notice) public onlyArbitrage only_during_renting returns(bool) { frozen(getNow(), notice); } /** * @notice ESCB9 interface * @notice Function to dispute escrow deal * @return Success of operation **/ function dispute() public onlyArbitrage only_after_check_out returns(bool) { disputed(getNow(), notice); } /** * @notice ESCB9 interface * @notice Function to cancel escrow deal and confirm fail * @return Success of operation **/ function cancel() public onlyArbitrage only_not_in_during_renting returns(bool) { canceled(getNow(), notice); } /** * @notice Get current unix time stamp **/ function getNow() constant public returns (uint) { return now; } /** * @notice Get private information when renter will pay deposit **/ function getPrivateInformation() constant isDeposited public returns (bytes) { return privateInformation; } }


8.2 Un contrat intelligent pour échanger n'importe quelle crypto-monnaie contre de la monnaie fiduciaire en retour en mode décentralisé


L'exemple de contrat Smart décrit ci-dessous vous permet d'échanger BTC contre de l'argent fiduciaire directement, sans la participation d'échangeurs et de services tiers. Le vendeur BTC transfère le montant du contrat intelligent au dépôt dans la blockchain BTC. L'acheteur, après confirmation de l'acompte par l'arbitre, transfère automatiquement le montant prévu au contrat sur le compte ou le numéro de carte plastique inclus dans le contrat. L'arbitre peut intervenir dans le processus de transaction après l'appel de l'un des participants. Initialement, le dépôt sera gelé et si les parties ne s'entendent pas par consensus, alors un tel contrat deviendra contesté avec une résolution supplémentaire sur le flux d'interaction contestée.
 // Don't use this code, it can be not working or contain the vulnerability, for demonstration purpose only pragma solidity ^0.4.21; /// @title p2pExchangeESCB9 - Allows exchanging any cryptocurrencies on fiat money and back, directly between users. The safe way to do deal for counterparties. /// @desc This example shows as exchange fiat money on BTC (forward flow) /// @author Konstantin Viktorov - <ceo@escrowblock.net> contract p2pExchangeESCB9 is ESCB9 { // in minimal decimals, for example, 500.000 rubles is equal 50000000 kopeks uint256 constant public inputAmount = 50000000; // RUR in bytes bytes constant public inputCurrency = "0x525552"; // in minimal decimals, for example, 1 BTC is equal 100000000 satoshi uint256 constant public outputAmount = "100000000"; // BTC in bytes bytes constant public outputCurrency = "0x425443"; // Deposit can be place only before this time const bytes public closeTime = "1526829900"; // use "forward" way, when output currency will be deposited or "backward" if input currency will be deposited uint256 constant public depositWay = "forward"; /** * Encrypted information, see https://github.com/ethereumjs/ethereumjs-wallet and * https://github.com/pubkey/eth-crypto/blob/master/tutorials/encrypted-message.md **/ /** * Encrypted information for placing deposit, for example BTC address **/ bytes private externalDepositAddress = "0x3139333978476346484d6f464b465845564754415761706b3537694e6a3579556b52"; /** * Encrypted information for the amount of deposit, for example for BTC 8 decimals can be added 2-3 chars from 0-9 as pin-code for deal. See more in EscrowBlock WhitePaper * If output amount is equal 100000000, then deposited amount can be 100000123 **/ bytes private externalDepositAmount = "0x5f5e17b"; /** * Encrypted information for sending amount to seller, for example credit card number or bank account, for example 4242424242424242 **/ bytes private externalIncomingAddress = "0xf12765df4c9b2"; modifier only_before_close_time { require(getNow() < closeTime); _; } modifier only_after_close_time { require(getNow() > closeTime); _; } /** * @notice ESCB9 interface * @notice Function to get address of apartment owner * @return Seller's address **/ function seller() public returns(address) { return "0x27a36731337cdee360d99b980b73e24f6e188618"; } /** * @notice ESCB9 interface * @notice Function to get custom type for ESCB9 smart contract * @return Type **/ function type() public returns(bytes) { return "exchange"; } /** * @notice ESCB9 interface * @notice Function to get address of renter * @return Buyer's address **/ function buyer() public returns(address) { return "0xb582baaF7e749d6aA98A22355A9d08B4c4d013C8"; } /** * @notice ESCB9 interface * @notice Function to get sum for deal * @return Sum of deal in minimal decimals **/ function depositedSum() public returns(uint256) { rerurn outputAmount; } /** * @notice ESCB9 interface * @notice Function to get arbitrage's address * @return Arbitrage's address **/ function arbitrage() public returns(address) { return "0xe91065d8bb2392121a8fbe6a81e79782fbc89dd4"; } /** * @notice ESCB9 interface * @notice Function to approve escrow deal and confirm success * @param Some comment * @return Success of operation **/ function confirm(notice) public onlyArbitrage only_after_close_time returns(bool) { confirmed(getNow(), notice); } /** * @notice ESCB9 interface * @notice Function to freeze escrow deal * @param Some comment * @return Success of operation **/ function freeze(notice) public onlyArbitrage only_after_close_time returns(bool) { frozen(getNow(), notice); } /** * @notice ESCB9 interface * @notice Function to dispute escrow deal * @return Success of operation **/ function dispute() public onlyArbitrage only_after_close_time returns(bool) { disputed(getNow(), notice); } /** * @notice ESCB9 interface * @notice Function to cancel escrow deal and confirm fail * @return Success of operation **/ function cancel() public onlyArbitrage only_before_close_time returns(bool) { canceled(getNow(), notice); } /** * @notice Get current unix time stamp **/ function getNow() constant public returns (uint) { return now; } /** * @notice Get private information for buyer when seller sent deposit **/ function getExternalIncomingAddress() constant isDeposited public returns (bytes) { return externalIncomingAddress; } /** * @notice Get private information about amount for seller for sending deposit **/ function getExternalDepositAmount() constant public returns (bytes) { return externalDepositAmount; } /** * @notice Get private information about address for seller for sending deposit **/ function getExternalDepositAddress() constant public returns (bytes) { return externalDepositAddress; } }


9 nœuds d'arbitrage


Pour maintenir le travail du système de confiance, une hiérarchie de portefeuilles multi-signatures est introduite. Les nœuds d'arbitrage, c'est-à-dire les portefeuilles de la hiérarchie qui ont des portefeuilles subsidiaires sous eux, agissent comme garants du règlement des différends. Les plénipotentiaires de ces nœuds ne peuvent être nommés que par une hiérarchie supérieure. Chaque participant autorisé reçoit une récompense en distribuant des dividendes et des bonus pour travailler avec des flux d'interaction contestés. La taille du bonus est déterminée par consensus.
Pour obtenir le statut de participant autorisé dans un nœud d'arbitrage, il est nécessaire d'avoir une quantité de jetons définie par consensus à l'adresse d'un participant autorisé.Ainsi, la réception stable des dividendes par tous les participants des nœuds d'arbitrage est garantie. Plus la hiérarchie d'un portefeuille multi-signatures est élevée, plus les jetons nécessaires doivent être présents à l'adresse d'un participant autorisé.

10 Dictionnaire


Ethereum est une technologie open source qui vous permet de créer une chaîne de transactions décentralisée et immuable. Chaque transaction peut être effectuée avec certaines conditions enregistrées dans un contrat intelligent.
Contrat intelligent - écrit en Solidity, la logique exécutée dans la machine virtuelle Ethereum, qui vous permet d'étendre la logique de transaction.
Un portefeuille multi-signatures (arbitre) est un contrat intelligent spécial contrôlé par un groupe de participants autorisés qui peuvent confirmer ou annuler des transactions. En utilisant le mécanisme des portefeuilles à abonnements multiples, vous pouvez créer une chaîne de passerelles pour les transactions et surveiller en temps opportun l'exécution ou le remboursement.
Le propriétaire d'un objet - est un propriétaire, un fournisseur, un développeur d'un logiciel, etc. C'est-à-dire une personne qui met en œuvre l'objet et reçoit finalement un dépôt en récompense.
Le propriétaire des fonds - est un locataire, un acheteur, un client d'un produit logiciel, etc. C'est-à-dire une personne qui dépose un dépôt sur un objet pour acheter un produit ou un service.

Source: https://habr.com/ru/post/fr412655/

More articles:


All Articles