🍖 🕗 🗝️ Hierarquia de carteira com várias assinaturas (sistema de confiança) ⭕️ 🌉 ⭕️

Este texto descreve a abstração de um sistema de confiança, que permite integrar serviços de garantia em qualquer área das relações econômicas.
Depositar fundos é uma parte fundamental de qualquer transação. Se as contrapartes não souberem informações confiáveis, o risco de fraude aumenta. Essa abordagem permite programar em uma rede descentralizada um modelo de resolução de disputas, um modelo para realizar transações automáticas, transações seguras, etc. Além disso, esse modelo de sistema de confiança está aberto. Todas as transações realizadas com a participação da hierarquia de carteiras com várias assinaturas nos permitem verificar a classificação da contraparte e nos proteger de esquemas fraudulentos de novos participantes em relações econômicas.

Conteúdo

1 Introdução
2 Descrição de uma carteira com várias assinaturas
3 maneiras de construir uma hierarquia de carteira
4 Interface de hierarquia de carteira de vários dias
5 fluxos de interação
5.1 Fluxo de interação padrão
5.2 Fluxo de interação seguro
5.3 Fluxo controverso de interação
6 Protocolo ESCB9
7 Integração de um sistema de confiança e contratos inteligentes que implementam o protocolo ESCB9
8 Exemplos de contratos que implementam o SEBC9
8.1 Contrato inteligente para o mercado de aluguel privado, seguindo o exemplo do AirBnb
8.2 Um contrato inteligente para troca de qualquer criptomoeda por dinheiro fiduciário e de volta em um modo descentralizado
9 nós de arbitragem
10 Dicionário

1. Introdução

O principal problema para os serviços de garantia é a criação de relações de confiança entre todos os participantes. Além disso, os próprios participantes não devem ser necessariamente conhecidos por cada sujeito das relações. Para resumir todos os casos, levaremos em conta que todos são anônimos. Para um sistema de relações tão confiante, é importante regular as relações dos novos participantes com os antigos. Os participantes antigos já têm uma certa classificação no sistema de relações e, portanto, causam mais confiança. Como ninguém conhece ninguém no sistema de confiança, isso causa problemas na verificação da classificação anterior. Este documento descreve o sistema confiável com base em cripto-carteiras com várias assinaturas. Esse sistema pode ser programado em um contrato inteligente. Tendo em vista a ampla distribuição da plataforma Ethereum, escolheremos essa plataforma como a plataforma para descrever todos os contratos inteligentes neste documento.

2. Descrição de uma carteira com várias assinaturas

Uma abstração que permite confirmar ou cancelar transações somente se for alcançado um consenso entre os participantes autorizados para tomar essa decisão é chamada carteira com várias assinaturas. Uma transação neste contexto é uma operação atômica programada para executar um método em outro ou no mesmo contrato inteligente.

A interface para o contrato Smart de tal abstração pode ser representada como:

o construtor aceita os endereços dos membros fundadores e o número de confirmações mínimas necessárias para transações
```
constructor(address[]:members, uint256:requiredConfirmationCount) 
```

Interface do participante autorizado

obtendo uma lista de participantes

 static getMembers() -> address[]:address

ver endereço do membro

 static getMember(uint256:indexNumber) -> address:address

verificação do endereço da associação

 static isMember(address:address) -> bool:value

obtendo o número máximo de participantes para a carteira
```
 static getMaxMemberCount() -> uint256:value 
```

Confirmação mínima de consenso

 static getRequiredConfirmationCount() -> uint256:value

evento de adição de um novo membro

 event MemberAddition() -> address:member

evento de exclusão de membro

 event MemberRemoval() -> address:member

evento de alteração exigido número de confirmações para executar
```
 event RequiredConfirmationCountChange() -> uint256:count 
```

adicionar membro

 execute addMember(address:member) -> void:value

exclusão de membro

 execute removeMember(address:member) -> void:value

substituição de membro

 execute replaceMember(address:currentMember, address:newMember) -> void:value

alteração no número de confirmações obrigatórias para execução

 execute changeRequiredConfirmationCount(uint256:count) -> void:value

Interface de transação

verificação da confirmação da transação no endereço do participante

 static getConfirmationByAddress(uint256:indexNumber, address:addressMember) -> bool:value

obtendo informações de uma transação

 static getTransactionInfo(uint256:indexNumber) -> [address:destination, uint256:value, bytes:data, bool:executed]

obtendo o número total de transações nesta carteira
```
 static getTransactionCount() -> uint256:value 
```

recebendo status de confirmação da transação

 static isConfirmed(uint256:transactionId) -> bool:value

recebendo o número de confirmações

 static getConfirmationCount(uint256:transactionId) -> uint256:count

obtendo o número de transações por tipo

 static getTransactionCount(bool:pending, bool:executed) -> uint256:count

obtendo a lista de participantes que confirmaram a transação

 static getConfirmations(uint256:transactionId) -> address[]:confirmations

obtendo uma lista do ID da transação por tipo em um determinado período de tempo

 static getTransactionIds(uint256:from, uint256:to, bool:pending, bool:executed) -> uint256[]:transactionIds

evento de confirmação de transação da parte

 event Confirmation() -> [address:sender, uint256:transactionId, uint256:timeStamp]

evento de retirada de confirmação do participante antes da transação

 event Revocation() -> [address:sender, uint256:transactionId, uint256:timeStamp]

evento de adição de transação da fila

 event Submission() -> [uint256:transactionId]

evento de execução da transação

 event Execution() -> [uint256:transactionId]

evento de erro de transação

 event ExecutionFailure -> [uint256:transactionId]

evento de reabastecimento de carteira

 event Deposit -> [address:sender, uint256:amount]

membro adicionando transação

 execute submitTransaction(address:destination, uint256:value, bytes:data) -> uint256:transactionId

confirmação de transação pelo participante

 execute confirmTransaction(uint256:transactionId) -> void:value

retirada da confirmação pelo participante

 execute revokeConfirmation(uint256:transactionId) -> void:value

transação manual

 execute executeTransaction(uint256:transactionId) -> void:value

3 maneiras de construir uma hierarquia de carteira

Existem duas maneiras principais de construir um sistema de confiança. Vertical e horizontal. A maneira horizontal de construir implica a criação de uma lista de carteiras filho por um pai principal. A maneira vertical de construir implica uma cadeia que consiste em carteiras filho com referência ao pai. Nesse caso, a carteira pai pode ser filha de outra carteira pai.
Como vemos, o caminho de construção horizontal pode ser uma subespécie do caminho de construção vertical. Portanto, ainda mais deixamos essa abordagem sem supervisão.

4 Interface de hierarquia de carteira de vários dias

Para construir um sistema de confiança, é necessário expandir a interface simples da carteira de várias assinaturas descrita acima, adicionando mecanismos para regular a hierarquia e a execução automática de confirmações, bem como a possibilidade de execução diferida.

O construtor aceita o endereço da carteira principal, os endereços dos membros fundadores, o número de confirmações mínimas necessárias para transações, o tempo padrão para confirmações automáticas em segundos
```
 constructor(address:parent, address[]:members, uint256:requiredConfirmationCount, uint256:standardTimeAutoConfirmation) 
```

Interface de Membro

obtendo uma lista de participantes

 static getMembers() -> address[]:address

para visualizar o endereço do participante

 static getMember(uint256:indexNumber) -> address:address

verificação do endereço da associação

 static isMember(address:address) -> bool:value

obtendo o número máximo de participantes da carteira
```
 static getMaxMemberCount() -> uint256:value 
```

Confirmação mínima de consenso

 static getRequiredConfirmationCount() -> uint256:value

evento de adição de um novo membro

 event memberAddition() -> address:member

evento de exclusão de membro

 event memberRemoval() -> address:member

evento de alteração exigido número de confirmações para executar
```
 event requiredConfirmationCountChange() -> uint256:count 
```

adicionar membro

 execute addMember(address:member) -> void:value

exclusão de membro

 execute removeMember(address:member) -> void:value

substituição de membro

 execute replaceMember(address:currentMember, address:newMember) -> void:value

alteração no número de confirmações obrigatórias para execução

 execute changeRequiredConfirmationCount(uint256:count) -> void:value

Interface de hierarquia
1. recebendo uma lista de carteiras filho
```
 static getChildren() -> address[]:wallets 
```
2. verifique se o endereço da carteira é filho do endereço atual
```
 static isChild() -> bool:value 
```
3. A verificação se o endereço da carteira é parental e o atual é feita através do isChild, contrastando-o.
4. evento de anexo da carteira da filial
```
 event childAttachment() -> [address:address,uint256:timeStamp] 
```
5. evento de remoção de carteira filho
```
 event childRemoval() -> [address:address,uint256:timeStamp] 
```
6. a aposição de uma carteira infantil
```
 execute attachChild(addres:child) -> void:value 
```
7. excluir carteira filho
```
 execute removeChild(address:address) -> void:value 
```
8. alterar uma carteira filho para outra
```
 execute replaceChild(address:newAddress) -> void:value 
```

Interface de transação

verificar o status da transação

 static getTransactionStatus(uint256:transactionId) -> enum:{submitted,completed,frozen,disputed,reverted}

verificando o status da transação quanto à conformidade

 static isTransactionStatus(uint256:transactionId, uint256:enumStatusNumber) -> bool:value

verificação da confirmação da transação no endereço do participante

 static getConfirmationByAddress(uint256:transactionId, address:addressMember) -> bool:value

obtendo informações de uma transação

 static getTransactionInfo(uint256:transactionId) -> [address:destination, uint256:value, bytes:data, bool:executed]

obtendo o número total de transações na carteira
```
 static getTransactionCount() -> uint256:value 
```

recebendo status de confirmação da transação

 static isConfirmed(uint256:transactionId) -> bool:value

recebendo o número de confirmações

 static getConfirmationCount(uint256:transactionId) -> uint256:count

obtendo o número de transações por tipo

 static getTransactionCount(bool:pending, bool:executed) -> uint256:count

obtendo a lista de participantes que confirmaram a transação

 static getConfirmations(uint256:transactionId) -> address[]:confirmations

recebendo tempo para confirmação automática

 static getTimeAutoConfirmation(uint256:transactionId) -> uint256:timestamp

obtendo uma lista do ID da transação por tipo em um determinado período de tempo

 static getTransactionIds(uint256:from, uint256:to, bool:pending, bool:executed) -> uint256[]:transactionIds

evento de confirmação de transação da parte

 event Confirmation() -> [address:sender, uint256:transactionId, uint256:timeStamp]

evento de confirmação automática de transação

 event AutoConfirmation() -> [uint256:transactionId, uint256:timeStamp]

evento de retirada de confirmação do participante antes da transação

 event Revocation() -> [address:sender, uint256:transactionId, uint256:timeStamp]

evento de adição de transação da fila

 event Submission() -> [uint256:transactionId]

evento de execução da transação

 event Execution() -> [uint256:transactionId]

evento de erro de transação

 event ExecutionFailure -> [uint256:transactionId]

mudança de status da transação para evento congelado
```
 event TransactionFrozen -> [uint256:transactionId] 
```
mudança do status da transação para evento controverso
```
 event TransactionDisputed -> [uint256:transactionId] 
```

mudança de status da transação para evento retornado

 event TransactionReverted -> [uint256:transactionId]

evento de reabastecimento de carteira

 event Deposit -> [address:sender, uint256:amount]

adicionar transação para executar

 execute submitTransaction(address:destination, uint256:value, uint256:TimeAutoConfirmation, bytes:data) -> uint256:transactionId

confirmação de transação

 execute confirmTransaction(uint256:transactionId) -> void:value

confirmação de revogação

 execute revokeConfirmation(uint256:transactionId) -> void:value

alterar o status da transação para congelado

 execute setTransactionStatus(uint256:transactionId, uint256:enumStatusNumber) -> void:value

transação manual

 execute executeTransaction(uint256:transactionId) -> void:value

Gerenciamento de Rating

obtendo uma classificação em

 static getRatingByAddress(address:agent) -> [uint256:negativeRating, uint256:positiveRating, uint256:countRatingRecords]

obtendo histórico de classificação por endereço e número de série

 static getRatingRecordForAddress(address:agent, uint256:indexNumber) -> void:value

evento de adição de um registro à classificação em

 event RatingRecordAdded -> [address:author, address:agent, bytes32:smartContractAddress, bool:positiveOrNegative, uin256:ratingNumber, bytes:comment, uint256:indexNumber]

adicionar registro à classificação do endereço

 execute addRatingRecord(address:agent, bytes32:smartContractAddress, bool:positiveOrNegative, uin256:ratingNumber, bytes:comment) -> void:value

Integração com o protocolo ESCB9
1. verificar no endereço se o contrato inteligente anexado a esta carteira é um contrato inteligente com a implementação do ESCB9
```
  static isAttachedESCB9SmartContract(address:smartContract) -> bool:result 
```
2. verificação do status do depósito para um contrato inteligente com o ESCB9 anexado a esta carteira
```
  static getDepositStatusForESCB9SmartContract(address:smartContract) -> enum:{awaiting,founded,returned} 
```
3. evento de anexar um contrato inteligente com a implementação da carteira ESCB9
```
 event AttachingESCB9SmartContract -> [address:smartContract] 
```
4. evento de depósito para contrato inteligente com implementação anexada à carteira ESCB9
```
 event ConfirmationForDepositESCB9SmartContract -> [address:smartContract, uint256:sum, bytes:notice] 
```
5. anexar um contrato inteligente com a implementação do ESCB9 à carteira
```
 execute attachESCB9SmartContract(address:smartContract) -> void:value 
```
6. confirmação de depósito para contrato inteligente com a implementação do ESCB9. Se o depósito estiver no sistema externo, o aviso terá um rótulo. Se o depósito estiver em ETH, o valor do depósito será enviado quando o método for executado.
```
 execute fundDepositForESCB9SmartContract(address:smartContract, uint256:sum, bytes:notice) -> void:value 
```

5 fluxos de interação

Qualquer contrato inteligente pode ser integrado à hierarquia de carteiras com várias assinaturas. Essa integração terá fluxos de interações. Em termos gerais, distinguimos vários tipos de fluxos:

Standard . Nesse formulário, a transação ocorre automaticamente. Sem a participação de membros autorizados da hierarquia da carteira.
Protegido . Neste formulário, o tempo da transação pode ser aumentado do padrão para confirmação automática do tempo para o necessário. Nesse caso, é necessária a participação de membros autorizados da hierarquia da carteira.
Controverso . Neste formulário, o participante da transação pode congelar a transação. Nesse caso, a participação de membros autorizados da hierarquia da carteira é necessária para criar consenso.

Cada carteira no sistema de confiança tem vários participantes plenipotenciários, que emitem um veredicto. Por um raciocínio simples, combinaremos todos os participantes autorizados da carteira em um conceito - o árbitro .

5.1 Fluxo de interação padrão

Para simplificar a apresentação, trazemos os conceitos de bens e serviços ao conceito de objeto de transferência (objeto) e ao conceito de moeda fiduciária, criptomoedas ao conceito de meio de transferência (meio).
A contraparte, o proprietário do objeto faz um acordo com a contraparte, o proprietário dos fundos, para fins de troca. Nesse caso, o proprietário do objeto cria um contrato de garantia inteligente enviando uma transação padronizada para uma das carteiras autorizadas na hierarquia de carteiras com várias assinaturas. Nesse caso, a transação é registrada por terceiros como um sistema de confiança. Para cada transação, o tempo padrão para sua execução é determinado. A contraparte, o proprietário dos fundos faz um depósito na transação transferindo fundos para o sistema de confiança. Depois disso, o proprietário do objeto transfere o objeto para o proprietário dos fundos. O proprietário dos fundos verifica a qualidade do objeto. Se, antes do final do tempo da transação, ele não confirmar a qualidade, os fundos serão transferidos para o proprietário do objeto como parte da transação. Ambas as contrapartes atribuem uma à outra classificações de conforto. Assim, o proprietário dos fundos pode alterar o fluxo de interação antes do final da transação. Após a transferência de fundos para o proprietário do objeto, o proprietário dos fundos pode aplicar a uma bolsa mais alta no nível hierárquico para resolver disputas dentro do prazo especificado pelo regulamento. Após esse período, as classificações da transação são aplicadas a ambas as partes e a transação se torna irrevogável.

5.2 Fluxo de interação segura

Se, por algumas razões fora do controle das contrapartes, o prazo para a transação for estendido, então, por acordo das partes, a carteira de hierarquia com várias assinaturas (árbitro) poderá alterar o tempo alocado para a transação. Após alterar a hora, o fluxo de interação alocado para a transação retorna ao nível lógico do fluxo padrão.

5.3 Fluxo controverso de interação

Se a qualidade do objeto durante a transação não se adequar à contraparte, o proprietário dos fundos que ele contribui para o sistema de confiança da hierarquia de carteiras com várias assinaturas, a transação poderá ser congelada. Nesse caso, o depósito não é transferido para a contraparte, o proprietário do objeto até que um veredicto sobre a transação seja emitido. O detentor dos fundos deve fornecer evidências substanciais ao árbitro da transação. Depois disso, o árbitro emite um veredicto a favor de uma das contrapartes. Se qualquer parte da transação não estiver satisfeita com o veredicto, ela se transformará em uma carteira mais alta na ordem na hierarquia de carteiras com várias assinaturas. Depois de todas as instâncias da hierarquia, qualquer uma das partes pode solicitar uma votação pública. Esta medida excepcional só pode ser atribuída por uma bolsa absoluta.

6 Protocolo ESCB9

Um exemplo do protocolo ESCB9 no Solidity como um contrato inteligente abstrato (o protocolo está em desenvolvimento e está sujeito a alterações)

 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 Integração de um sistema de confiança e contratos inteligentes que implementam o protocolo ESCB9

Para usar o sistema de confiança da hierarquia de carteiras com várias assinaturas em seu próprio projeto, você precisa criar um contrato inteligente que implemente o padrão ESCB9 e anexar um contrato inteligente a um dos árbitros que não possuem carteiras subsidiárias. Essas carteiras em uma hierarquia de várias assinaturas são chamadas de "nós de entrada". Todas as carteiras de assinaturas múltiplas a montante são chamadas de "nós de arbitragem".

8 Exemplos de contratos que implementam o SEBC9

8.1 Contrato inteligente para o mercado de aluguel privado, seguindo o exemplo do 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 Um contrato inteligente para troca de qualquer criptomoeda por dinheiro fiduciário e de volta em um modo descentralizado

O exemplo de um contrato Smart descrito abaixo permite trocar diretamente o BTC por dinheiro fiduciário, sem a participação de trocadores e serviços de terceiros. O vendedor do BTC transfere o valor do contrato inteligente para o depósito na blockchain do BTC. O comprador, após confirmar o depósito pelo árbitro, transfere automaticamente o valor estipulado no contrato para a conta ou o número do cartão plástico incluído no contrato. O árbitro pode intervir no processo de transação após a apelação de um dos participantes. Inicialmente, o depósito será congelado e, se as partes não concordarem por consenso, esse contrato será contestado com mais resolução sobre o fluxo da interação contestada.

 // 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ós de arbitragem

Para manter o trabalho do sistema de confiança, é introduzida uma hierarquia de carteiras com várias assinaturas. Nós de arbitragem, ou seja, tais carteiras na hierarquia que possuem carteiras subsidiárias, atuam como garantidores da resolução de disputas. Os plenipotenciários para esses nós só podem ser nomeados por uma hierarquia superior. Cada participante autorizado recebe uma recompensa distribuindo dividendos e bônus por trabalhar com fluxos disputados de interação. O tamanho do bônus é determinado por consenso.
Para obter o status de um participante autorizado em um nó de arbitragem, é necessário ter uma quantidade definida de consenso de tokens no endereço de um participante autorizado.Assim, é garantido o recebimento estável de dividendos por todos os participantes dos nós de arbitragem. Quanto maior a hierarquia de uma carteira com várias assinaturas, mais tokens devem estar presentes no endereço de um participante autorizado.

10 Dicionário

Ethereum é uma tecnologia de código aberto que permite criar uma cadeia de transações descentralizada e imutável. Cada transação pode ser realizada com determinadas condições registradas em um contrato inteligente.
Contrato inteligente - escrito em Solidity, a lógica executada na máquina virtual Ethereum, que permite expandir a lógica da transação.
Uma carteira com várias assinaturas (árbitro) é um contrato inteligente especial controlado por um grupo de participantes autorizados que podem confirmar ou cancelar transações. Usando o mecanismo de carteiras com várias assinaturas, você pode criar uma cadeia de gateways para transações e monitorar oportunamente a execução ou reembolso.
Dono de um objeto - é um proprietário, fornecedor, desenvolvedor de um produto de software, etc. Ou seja, uma pessoa que vende um objeto e, por fim, recebe um depósito como recompensa.
Dono de fundos - é um inquilino, comprador, cliente de um produto de software, etc. Ou seja, uma pessoa que deposita um objeto em um objeto para comprar um produto ou serviço.

Hierarquia de carteira com várias assinaturas (sistema de confiança)