KR20230107561A

KR20230107561A - 네트워크 내의 분산 데이터베이스를 위한 방법들 및 장치

Info

Publication number: KR20230107561A
Application number: KR1020237015347A
Authority: KR
Inventors: 리몬 씨. 3세 베어드
Original assignee: 헤데라 하쉬그라프, 엘엘씨
Priority date: 2020-10-06
Filing date: 2021-10-05
Publication date: 2023-07-17
Also published as: WO2022076429A1; AU2021358742A1; US20240111782A1; CN116615722A; JP2023544422A; US20220107960A1; EP4226257A1; CA3194984A1

Abstract

일부 실시예들에서, 방법은 분산 데이터베이스에 대한 주소록을 정의하는 단계를 포함한다. 주소록은 네트워크를 통해 분산 데이터베이스를 구현하는 컴퓨팅 디바이스들의 세트로부터의 각각의 컴퓨팅 디바이스에 대한 식별자를 포함한다. 이 방법은 컴퓨팅 디바이스들의 세트로부터의 컴퓨팅 디바이스로부터, 주소록을 업데이트하기 위한 트랜잭션을 포함하는 이벤트를 수신하는 단계 및 주소록을 이용하는 분산 데이터베이스의 컨센서스 프로토콜에 기반하여, 이벤트에 대한 수신된 라운드를 계산하는 단계를 더 포함한다. 이 방법은 이벤트에 대한 수신된 라운드 또는 주소록에 대한 이전 업데이트 중 적어도 하나 후에 미리 결정된 수의 라운드로 업데이트된 주소록을 정의하기 위해 트랜잭션에 기반하여 주소록을 업데이트하는 단계를 더 포함한다.

Description

네트워크 내의 분산 데이터베이스를 위한 방법들 및 장치

관련 출원들에 대한 상호 참조

본 출원은, 참조에 의해 그 전체를 본 명세서에 포함하는, 발명의 명칭이 "Methods and Apparatus for a Distributed Database within a Network"인 2020년 10월 6일에 출원된 미국 가출원 제63/088,298호의 우선권 및 그 혜택을 주장한다.

본 명세서에 설명된 실시예들은 일반적으로 데이터베이스 시스템에 관한 것으로, 더 상세하게는 네트워크 내의 다수의 디바이스들에 걸쳐 데이터베이스 시스템을 구현하기 위한 방법들 및 장치에 관한 것이다.

일부 알려진 분산 데이터베이스 시스템들은 분산 데이터베이스 시스템들 내의 값들(예컨대, 트랜잭션들이 발생하는 순서에 관한 것임)에 대한 컨센서스(consensus)를 달성하려고 시도한다. 예를 들어, 온라인 멀티플레이어 게임에는 사용자들이 게임을 플레이하기 위해 액세스할 수 있는 많은 컴퓨터 서버들이 있을 수 있다. 2명의 사용자가 동시에 게임 내의 특정 아이템을 집으려고 시도한다면, 분산 데이터베이스 시스템 내의 서버들이 2명의 사용자 중 어느 쪽이 아이템을 먼저 집었는지에 대해 결국 합의에 도달하는 것이 중요하다.

이러한 분산 컨센서스는 Paxos 알고리즘 또는 그 변형들과 같은 방법들 및/또는 프로세스들에 의해 핸들링될 수 있다. 이러한 방법들 및/또는 프로세스들에서, 데이터베이스 시스템의 하나의 서버가 "리더(leader)"로 설정되고 리더가 이벤트들의 순서를 결정한다. (예컨대, 멀티플레이어 게임들 내의) 이벤트들은 리더에게 전달되고, 리더는 이벤트들의 순서를 선택하고, 리더는 그 순서를 데이터베이스 시스템의 다른 서버들로 브로드캐스팅한다.

그러나, 이러한 알려진 접근법들은 데이터베이스 시스템의 사용자들(예컨대, 게임 플레이어들)에 의해 신뢰받는 당사자(예컨대, 중앙 관리 서버)에 의해 운영되는 서버를 이용한다. 따라서, 데이터베이스 시스템을 동작시키기 위해 리더 또는 신뢰되는 제3자를 필요로 하지 않는 분산 데이터베이스 시스템을 위한 방법들 및 장치에 대한 필요가 존재한다.

일부 실시예들에서, 방법은 분산 데이터베이스에 대한 주소록을 정의하는 단계를 포함한다. 주소록은 네트워크를 통해 분산 데이터베이스를 구현하는 컴퓨팅 디바이스들의 세트로부터의 각각의 컴퓨팅 디바이스에 대한 식별자를 포함한다. 이 방법은 컴퓨팅 디바이스들의 세트로부터의 컴퓨팅 디바이스로부터, 주소록을 업데이트하기 위한 트랜잭션을 포함하는 이벤트를 수신하는 단계 및 주소록을 이용하는 분산 데이터베이스의 컨센서스 프로토콜에 기반하여, 이벤트에 대한 수신된 라운드(round)를 계산하는 단계를 더 포함한다. 이 방법은 이벤트에 대한 수신된 라운드 또는 주소록에 대한 이전 업데이트 중 적어도 하나 후에 미리 결정된 수의 라운드로 업데이트된 주소록을 정의하기 위해 트랜잭션에 기반하여 주소록을 업데이트하는 단계를 더 포함한다.

도 1은 일 실시예에 따른, 분산 데이터베이스 시스템을 예시하는 상위 레벨 블록도이다.
도 2는 일 실시예에 따른, 분산 데이터베이스 시스템의 컴퓨팅 디바이스를 예시하는 블록도이다.
도 3 내지 도 6은 일 실시예에 따른, 해시그래프의 예들을 예시한다.
도 7은 일 실시예에 따른, 제1 컴퓨팅 디바이스와 제2 컴퓨팅 디바이스 사이의 통신 흐름을 예시하는 흐름도이다.
도 8은 일 실시예에 따른, 해시그래프의 예이다.
도 9는 일 실시예에 따른, 해시그래프의 예이다.
도 10a 및 도 10b는 일 실시예에 따른, 해시그래프와 함께 이용하기 위한 예시적인 컨센서스 방법을 예시한다.
도 11a 및 도 11b는 다른 실시예에 따른, 해시그래프와 함께 이용하기 위한 예시적인 컨센서스 방법을 예시한다.
도 12a 및 도 12b는 다른 실시예에 따른, 해시그래프와 함께 이용하기 위한 예시적인 컨센서스 방법을 예시한다.
도 13a 내지 도 13e는 다른 실시예에 따른, 해시그래프와 함께 이용하기 위한 예시적인 컨센서스 방법을 예시한다.
도 14는 일 실시예에 따른, 분산 데이터베이스 시스템과 연관된 주소록을 예시한다.
도 15는 일 실시예에 따른, 주소록을 업데이트하는 방법을 예시하는 흐름도이다.
도 16은 일 실시예에 따른, 컴퓨팅 디바이스가 분산 데이터베이스에 연결 및/또는 조인하는 방법을 예시하는 흐름도이다.

일부 실시예들에서, 장치는 컴퓨팅 디바이스들의 세트에 동작가능하게 결합된 네트워크를 통해 컴퓨팅 디바이스들의 세트에 의해 구현되는 분산 데이터베이스와 연관된 컴퓨팅 디바이스의 메모리, 및 메모리에 동작가능하게 결합된 프로세서를 포함한다. 프로세서는 분산 데이터베이스에 대한 주소록을 정의하도록 구성된다. 주소록은 분산 데이터베이스를 구현하는 컴퓨팅 디바이스들의 세트로부터의 각각의 컴퓨팅 디바이스에 대한 식별자를 포함한다. 프로세서는 컴퓨팅 디바이스들의 세트로부터의 컴퓨팅 디바이스로부터, 주소록을 업데이트하기 위한 트랜잭션을 포함하는 이벤트를 수신하고 이벤트들의 그룹으로부터의 각각의 이벤트에 대한 속성(예를 들어, 라운드 번호 또는 라운드 생성)을 계산하도록 구성된다. 이벤트는 이벤트들의 그룹에 포함된다. 프로세서는 주소록을 이용하는 분산 데이터베이스의 컨센서스 프로토콜에 기반하여, 이벤트의 수신된 라운드를 계산하도록 구성된다. 수신된 라운드는 이벤트의 후손들인 이벤트들의 세트로부터의 임계 수의 이벤트들에 기반할 수 있다. 프로세서는 이벤트에 대한 수신된 라운드 또는 주소록에 대한 이전 업데이트 중 적어도 하나 후에 미리 결정된 수의 라운드로 업데이트된 주소록을 정의하기 위해 트랜잭션에 기반하여 주소록을 업데이트하도록 추가로 구성된다. 프로세서는, 업데이트된 주소록을 이용하여, 그 이벤트가 이벤트들의 세트로부터의 후손 이벤트를 갖지 않을 때 이벤트들의 그룹으로부터의 각각의 이벤트에 대한 속성을 재계산하도록 구성된다.

일부 실시예들에서, 비일시적 프로세서 판독가능한 매체는 프로세서에 의해 실행될 명령어들을 나타내는 코드를 저장한다. 코드는 프로세서로 하여금, 네트워크를 통해, 분산 데이터베이스를 구현하는 컴퓨팅 디바이스들의 세트에 그리고 분산 데이터베이스를 구현하는 노드로서 연결하게 하는 코드를 포함한다. 코드는 프로세서로 하여금 컴퓨팅 디바이스들의 세트로부터의 컴퓨팅 디바이스로부터 컨센서스 프로토콜의 완료된 라운드와 연관된 분산 데이터베이스의 상태를 수신하게 하는 코드를 추가로 포함한다. 상태는 이벤트들의 코어 세트로부터의 각각의 이벤트에 대한 라운드 식별자와 함께 완료된 라운드와 연관된 이벤트들의 코어 세트의 표시를 포함한다. 코드는 프로세서로 하여금 컴퓨팅 디바이스들의 세트로부터 상태와 연관된 이벤트들의 세트를 수신하게 하고, 이벤트들의 코어 세트 및 이벤트들의 코어 세트로부터의 각각의 이벤트에 대한 라운드 식별자에 기반하여 이벤트들의 세트로부터의 각각의 이벤트에 대한 속성들의 세트를 계산하게 하는 코드를 추가로 포함한다. 코드는 프로세서로 하여금 이벤트들의 세트 및 이벤트들에 대한 속성들의 세트에 기반하여 방향성 비순환 그래프(directed acyclic graph)(DAG)를 구성하게 하고, DAG를 이용하여 컨센서스 프로토콜의 다음 라운드와 연관된 이벤트들의 순서를 계산하게 하는 코드를 포함한다.

일부 실시예들에서, 장치는 컴퓨팅 디바이스들의 세트에 동작가능하게 결합된 네트워크를 통해 분산 데이터베이스를 구현하는 컴퓨팅 디바이스들의 세트 내에 포함되도록 구성된 제1 컴퓨팅 디바이스에서 분산 데이터베이스의 인스턴스를 포함한다. 장치는 또한 분산 데이터베이스의 인스턴스를 저장한 메모리에 동작가능하게 결합된 프로세서를 포함한다. 프로세서는, 제1 시간에, 이벤트들의 제1 세트에 링크된 제1 이벤트를 정의하도록 구성된다. 프로세서는, 제1 시간 이후 제2 시간에, 그리고 컴퓨팅 디바이스들의 세트로부터의 제2 컴퓨팅 디바이스로부터, (1) 제2 컴퓨팅 디바이스에 의해 정의되고 (2) 이벤트들의 제2 세트에 링크된 제2 이벤트를 나타내는 신호를 수신하도록 구성된다. 프로세서는 적어도 프로토콜의 결과에 기반하여 이벤트들의 제3 세트와 연관된 순서를 식별하도록 구성된다. 이벤트들의 제3 세트로부터의 각각의 이벤트는 이벤트들의 제1 세트 또는 이벤트들의 제2 세트 중 적어도 하나로부터 유래된다. 프로세서는 이벤트들의 제3 세트와 연관된 순서를 분산 데이터베이스의 인스턴스에 저장하도록 구성된다.

일부 경우들에서, 이벤트들의 제3 세트로부터의 각각의 이벤트는 속성들의 세트(예컨대, 시퀀스 번호, 세대 번호, 라운드 번호, 수신된 라운드 번호, 및/또는 타임스탬프 등)와 연관된다. 프로토콜의 결과는 이벤트들의 제3 세트로부터의 각각의 이벤트에 대한 속성들의 세트로부터의 각각의 속성에 대한 값을 포함할 수 있다. 속성들의 세트로부터의 제1 속성에 대한 값은 제1 수치 값을 포함할 수 있고, 속성들의 세트로부터의 제2 속성에 대한 값은 제1 수치 값과 연관된 이진 값을 포함할 수 있다. 이벤트들의 제3 세트로부터의 이벤트에 대한 제2 속성에 대한 이진 값(예컨대, 라운드 증분 값)은 그 이벤트와 그 이벤트에 링크된 이벤트들의 제4 세트 사이의 관계가 기준(예컨대, 그 이벤트에 의해 강력하게 식별되는 이벤트들의 수)을 만족시키는지 여부에 기반할 수 있다. 이벤트들의 제4 세트로부터의 각각의 이벤트는 (1) 이벤트들의 제3 세트로부터의 이벤트의 조상이고 (2) 이벤트들의 제4 세트로부터의 나머지 이벤트들로서의 제1 공통 속성(예컨대, 공통 라운드 번호, 라운드 R 제1 이벤트임의 표시 등)과 연관된다. 제1 공통 속성은 컴퓨팅 디바이스들의 세트로부터의 각각의 컴퓨팅 디바이스에 의해 정의된 이벤트가 제1 특정 값(예컨대, 라운드 R 제1 이벤트임의 표시 등)과 연관되는 제1/초기 인스턴스를 나타낼 수 있다.

속성들의 세트로부터의 제3 속성(예컨대, 수신된 라운드 번호)에 대한 값은 이벤트와 이벤트에 링크된 이벤트들의 제5 세트 사이의 관계에 기반한 제2 수치 값을 포함할 수 있다. 이벤트들의 제5 세트로부터의 각각의 이벤트는 이벤트의 후손이고 이벤트들의 제5 세트로부터의 나머지 이벤트로서의 제2 공통 속성과 연관된다(예컨대, 유명하다). 제2 공통 속성은 (1) 컴퓨팅 디바이스들의 세트로부터의 각각의 컴퓨팅 디바이스에 의해 정의된 제2 이벤트가 제1 특정 값과는 상이한 제2 특정 값과 연관되는 제1 인스턴스를 나타내는 제3 공통 속성(예컨대, 라운드 R 제1 이벤트 또는 목격자임) 및 (2) 표시들의 세트에 기반한 결과와 연관될 수 있다. 표시들의 세트로부터의 각각의 표시는 이벤트들의 제6 세트로부터의 이벤트와 연관될 수 있다. 이벤트들의 제6 세트로부터의 각각의 이벤트는 컴퓨팅 디바이스들의 세트로부터의 각각의 컴퓨팅 디바이스에 의해 정의된 제3 이벤트가 제1 특정 값 및 제2 특정 값과는 상이한 제3 특정 값과 연관되는 제1/초기 인스턴스를 나타내는 제4 공통 속성과 연관될 수 있다. 일부 경우들에서, 제1 특정 값은 제1 정수(예컨대, 제1 라운드 번호 R)이고, 제2 특정 값은 제1 정수보다 큰 제2 정수(예컨대, 제2 라운드 번호, R+n)이고, 제3 특정 값은 제2 정수보다 큰 제3 정수(예컨대, 제3 라운드 번호, R+n+m)이다.

본 명세서에서 이용될 때, 모듈은 예를 들어 특정 기능을 수행하는 것과 연관된 동작가능하게 결합된 전기 컴포넌트들의 임의의 조립체 및/또는 세트일 수 있으며, 예를 들어 메모리, 프로세서, 전기 트레이스들, 광 커넥터들, (하드웨어에서 실행되는) 소프트웨어 등을 포함할 수 있다.

본 명세서에서 이용될 때, 단수 형태는 문맥상 명확하게 달리 지시하지 않는 한 복수의 지시 대상을 포함한다. 따라서, 예를 들어, 용어 "모듈"은 단일 모듈 또는 모듈들의 조합을 의미하도록 의도된다. 예를 들어, "네트워크"는 단일 네트워크 또는 네트워크들의 조합을 의미하도록 의도된다.

도 1은 일 실시예에 따른, 분산 데이터베이스 시스템(100)을 예시하는 상위 레벨 블록도이다. 도 1은 4개의 컴퓨팅 디바이스(컴퓨팅 디바이스(110), 컴퓨팅 디바이스(120), 컴퓨팅 디바이스(130) 및 컴퓨팅 디바이스(140))에 걸쳐 구현된 분산 데이터베이스(100)를 예시하지만, 분산 데이터베이스(100)는 도 1에 도시되지 않은 컴퓨팅 디바이스들을 포함하여 임의의 수의 컴퓨팅 디바이스들의 세트를 이용할 수 있다는 것을 이해해야 한다. 네트워크(105)는 유선 네트워크 및/또는 무선 네트워크로서 구현되고 컴퓨팅 디바이스들(110, 120, 130, 140)과 동작가능하게 결합하는데 이용되는 임의의 유형의 네트워크(예컨대, 로컬 영역 네트워크(LAN), 광역 네트워크(WAN), 가상 네트워크, 원격 통신 네트워크)일 수 있다. 본 명세서에서 더 상세히 설명된 바와 같이, 일부 실시예들에서, 예를 들어, 컴퓨팅 디바이스들은 인터넷 서비스 제공자(ISP) 및 인터넷(예컨대, 네트워크(105))을 통해 서로 연결된 개인용 컴퓨터들이다. 일부 실시예들에서, 임의의 2개의 컴퓨팅 디바이스들(110, 120, 130, 140) 사이에, 네트워크(105)를 통해, 연결이 정의될 수 있다. 도 1에 도시된 바와 같이, 예를 들어, 컴퓨팅 디바이스(110)와 컴퓨팅 디바이스(120), 컴퓨팅 디바이스(130), 또는 컴퓨팅 디바이스(140) 중 어느 하나 사이에 연결이 정의될 수 있다.

일부 실시예들에서, 컴퓨팅 디바이스들(110, 120, 130, 140)은 서로 그리고 중간 네트워크들 및/또는 대안적 네트워크들(도 1에 도시되지 않음)을 통해 네트워크와 통신(예컨대, 그에 데이터를 전송 및/또는 그로부터 데이터를 수신)할 수 있다. 이러한 중간 네트워크들 및/또는 대안적 네트워크들은 네트워크(105)와 동일한 유형 및/또는 상이한 유형의 네트워크일 수 있다.

각각의 컴퓨팅 디바이스(110, 120, 130, 140)는 하나 이상의 다른 컴퓨팅 디바이스에 데이터를 전송 및/또는 그로부터 데이터를 수신하기 위해 네트워크(105)를 통해 데이터를 전송하도록 구성된 임의의 유형의 디바이스일 수 있다. 컴퓨팅 디바이스들의 예들이 도 1에 도시되어 있다. 컴퓨팅 디바이스(110)는 메모리(112), 프로세서(111), 및 출력 디바이스(113)를 포함한다. 예를 들어, 메모리(112)는 랜덤 액세스 메모리(RAM), 메모리 버퍼, 하드 드라이브, 데이터베이스, 소거가능 프로그래밍가능한 판독 전용 메모리(EPROM), 전기적으로 소거가능 판독 전용 메모리(EEPROM), 판독 전용 메모리(ROM) 등을 포함할 수 있다. 일부 실시예들에서, 컴퓨팅 디바이스(110)의 메모리(112)는 분산 데이터베이스의 인스턴스(예컨대, 분산 데이터베이스 인스턴스(114))와 연관된 데이터를 포함한다. 일부 실시예들에서, 메모리(112)는 프로세서로 하여금 동기화 이벤트의 기록, 및/또는 다른 컴퓨팅 디바이스들과의 이전 동기화 이벤트들의 기록, 및/또는 동기화 이벤트들의 순서, 및/또는 이벤트들 내의 트랜잭션들의 순서, 동기화 이벤트들 및/또는 트랜잭션들의 순서를 식별하는 것과 연관된 파라미터들, 및/또는 파라미터에 대한 값(예컨대, 트랜잭션을 정량화하는 데이터베이스 필드, 이벤트들이 발생하는 순서를 정량화하는 데이터베이스 필드, 및/또는 값이 데이터베이스에 저장될 수 있는 임의의 다른 적합한 필드)을 분산 데이터베이스의 다른 인스턴스(예컨대, 컴퓨팅 디바이스(120)에서의 분산 데이터베이스 인스턴스(124))로 전송 및/또는 그로부터 수신하는 것과 연관된 모듈들, 프로세스들 및/또는 기능들을 실행하게 하는 명령어들을 저장한다.

분산 데이터베이스 인스턴스(114)는, 예를 들어, 데이터를 저장, 수정 및/또는 삭제하는 것을 포함하여, 데이터를 조작하도록 구성될 수 있다. 일부 실시예들에서, 분산 데이터베이스 인스턴스(114)는 어레이들의 세트, 데이터 구조들의 세트, 관계형 데이터베이스, 객체 데이터베이스, 사후-관계형 데이터베이스, 및/또는 임의의 다른 적합한 유형의 데이터베이스 또는 저장소일 수 있다. 예를 들어, 분산 데이터베이스 인스턴스(114)는 임의의 특정 기능 및/또는 산업과 관련된 데이터를 저장할 수 있다. 예를 들어, 분산 데이터베이스 인스턴스(114)는 특정 금융 상품의 소유권 이력과 관련된 값 및/또는 값들의 벡터를 포함하는 (예를 들어, 컴퓨팅 디바이스(110)의 사용자의) 금융 트랜잭션들을 저장할 수 있다. 일반적으로, 벡터는 파라미터에 대한 값들의 임의의 세트일 수 있고, 파라미터는 상이한 값들을 가질 수 있는 임의의 데이터 객체 및/또는 데이터베이스 필드일 수 있다. 따라서, 분산 데이터베이스 인스턴스(114)는 다수의 파라미터들 및/또는 필드들을 가질 수 있고, 그 각각은 값들의 벡터와 연관된다. 값들의 벡터는 그 데이터베이스 인스턴스(114) 내의 파라미터 및/또는 필드의 실제 값을 결정하는데 이용된다. 일부 경우들에서, 분산 데이터베이스 인스턴스(114)는 동기화 이벤트의 기록, 다른 컴퓨팅 디바이스들과의 이전 동기화 이벤트들의 기록, 동기화 이벤트들의 순서, 이벤트들 내의 트랜잭션들의 순서, 동기화 이벤트들 및/또는 트랜잭션들의 순서를 식별하는 것과 연관된 파라미터들 및/또는 값들(예컨대, 본 명세서에 설명된 컨센서스 방법을 이용하는 순서를 계산하는데 이용됨), 파라미터에 대한 값(예컨대, 트랜잭션을 정량화하는 데이터베이스 필드, 이벤트들이 발생하는 순서를 정량화하는 데이터베이스 필드, 및/또는 값이 데이터베이스에 저장될 수 있는 임의의 다른 적합한 필드)을 저장한다.

일부 경우들에서, 분산 데이터베이스 인스턴스(114)는 또한 데이터베이스 상태 변수 및/또는 현재 상태를 저장할 수 있다. 현재 상태는 트랜잭션들의 결과와 연관된 상태, 잔고, 조건 등일 수 있다. 유사하게 말해서, 상태는 트랜잭션들에 의해 수정된 데이터 구조 및/또는 변수들을 포함할 수 있다. 다른 경우들에서, 현재 상태는 개별 데이터베이스 및/또는 메모리(112)의 일부에 저장될 수 있다. 또 다른 경우들에서, 현재 상태는 컴퓨팅 디바이스(110)와 상이한 컴퓨팅 디바이스의 메모리에 저장될 수 있다.

일부 경우들에서, 분산 데이터베이스 인스턴스(114)는 또한 (키, 값) 쌍들의 세트와 같은 다른 데이터 구조들을 구현하는데 이용될 수 있다. 분산 데이터베이스 인스턴스(114)에 의해 기록된 트랜잭션은, 예를 들어, (키, 값) 쌍들의 세트에서 (키, 값) 쌍을 추가, 삭제, 또는 수정할 수 있다.

일부 경우들에서, 분산 데이터베이스 시스템(100) 또는 임의의 분산 데이터베이스 인스턴스들(114, 124, 134, 144)이 질의될 수 있다. 예를 들어, 질의는 키를 포함할 수 있고, 분산 데이터베이스 시스템(100) 또는 분산 데이터베이스 인스턴스들(114, 124, 134, 144)로부터의 반환된 결과는 키와 연관된 값일 수 있다. 일부 경우들에서, 분산 데이터베이스 시스템(100) 또는 임의의 분산 데이터베이스 인스턴스들(114, 124, 134, 144)은 또한 트랜잭션을 통해 수정될 수 있다. 예를 들어, 데이터베이스를 수정하는 트랜잭션은 수정 트랜잭션을 허가하는 당사자에 의한 디지털 서명을 포함할 수 있다.

분산 데이터베이스 시스템(100)은, 예를 들어, 분산 아이덴티티 시스템에서 다양한 사용자와 연관된 속성들을 저장하는 것과 같은 많은 목적으로 이용될 수 있다. 예를 들어, 이러한 시스템은 사용자의 아이덴티티 및/또는 식별자를 "키"로서 이용할 수 있고, 사용자들과 연관된 속성들의 목록을 "값"으로서 이용할 수 있다. 일부 경우들에서, 아이덴티티 및/또는 식별자는 그 사용자에게 알려진 대응하는 개인 키를 갖는 암호 공개 키일 수 있다. 예를 들어, 각각의 속성은 그 속성을 표명하는 권한을 가진 인증 기관에 의해 디지털 서명될 수 있다. 예를 들어, 각각의 속성은 속성을 판독하는 권한을 갖는 개인 또는 개인 그룹과 연관된 공개 키로 암호화될 수 있다. 일부 키들 또는 값들에는 키들 또는 값들을 수정 및/또는 삭제하도록 허가된 당사자들의 공개 키 목록이 또한 첨부될 수 있다.

다른 예에서, 분산 데이터베이스 인스턴스(114)는 게임플레이 아이템들의 현재 상태 및 소유권과 같은 MMG(Massively Multiplayer Game)들과 관련된 데이터를 저장할 수 있다. 일부 경우들에서, 분산 데이터베이스 인스턴스(114)는 도 1에 도시된 바와 같이 컴퓨팅 디바이스(110) 내에 구현될 수 있다. 다른 경우들에서, 분산 데이터베이스의 인스턴스는 컴퓨팅 디바이스에 의해 액세스가능하지만(예컨대, 네트워크를 통해), 컴퓨팅 디바이스 내에 구현되지 않는다(도 1에 도시되지 않는다).

컴퓨팅 디바이스(110)의 프로세서(111)는 분산 데이터베이스 인스턴스(114)를 운용 및/또는 실행하도록 구성된 임의의 적합한 처리 디바이스일 수 있다. 예를 들어, 프로세서(111)는 본 명세서에 더 상세히 설명된 바와 같이 컴퓨팅 디바이스(120)로부터 신호를 수신하는 것에 응답하여 분산 데이터베이스 인스턴스(114)를 업데이트하고/하거나, 컴퓨팅 디바이스(120)에 신호가 전송되게 하도록 구성될 수 있다. 보다 구체적으로, 본 명세서에서 더 상세히 설명된 바와 같이, 프로세서(111)는 다른 컴퓨팅 디바이스로부터 트랜잭션과 연관된 동기화 이벤트, 동기화 이벤트들의 순서와 연관된 기록 등을 수신하는 것에 응답하여 분산 데이터베이스 인스턴스(114)를 업데이트하기 위해 모듈들, 기능들 및/또는 프로세스들을 실행하도록 구성될 수 있다. 일부 실시예들에서, 프로세서(111)는 분산 데이터베이스의 다른 인스턴스(예컨대, 컴퓨팅 디바이스(120)에서의 분산 데이터베이스 인스턴스(124))에 저장된 파라미터에 대한 값을 수신하는 것에 응답하여 분산 데이터베이스 인스턴스(114)를 업데이트하고/하거나, 컴퓨팅 디바이스(110)에서의 분산 데이터베이스 인스턴스(114)에 저장된 파라미터에 대한 값이 컴퓨팅 디바이스(120)로 전송되게 하기 위해 모듈들, 기능들 및/또는 프로세스들을 실행하도록 구성될 수 있다. 일부 실시예들에서, 프로세서(111)는 범용 프로세서, FPGA(Field Programmable Gate Array), ASIC(Application Specific Integrated Circuit), DSP(Digital Signal Processor) 등일 수 있다.

디스플레이(113)는, 예를 들어, 액정 디스플레이(LCD), 음극선관 디스플레이(CRT) 등과 같은 임의의 적합한 디스플레이일 수 있다. 다른 실시예들에서, 컴퓨팅 디바이스들(110, 120, 130, 140) 중 임의의 것은 디스플레이들(113, 123, 133, 143) 대신에 또는 그에 추가하여 다른 출력 디바이스를 포함한다. 예를 들어, 컴퓨팅 디바이스들(110, 120, 130, 140) 중 어느 하나는 오디오 출력 디바이스(예컨대, 스피커), 촉각 출력 디바이스 등을 포함할 수 있다. 또 다른 실시예들에서, 컴퓨팅 디바이스들(110, 120, 130, 140) 중 임의의 것은 디스플레이들(113, 123, 133, 143) 대신에 또는 그에 추가하여 입력 디바이스를 포함한다. 예를 들어, 컴퓨팅 디바이스들(110, 120, 130, 140) 중 어느 하나는 키보드, 마우스 등을 포함할 수 있다.

도 1에는 단일 컴퓨팅 디바이스 내에 있는 것으로 도시되지만, 일부 경우들에서는 분산 데이터베이스를 업데이트하기 위해 모듈들, 기능들 및/또는 프로세스들을 실행하도록 구성된 프로세서는 그 연관된 분산 데이터베이스와 별개의 컴퓨팅 디바이스 내에 있을 수 있다. 이러한 경우, 예를 들어, 프로세서는 네트워크를 통해 분산 데이터베이스 인스턴스에 동작가능하게 결합될 수 있다. 예를 들어, 프로세서는 컨센서스 방법을 실행하여 이벤트들 및/또는 트랜잭션들의 순서를 식별할 수 있고(예컨대, 다른 분산 데이터베이스 인스턴스들과의 동기화의 결과로서) 이벤트들 및/또는 트랜잭션들의 순서를 포함하는 신호를 네트워크를 통해 연관된 분산 데이터베이스 인스턴스에 전송할 수 있다. 그 후 연관된 분산 데이터베이스 인스턴스는 이벤트들의 순서, 트랜잭션들의 순서 및/또는 연관된 분산 데이터베이스 인스턴스에서의 트랜잭션들의 순서에 기반한 상태 변수를 저장할 수 있다. 그에 따라, 분산 데이터베이스와 연관된 기능들 및 저장이 분산될 수 있다. 또한, 프로세서는 데이터베이스가 분산 데이터베이스 시스템과 연관된 모듈들, 기능들 및/또는 프로세스들(예컨대, 컨센서스 방법)을 구현하는 프로세서를 갖는 컴퓨팅 디바이스와 별개의 컴퓨팅 디바이스에서 구현되는 경우에도, 그 연관된 분산 데이터베이스 인스턴스를 질의하고, 데이터베이스 상태 변수들 및/또는 현재 상태들, 및 본 명세서에 설명된 다른 적합한 연산들을 그 분산 데이터베이스 인스턴스에 저장할 수 있다. 다른 경우들에서, 본 명세서에 설명된 기능들 및/또는 방법들은 임의의 수의 컴퓨팅 디바이스들에 걸쳐(예컨대, 분산 컴퓨팅 환경 및/또는 클러스터 내에서) 실행될 수 있고 이러한 기능들 및/또는 방법들의 결과들 및/또는 값들은 임의의 적합한 컴퓨팅 디바이스에서의 메모리 및/또는 저장소에 저장될 수 있다.

컴퓨팅 디바이스(120)는 프로세서(121), 메모리(122) 및 디스플레이(123)를 갖고, 이들은 프로세서(111), 메모리(112) 및 디스플레이(113)와 각각 구조적 및/또는 기능적으로 유사할 수 있다. 또한, 분산 데이터베이스 인스턴스(124)는 분산 데이터베이스 인스턴스(114)와 구조적 및/또는 기능적으로 유사할 수 있다.

컴퓨팅 디바이스(130)는 프로세서(131), 메모리(132) 및 디스플레이(133)를 갖고, 이들은 프로세서(111), 메모리(112) 및 디스플레이(113)와 각각 구조적 및/또는 기능적으로 유사할 수 있다. 또한, 분산 데이터베이스 인스턴스(134)는 분산 데이터베이스 인스턴스(114)와 구조적 및/또는 기능적으로 유사할 수 있다.

컴퓨팅 디바이스(140)는 프로세서(141), 메모리(142) 및 디스플레이(143)를 갖고, 이들은 프로세서(111), 메모리(112) 및 디스플레이(113)와 각각 구조적 및/또는 기능적으로 유사할 수 있다. 또한, 분산 데이터베이스 인스턴스(144)는 분산 데이터베이스 인스턴스(114)와 구조적 및/또는 기능적으로 유사할 수 있다.

비록 컴퓨팅 디바이스들(110, 120, 130, 140)이 서로 유사한 것으로 도시되어 있지만, 분산 데이터베이스 시스템(100)의 각각의 컴퓨팅 디바이스는 다른 컴퓨팅 디바이스와 상이할 수 있다. 분산 데이터베이스 시스템(100)의 각각의 컴퓨팅 디바이스(110, 120, 130, 140)는, 예를 들어, 컴퓨팅 엔티티(예컨대, 데스크톱 컴퓨터, 랩톱 컴퓨터 등과 같은 개인용 컴퓨팅 디바이스), 모바일 전화, PDA(personal digital assistant) 등 중 어느 하나일 수 있다. 예를 들어, 컴퓨팅 디바이스(110)는 데스크톱 컴퓨터일 수 있고, 컴퓨팅 디바이스(120)는 스마트폰일 수 있고, 컴퓨팅 디바이스(130)는 서버일 수 있다.

일부 실시예들에서, 컴퓨팅 디바이스들(110, 120, 130, 140)의 하나 이상의 부분은 하드웨어 기반 모듈(예컨대, DSP(digital signal processor), FPGA(field programmable gate array)) 및/또는 소프트웨어 기반 모듈(예컨대, 메모리에 저장되고/되거나 프로세서에서 실행되는 컴퓨터 코드의 모듈)을 포함할 수 있다. 일부 실시예들에서, 컴퓨팅 디바이스들(110, 120, 130, 140)과 연관된 기능들(예컨대, 프로세서들(111, 121, 131, 141)과 연관된 기능들) 중 하나 이상은 하나 이상의 모듈에 포함될 수 있다(예컨대, 도 2 참조).

컴퓨팅 디바이스들(예컨대, 컴퓨팅 디바이스들(110, 120, 130, 140))의 속성, 컴퓨팅 디바이스들의 수, 및 네트워크(105)를 포함하는 분산 데이터베이스 시스템(100)의 속성은 임의의 수의 방식으로 선택될 수 있다. 일부 경우들에서, 분산 데이터베이스 시스템(100)의 속성은 분산 데이터베이스 시스템(100)의 관리자에 의해 선택될 수 있다. 다른 경우들에서, 분산 데이터베이스 시스템(100)의 속성은 분산 데이터베이스 시스템(100)의 사용자에 의해 집합적으로 선택될 수 있다.

분산 데이터베이스 시스템(100)이 이용되기 때문에, 컴퓨팅 디바이스들(110, 120, 130 및 140) 사이에 리더가 지정되지 않는다. 구체적으로, 컴퓨팅 디바이스들(110, 120, 130 또는 140) 중 어떤 것도 컴퓨팅 디바이스들(110, 120, 130, 140)의 분산 데이터베이스 인스턴스들(114, 124, 134, 144)에 저장된 값들 사이의 분쟁을 해결하기 위한 리더로서 식별 및/또는 선택되지 않는다. 대신에, 본 명세서에 설명된 이벤트 동기화 프로세스들, 투표 프로세스들, 컨센서스 방법 및/또는 프로토콜 및/또는 다른 방법들을 이용하여, 컴퓨팅 디바이스들(110, 120, 130, 140)은 집합적으로 파라미터에 대한 값에 수렴할 수 있다.

분산 데이터베이스 시스템에 리더가 없으면 분산 데이터베이스 시스템의 보안성이 증가된다. 구체적으로, 리더가 있으면, 공격 및/또는 장애의 단일 지점이 존재한다. 악성 소프트웨어가 리더를 감염시키고/시키거나 리더의 분산 데이터베이스 인스턴스에서의 파라미터에 대한 값이 악의적으로 변경되면, 다른 분산 데이터베이스 인스턴스들에 걸쳐 장애 및/또는 부정확한 값이 전파된다. 그러나, 리더가 없는 시스템에서는, 공격 및/또는 장애의 단일 지점이 존재하지 않는다. 구체적으로, 리더가 없는 시스템의 분산 데이터베이스 인스턴스에서의 파라미터가 값을 포함하면, 이 값은 본 명세서에 더 상세히 설명된 바와 같이, 분산 데이터베이스 인스턴스가 시스템 내의 다른 분산 데이터베이스 인스턴스들과 값들을 교환한 후에 변경될 것이다. 추가적으로, 본 명세서에 설명된 리더가 없는 분산 데이터베이스 시스템은 수렴의 속도를 증가시키면서, 본 명세서에 더 상세히 설명된 바와 같이 디바이스들 간에 전송되는 데이터의 양을 감소시킨다.

도 2는 일 실시예에 따른, 분산 데이터베이스 시스템(예컨대, 분산 데이터베이스 시스템(100))의 컴퓨팅 디바이스(200)를 예시한다. 일부 실시예들에서, 컴퓨팅 디바이스(200)는 도 1에 관하여 도시되고 설명된 컴퓨팅 디바이스들(110, 120, 130, 140)과 유사할 수 있다. 컴퓨팅 디바이스(200)는 프로세서(210) 및 메모리(220)를 포함한다. 프로세서(210) 및 메모리(220)는 서로 동작가능하게 결합된다. 일부 실시예들에서, 프로세서(210) 및 메모리(220)는 각각 도 1에 관하여 상세히 설명된 프로세서(111) 및 메모리(112)와 유사할 수 있다. 도 2에 도시된 바와 같이, 프로세서(210)는 데이터베이스 수렴 모듈(211) 및 통신 모듈(210)을 포함하고, 메모리(220)는 분산 데이터베이스 인스턴스(221)를 포함한다. 통신 모듈(212)은 컴퓨팅 디바이스(200)가 다른 컴퓨팅 디바이스들과 통신(예컨대, 그에 데이터를 전송 및/또는 그로부터 데이터를 수신)하는 것을 가능하게 한다. 일부 실시예들에서, 통신 모듈(212)(도 1에 도시되지 않음)은 컴퓨팅 디바이스(110)가 컴퓨팅 디바이스들(120, 130, 140)과 통신하는 것을 가능하게 한다. 통신 모듈(210)은, 예를 들어, 네트워크 인터페이스 컨트롤러(NIC), 무선 연결, 유선 포트 등을 포함 및/또는 인에이블할 수 있다. 그에 따라, 통신 모듈(210)은 컴퓨팅 디바이스(200)와 다른 디바이스 사이의 통신 세션을 확립 및/또는 유지할 수 있다(예컨대, 도 1의 네트워크(105) 또는 인터넷(도시되지 않음)과 같은 네트워크를 통해). 유사하게 말해서, 통신 모듈(210)은 컴퓨팅 디바이스(200)가 다른 디바이스로 데이터를 전송하고/하거나 그부터 데이터를 수신하는 것을 가능하게 할 수 있다.

일부 경우들에서, 데이터베이스 수렴 모듈(211)은 다른 컴퓨팅 디바이스들과 이벤트들 및/또는 트랜잭션들을 교환하고, 데이터베이스 수렴 모듈(211)이 수신하는 이벤트들 및/또는 트랜잭션들을 저장하고, 이벤트들 사이의 참조들의 패턴에 의해 정의된 부분 순서에 기반하여 이벤트들 및/또는 트랜잭션들의 순서(예를 들어, 컨센서스 또는 전체 순서)를 계산할 수 있다. 각각의 이벤트는 2개의 이전 이벤트(그 이벤트를 2개의 이전 이벤트 및 그 조상 이벤트에 링크하는, 그리고 그 반대의)의 식별자(예로서, 암호 해시), 페이로드 데이터(예로서, 기록될 트랜잭션들), 현재 시간, 그 생성자가 이벤트가 처음 정의된 시간이라고 표명하는 타임스탬프(예컨대, 날짜 및 UTC 시간)와 같은 다른 정보 등을 포함하는 기록일 수 있다. 통신하는 컴퓨팅 디바이스들 각각은 "멤버들" 또는 "해시그래프 멤버들"이라고 불린다. 일부 경우들에서, 멤버에 의해 정의된 제1 이벤트는 다른 멤버에 의해 정의된 단일 이벤트의 해시만을 포함한다. 이러한 경우들에서, 멤버는 아직 이전의 자기-해시(예를 들어, 그 멤버에 의해 이전에 정의된 이벤트의 해시)를 갖지 않는다. 일부 경우들에서, 분산 데이터베이스 내의 제1 이벤트는 (그 분산 데이터베이스에 대한 이전 이벤트가 없기 때문에) 임의의 이전 이벤트의 해시를 포함하지 않는다.

일부 실시예들에서, 2개의 이전 이벤트의 이러한 암호 해시는 이벤트를 입력으로 이용하여 암호 해시 함수에 기반하여 정의된 해시 값일 수 있다. 구체적으로, 이러한 실시예들에서, 이벤트는 바이트의 특정 시퀀스 또는 스트링(그 이벤트의 정보를 나타냄)을 포함한다. 이벤트의 해시는 그 이벤트에 대한 바이트들의 시퀀스를 입력으로 이용하여 해시 함수로부터 반환된 값일 수 있다. 다른 실시예들에서, 이벤트와 연관된 임의의 다른 적합한 데이터(예컨대, 식별자, 일련 번호, 이벤트의 특정 부분을 나타내는 바이트 등)가 그 이벤트의 해시를 계산하기 위해 해시 함수에 대한 입력으로서 이용될 수 있다. 임의의 적합한 해시 함수가 해시를 정의하는데 이용될 수 있다. 일부 실시예들에서, 각각의 멤버는 주어진 이벤트에 대해 각각의 멤버에서 동일한 해시가 생성되도록 동일한 해시 함수를 이용한다. 이벤트는 그 후 이벤트를 정의 및/또는 생성하는 멤버에 의해 디지털 서명될 수 있다. 일부 구현들에서, 해시 값보다는, 이벤트의 임의의 다른 적합한 식별자가 이용될 수 있다.

일부 경우들에서, 이벤트들의 세트와 그 상호 연결들이 방향성 비순환 그래프(DAG)를 형성할 수 있다. 일부 경우들에서, DAG에서의 각각의 이벤트는 0 또는 그 이상(예컨대, 2개)의 이전 이벤트를 참조하고(그 이벤트를 이전 이벤트들 및 그 조상 이벤트들에 링크하는 그리고 그 반대), 어떤 루프도 존재하지 않도록 각각의 참조는 엄격히 이전 이벤트들에 대한 것이다. 일부 실시예들에서, DAG는 암호 해시들에 기반하므로, 데이터 구조는 해시그래프(본 명세서에서 "hashDAG"라고도 지칭됨)라고 불릴 수 있다. 다른 실시예들에서, DAG는 이벤트들의 임의의 다른 적합한 식별자에 기반할 수 있다. 해시그래프 또는 DAG는 부분 순서를 직접 인코딩하며, 이는 Y가 X의 해시를 포함하는 경우, 또는 Y가 X의 해시를 포함하는 이벤트의 해시를 포함하는 경우, 또는 임의의 길이의 이러한 경로들에 대해 이벤트 X가 이벤트 Y 이전에 오는 것으로 알려져 있음을 의미한다. 그러나, X에서 Y까지 또는 Y에서 X까지의 경로가 없으면, 부분 순서는 어느 이벤트가 먼저 왔는지를 정의하지 않는다. 따라서, 데이터베이스 수렴 모듈은 부분 순서로부터 전체 또는 컨센서스 순서를 계산할 수 있다. 이는 컴퓨팅 디바이스가 동일한 순서를 계산하도록 컴퓨팅 디바이스들이 이용하는 임의의 적합한 결정론적 함수에 의해 행해질 수 있다. 일부 실시예들에서, 각각의 멤버는 각각의 동기화 후에 이 순서를 재계산할 수 있고, 결국 이러한 순서들은 컨센서스가 나타나도록 수렴할 수 있다.

컨센서스 알고리즘 및/또는 방법은 해시그래프에서의 이벤트들의 전체 또는 컨센서스 순서, DAG 및/또는 이벤트들 내에 저장된 트랜잭션들의 순서를 결정하는데 이용될 수 있다. 트랜잭션들의 순서는 차례로 순서에 따라 그 트랜잭션들을 수행한 결과로서 데이터베이스의 상태를 정의할 수 있다. 정의된 데이터베이스의 상태는 데이터베이스 상태 변수로서 저장될 수 있다. 일부 실시예들에서, 분산 데이터베이스의 인스턴스(예컨대, 분산 데이터베이스 인스턴스(114))는 해시그래프, 및/또는 트랜잭션들, 및/또는 트랜잭션들의 순서, 및/또는 이벤트들, 및/또는 이벤트들의 순서, 및/또는 트랜잭션들의 수행의 결과로 생기는 상태를 저장한다.

일부 경우들에서, 데이터베이스 수렴 모듈은 다음의 함수를 이용하여 해시그래프에서의 부분 순서로부터 전체 순서(컨센서스 순서라고도 함)를 계산할 수 있다. 다른 컴퓨팅 디바이스들("멤버"라고 불림) 각각에 대해, 데이터베이스 수렴 모듈은 해시그래프를 검사하여 그 멤버가 이벤트들(및/또는 그 이벤트의 표시들)를 수신한 순서를 발견할 수 있다. 그 후 데이터베이스 수렴 모듈은 멤버가 수신한 제1 이벤트에 대해 랭크가 1이고, 멤버가 수신한 제2 이벤트에 대해 랭크가 2인 등의 방식으로 마치 그 멤버가 각각의 이벤트에 수치 "랭크"를 할당한 것처럼 계산할 수 있다. 데이터베이스 수렴 모듈은 해시그래프에서의 각각의 멤버에 대해 이를 행할 수 있다. 그 후, 각각의 이벤트에 대해, 데이터베이스 수렴 모듈은 할당된 랭크의 중앙값을 계산할 수 있고, 이벤트들을 그 중앙값들에 의해 정렬할 수 있다. 그 정렬은 2개의 동점 이벤트를 그 해시들의 수치 순서에 의해, 또는 어떤 다른 방법에 의해 정렬하는 것과 같이 결정론적 방식으로 동점을 구분할 수 있고, 각각의 멤버의 데이터베이스 수렴 모듈은 동일한 방법을 이용한다. 이 정렬의 결과는 전체 순서이다.

도 6은 부분 순서로부터 전체 순서(또는 컨센서스 순서)를 결정하기 위한 일 예의 해시그래프(640)를 예시한다. 해시그래프(640)는 2개의 이벤트(맨 아래의 줄무늬 원 및 맨 아래의 점표시 원)를 예시하고, 제1 시간에, 각각의 멤버는 그 이벤트들(다른 줄무늬 및 점표시 원들)의 표시를 수신한다. 맨 위에 있는 각각의 멤버의 이름은 어느 이벤트가 그 부분 또는 느린 순서에서 먼저인지에 따라 색이 지정된다. 점표시보다 더 많은 줄무늬의 초기 투표가 있고; 따라서, 멤버들 각각에 대한 컨센서스 투표들이 줄무늬이다. 다시 말해서, 멤버들은 점표시 이벤트 전에 줄무늬 이벤트가 발생했다는 합의에 결국 수렴한다.

이 예에서, 멤버들(Alice, Bob, Carol, Dave 및 Ed로 라벨링된 컴퓨팅 디바이스들)은 이벤트 642 또는 이벤트 644 중 어느 쪽이 먼저 발생했는지에 대한 컨센서스를 정의하기 위해 작업할 것이다. 각각의 줄무늬 원은 멤버가 이벤트 644(및/또는 그 이벤트 644의 표시)를 먼저 수신한 이벤트를 표시한다. 유사하게, 각각의 점표시 원은 멤버가 이벤트 642(및/또는 그 이벤트 642의 표시)를 먼저 수신한 이벤트를 표시한다. 해시그래프(640)에 도시된 바와 같이, Alice, Bob 및 Carol은 각각 이벤트 642 이전에 이벤트 644(및/또는 이벤트 644의 표시)를 수신했다. Dave 및 Ed는 둘 다 이벤트 644(및/또는 이벤트 644의 표시) 이전에 이벤트 642(및/또는 이벤트 642의 표시)를 수신했다. 따라서, 더 많은 수의 멤버가 이벤트 642 전에 이벤트 644를 수신했기 때문에, 이벤트 644가 이벤트 642 이전에 발생했음을 표시하기 위해 각각의 멤버에 의해 전체 순서가 결정될 수 있다.

다른 경우들에서, 데이터베이스 수렴 모듈은 상이한 함수를 이용하여 해시그래프에서의 부분 순서로부터 전체 및/또는 컨센서스 순서를 계산할 수 있다. 이러한 실시예들에서, 예를 들어, 데이터베이스 수렴 모듈은 전체 순서를 계산하기 위해 다음 함수를 이용할 수 있는데, 여기서 양의 정수 Q는 멤버들에 의해 공유되는 파라미터이다.

이 실시예에서, fast( x,y )는 실질적으로 x가 생성 및/또는 정의된 직후에 creator(x)의 의견에 따라, 이벤트들의 전체 순서에서 y의 위치를 제공한다. Q가 무한대이면, 상기한 것은 이전에 설명된 실시예에서와 동일한 전체 순서를 계산한다. Q가 유한하고 모든 멤버가 온라인 상태이면, 상기한 것은 이전에 설명된 실시예에서와 동일한 전체 순서를 계산한다. Q가 유한하고, 멤버들 중 소수가 주어진 시간에 온라인 상태이면, 이 함수는 온라인 상태의 멤버들이 그들 사이의 컨센서스에 도달할 수 있게 하고, 이 컨센서스는 새로운 멤버들이 하나씩 천천히 온라인 상태가 될 때 불변 상태로 유지될 것이다. 그러나, 네트워크의 파티션이 있으면, 각각의 파티션의 멤버들은 그들 자신의 컨센서스에 도달할 수 있다. 그 후, 파티션이 조정되면, 더 작은 파티션의 멤버들이 더 큰 파티션의 컨센서스를 채택할 것이다.

또 다른 경우들에서, 도 8 내지 도 13e에 관하여 설명된 바와 같이, 데이터베이스 수렴 모듈은 상이한 함수들을 이용하여 해시그래프에서의 부분 순서로부터 전체 순서를 계산할 수 있다. 도 8 내지 도 9에 도시된 바와 같이, 각각의 멤버(Alice, Bob, Carol, Dave 및 Ed)는 이벤트들(도 8에 도시된 1401-1413; 도 9에 도시된 1501-1506)을 생성 및/또는 정의한다. 도 8 내지 도 13e에 관하여 설명된 기능 및 하위 기능을 이용하여, 이벤트들에 대한 전체 순서는, 본 명세서에 더 상세히 설명되는 바와 같이, 그 수신된 라운드에 의해 이벤트들을 정렬하고, 그 수신된 타임스탬프에 의해 동점을 구분하고, 그 서명들에 의해 그 동점을 구분하는 것에 의해 계산될 수 있다. 다른 경우들에서, 이벤트에 대한 전체 순서는 그 수신된 라운드에 의해 이벤트들을 정렬하고, 그 수신된 세대에 의해(그들의 수신된 타임스탬프 대신에) 동점을 구분하고, 그 서명들에 의해 그 동점을 구분하는 것에 의해 계산될 수 있다. 다음 단락들에서는 이벤트의 수신된 라운드 및 수신된 세대를 계산 및/또는 정의하여 이벤트들에 대한 순서를 결정하는데 이용되는 함수들을 지정한다. 다음 용어들은 도 8 내지 도 13e와 관련하여 사용되고 예시된다.

"부모": Y가 X의 해시를 포함하면 이벤트 X는 이벤트 Y의 부모이다. 예를 들어, 도 8에서, 이벤트 1412의 부모들은 이벤트 1406 및 이벤트 1408을 포함한다.

"조상": 이벤트 X의 조상은 X, 그 부모, 그 부모의 부모 등이다. 예를 들어, 도 8에서, 이벤트 1412의 조상은 이벤트 1401, 1402, 1403, 1406, 1408, 및 1412이다. 이벤트의 조상들은 그 이벤트에 링크된다고 말할 수 있고 그 반대의 경우도 마찬가지이다.

"후손": 이벤트 X의 후손은 X, 그 자식, 그 자식의 자식 등이다. 예를 들어, 도 8에서, 이벤트 1401의 후손은 도면에 도시된 모든 이벤트이다. 다른 예로서, 이벤트 1403의 후손들은 이벤트 1403, 1404, 1406, 1407, 1409, 1410, 1411, 1412 및 1413이다. 이벤트의 후손들은 그 이벤트에 링크된다고 말할 수 있고 그 반대의 경우도 마찬가지이다.

"N": 모집단의 멤버들의 총 수이다. 예를 들어, 도 8에서, 멤버들은 Alice, Bob, Carol, Dave 및 Ed로 라벨링된 컴퓨팅 디바이스들이고, N은 5와 같다.

"M": N의 특정 백분율보다 큰(예컨대, N의 2/3보다 큰) 최소 정수이다. 예를 들어, 도 8에서, 백분율을 2/3으로 정의하면, M은 4와 같다. 다른 경우들에서, M은 예를 들어 N의 상이한 백분율(예컨대, 1/3, 1/2 등), 특정 미리 정의된 수로, 및/또는 임의의 다른 적합한 방식으로 정의될 수 있다.

"자기-부모": 이벤트 X의 자기-부모(self-parent)는 동일한 멤버에 의해 생성 및/또는 정의된 그 부모 이벤트 Y이다. 예를 들어, 도 8에서, 이벤트 1405의 자기-부모는 1401이다.

"자기-조상": 이벤트 X의 자기-조상(self-ancestor)은 X, 그 자기-부모, 그 자기-부모의 자기-부모 등이다.

"시퀀스 번호"(또는 "SN"): 이벤트의 자기-부모의 시퀀스 번호에 1을 더한 것으로 정의된 이벤트의 정수 속성이다. 예를 들어, 도 8에서, 이벤트 1405의 자기-부모는 1401이다. 이벤트 1401의 시퀀스 번호가 1이기 때문에, 이벤트 1405의 시퀀스 번호는 2(즉, 1 + 1)이다.

"세대 번호"(또는 "GN"): 이벤트의 부모들의 세대 번호들 중 최대치에 1을 더한 것으로 정의된 이벤트의 정수 속성이다. 예를 들어, 도 8에서, 이벤트 1412는 세대 번호 4 및 2를 각각 갖는 2개의 부모, 이벤트 1406 및 1408을 갖는다. 따라서, 이벤트 1412의 세대 번호는 5(즉, 4 + 1)이다.

"라운드 증분"(또는 "RI"): 0 또는 1일 수 있는 이벤트의 속성이다.

"라운드 번호"(또는 "RN"): 이벤트의 정수 속성이다. 일부 경우들에서, 이는 라운드 생성 또는 생성된 라운드라고도 지칭된다. 일부 경우들에서, 라운드 번호는 이벤트의 부모들의 라운드 번호들 중 최대치에 이벤트의 라운드 증분을 더한 것으로 정의될 수 있다. 예를 들어, 도 8에서, 이벤트 1412는 둘 다 1의 라운드 번호를 갖는 2개의 부모, 이벤트 1406 및 1408을 갖는다. 이벤트 1412는 또한 1의 라운드 증분을 갖는다. 따라서, 이벤트 1412의 라운드 번호는 2(즉, 1 + 1)이다. 다른 경우들에서, R이 최소 정수인 경우 이벤트는 라운드 번호 R을 가질 수 있어서, 이벤트는 모두 라운드 번호 R-1을 갖는 상이한 멤버들에 의해 정의 및/또는 생성된 적어도 M개의 이벤트를 강력하게 볼 수 있다(본 명세서에 설명된 바와 같이). 이러한 정수가 없는 경우, 이벤트에 대한 라운드 번호는 기본 값(예컨대, 0, 1 등)일 수 있다. 이러한 경우들에서, 이벤트에 대한 라운드 번호는 라운드 증분을 이용하지 않고 계산될 수 있다. 예를 들어, 도 8에서, M이 N의 1/2배보다 큰 최소 정수로 정의되면, M은 3이다. 그 후 이벤트 1412는 M개의 이벤트 1401, 1402 및 1408을 강력하게 보고, 이 이벤트들 각각은 상이한 멤버에 의해 정의되고 1의 라운드 번호를 갖는다. 이벤트 1412는 상이한 멤버들에 의해 정의된 2의 라운드 번호를 갖는 적어도 M개의 이벤트를 강력하게 볼 수 없다. 따라서, 이벤트 1412에 대한 라운드 번호는 2이다. 일부 경우들에서, 분산 데이터베이스에서의 제1 이벤트는 1의 라운드 번호를 포함한다. 다른 경우들에서, 분산 데이터베이스에서의 제1 이벤트는 0 또는 임의의 다른 적합한 수의 라운드 번호를 포함할 수 있다.

"포킹(forking)": 이벤트 X와 이벤트 Y가 동일한 멤버에 의해 정의 및/또는 생성되었으면서, 어느 쪽도 다른 것의 자기-조상이 아닌 경우 이벤트 X는 이벤트 Y와 포크(fork)이다. 예를 들어, 도 9에서, 멤버 Dave는 이벤트 1503이 이벤트 1504의 자기-조상이 아니고, 이벤트 1504가 이벤트 1503의 자기-조상이 아니도록, 둘 다 동일한 자기-부모(즉, 이벤트 1501))를 갖는 이벤트 1503 및 1504를 생성 및/또는 정의함으로써 포킹한다.

포킹의 "식별": 포킹은 2개의 이벤트가 둘 다 제3 이벤트의 조상들인 경우, 서로 포크인 2개의 그 이벤트 후에 생성 및/또는 정의된 제3 이벤트에 의해 "식별"될 수 있다. 예를 들어, 도 9에서, 멤버 Dave는 어느 쪽도 다른 것의 자기-조상이 아닌 이벤트 1503 및 1504를 생성함으로써 포킹한다. 이 포킹은 이벤트(1503) 및 1504가 둘 다 이벤트 1506의 조상이기 때문에 나중의 이벤트 1506에 의해 식별될 수 있다. 일부 경우들에서, 포킹의 식별은 특정 멤버(예컨대, Dave)가 치팅한 것을 표시할 수 있다.

이벤트의 "식별": X가 Y와 포크인 조상 이벤트 Z를 갖지 않는 경우 이벤트 X는 조상 이벤트 Y를 "식별"하거나 "본다". 예를 들어, 도 8에서, 이벤트 1403이 이벤트 1412의 조상이고 이벤트 1412가 이벤트 1403과 포크들인 조상 이벤트들을 갖지 않기 때문에 이벤트 1412는 이벤트 1403을 식별한다("본다"이라고도 지칭됨). 일부 경우들에서, X가 이벤트 Y 이전에 포킹을 식별하지 못하면, 이벤트 X는 이벤트 Y를 식별할 수 있다. 이러한 경우들에서, 비록 이벤트 X가 이벤트 Y에 후속하는 이벤트 Y를 정의하는 멤버에 의해 포킹을 식별하더라도, 이벤트 X는 이벤트 Y를 볼 수 있다. 이벤트 X는 포킹에 후속하는 그 멤버에 의해 이벤트들을 식별하지 못한다. 또한, 멤버가 이력에서 둘 다가 그 멤버의 제1 이벤트들인 2개의 상이한 이벤트를 정의하는 경우, 이벤트 X는 포킹을 식별할 수 있고 그 멤버에 의해 어떤 이벤트도 식별하지 못한다.

이벤트의 "강력한 식별"(본 명세서 "강력하게 보는"이라고도 지칭됨): X가 Y를 식별하는 경우, 이벤트 X는 X와 동일한 멤버에 의해 생성 및/또는 정의된 조상 이벤트 Y를 "강력하게 식별한다"(또는 "강력하게 보는"). (1) X와 Y를 둘 다 포함하고 (2) 이벤트 X의 조상들이고 (3) 조상 이벤트 Y의 후손들이고 (4) X에 의해 식별되고 (5) 각각 Y를 식별할 수 있고 (6) 적어도 M명의 상이한 멤버에 의해 생성 및/또는 정의된 이벤트들의 세트 S가 존재하는 경우, 이벤트 X는 X와 동일한 멤버에 의해 생성 및/또는 정의되지 않은 조상 이벤트 Y를 "강력하게 식별"한다. 예를 들어, 도 8에서, M이 N의 2/3보다 큰 최소 정수인 것으로 정의된다면(즉, M=1+floor(2N/3), 이 예에서는 4일 것임), 이벤트 1412는 조상 이벤트 1401을 강력하게 식별하는데 그 이유는 이벤트들의 세트 1401, 1402, 1406 및 1412가 이벤트 1412의 조상들 및 이벤트 1401의 후손들인 적어도 4개의 이벤트의 세트이고, 그것들이 각각 4명의 멤버 Dave, Carol, Bob, 및 Ed에 의해 각각 생성 및/또는 정의되고, 이벤트 1412는 이벤트 1401, 1402, 1406, 및 1412 각각을 식별하고, 이벤트 1401, 1402, 1406, 및 1412 각각은 이벤트 1401를 식별하기 때문이다. 유사하게 말해서, X가 Y를 각각 볼 수 있는 상이한 멤버들에 의해 생성 또는 정의된 적어도 M개의 이벤트(예컨대, 이벤트 1401, 1402, 1406, 및 1412)를 볼 수 있는 경우, 이벤트 X(예컨대, 이벤트 1412)는 이벤트 Y(예컨대, 이벤트 1401)를 "강력하게 볼" 수 있다.

"라운드 R 제1" 이벤트(본 명세서에서 "목격자"라고도 지칭됨): 이벤트가 (1) 라운드 번호 R을 갖고, (2) R보다 작은 라운드 번호를 갖는 자기-부모를 갖거나 자기-부모가 없는 경우 그 이벤트는 "라운드 R 제1" 이벤트(또는 "목격자")이다. 예를 들어, 도 8에서, 이벤트 1412는 "라운드 2 제1" 이벤트인데 그 이유는 그것이 2의 라운드 번호를 갖고, 그 자기-부모가 1의 라운드 번호(즉, 2보다 작음)를 갖는 이벤트 1408이기 때문이다.

일부 경우들에서, X가 적어도 M개의 "라운드 R 제1" 이벤트를 "강력하게 식별"하는 경우에만 이벤트 X에 대한 라운드 증분이 1로 정의되고, 여기서 R은 그 부모의 최대 라운드 번호이다. 예를 들어, 도 8에서, M이 N의 1/2배보다 큰 최소 정수로 정의되면, M은 3이다. 그 후 이벤트 1412는 모두가 라운드 1 제1 이벤트들인 M개의 이벤트 1401, 1402 및 1408을 강력하게 식별한다. 1412의 양 부모는 1의 라운드 번호를 갖고, 1412는 적어도 M개의 라운드 1 제1 이벤트를 강력하게 식별하며, 따라서 1412에 대한 라운드 증분은 1이다. "RI=0"으로 마킹된 도면에서의 이벤트들 각각은 적어도 M개의 라운드 1 제1 이벤트를 강력하게 식별하지 못하고, 따라서 그 라운드 증분은 0이다.

일부 경우들에서, 이벤트 X가 조상 이벤트 Y를 강력하게 식별할 수 있는지 여부를 결정하기 위해 다음 방법이 이용될 수 있다. 각각의 라운드 R 제1 조상 이벤트 Y에 대해, 멤버당 하나씩 정수들의 어레이 A1을 유지하여, 이벤트 X의 최저 시퀀스 번호를 부여하고, 여기서 그 멤버가 이벤트 X를 생성 및/또는 정의하였고, X가 Y를 식별할 수 있다. 각각의 이벤트 Z에 대해, 멤버당 하나씩 정수들의 어레이 A2를 유지하여, 그 멤버에 의해 생성 및/또는 정의된 이벤트 W의 최고 시퀀스 번호를 제공하고, 따라서 Z가 W를 식별할 수 있다. Z가 조상 이벤트 Y를 강력하게 식별할 수 있는지 여부를 결정하기 위해, A1[E] <= A2[E]이도록 요소 위치의 수 E를 카운트한다. 이벤트 Z는 이 카운트가 M보다 큰 경우에만 Y를 강력하게 식별할 수 있다. 예를 들어, 도 8에서, 멤버 Alice, Bob, Carol, Dave 및 Ed는 각각 이벤트 1401을 식별할 수 있고, 여기서 그렇게 할 수 있는 가장 이른 이벤트는 각각 그 이벤트들 {1404, 1403, 1402, 1401, 1408}이다. 이 이벤트들은 시퀀스 번호들 A1={1,1,1,1,1}을 갖는다. 유사하게, 이벤트 1412에 의해 식별되는 그들 각각에 의한 최근 이벤트는 이벤트 {없음, 1406, 1402, 1401, 1412}이고, 여기서 1412는 Alice에 의한 어떤 이벤트도 식별할 수 없기 때문에 Alice는 "없음"으로 열거된다. 이 이벤트들은 각각 A2={0,2,1,1,2}의 시퀀스 번호를 가지며, 여기서 모든 이벤트들은 양의 시퀀스 번호를 가지므로, 0은 Alice가 1412로 식별되는 이벤트를 갖지 않음을 의미한다. 목록 A1을 목록 A2와 비교하면 4개의 값이 참인 {거짓, 참, 참, 참, 참}와 동등한 결과 {1<=0, 1<=2, 1<=1, 1<=1, 1<=2}를 제공한다. 따라서, 1412의 조상들과 1401의 후손들인 4개의 이벤트로 구성된 세트 S가 존재한다. 4는 적어도 M이며, 따라서 1412는 1401을 강력하게 식별한다.

A1 및 A2에서, 이벤트 X가 조상 이벤트 Y를 강력하게 식별할 수 있는지 여부를 결정하는 방법을 구현하는 또 다른 변형은 다음과 같다. 양쪽 어레이에서의 정수 요소들이 128보다 작으면, 각각의 요소를 단일 바이트에 저장하고, 8개의 이러한 요소를 단일 64-비트 워드로 팩킹하고, A1 및 A2를 이러한 워드들의 어레이들로 하는 것이 가능하다. A1에서의 각각의 바이트의 최상위 비트는 0으로 설정될 수 있고, A2에서의 각각의 바이트의 최상위 비트는 1로 설정될 수 있다. 2개의 대응 워드를 빼고, 그 후 마스크와 비트 단위 AND를 수행하여 최상위 비트들 이외의 모든 것을 0으로 하고, 그 후 7 비트 위치만큼 오른쪽으로 시프트하여, C 프로그래밍 언어에서 다음과 같이 표현되는 값을 얻는다: ((A2[i] - A1[i]) & 0x8080808080808080) >> 7). 이는 0으로 초기화된 러닝 누산기(running accumulator)(S)에 추가될 수 있다. 이를 여러 번 수행한 후, 바이트들을 시프팅 및 추가하는 것에 의해 누산기를 카운트로 변환하여 ((S & 0xff) + ((S >> 8) & 0xff) + ((S >> 16) & 0xff) + ((S >> 24) & 0xff) + ((S >> 32) & 0xff) + ((S >> 40) & 0xff) + ((S >> 48) & 0xff) + ((S >> 56) & 0xff))를 얻는다. 일부 경우들에서, 이러한 계산들은 C, Java 등과 같은 프로그래밍 언어로 수행될 수 있다. 다른 경우들에서, 계산들은 Intel 및 AMD에 의해 제공되는 AVX(Advanced Vector Extensions) 명령어, 또는 GPU(graphics processing unit) 또는 GPGPU(general-purpose graphics processing unit)의 균등물과 같은 프로세서 특정 명령어를 이용하여 수행할 수 있다. 일부 아키텍처들에서, 계산들은 128 비트, 256 비트, 512 비트 또는 그 이상의 비트와 같이 64 비트보다 큰 워드를 이용하여 더 빨리 수행될 수 있다.

"유명(famous)" 이벤트: (1) 이벤트 X가 "라운드 R 제1" 이벤트(또는 "목격자")이고 (2) 아래에 설명된 비잔틴 합의 프로토콜의 실행을 통해 "예" 결정에 도달하는 경우 라운드 R 이벤트 X는 "유명"하다. 일부 실시예들에서, 비잔틴 합의 프로토콜은 분산 데이터베이스의 인스턴스(예컨대, 분산 데이터베이스 인스턴스(114)) 및/또는 데이터베이스 수렴 모듈(예컨대, 데이터베이스 수렴 모듈(211))에 의해 실행될 수 있다. 예를 들어, 도 8에는, 5개의 라운드 1 제1 이벤트가 도시되어 있다: 1401, 1402, 1403, 1404 및 1408. M이 3인, N의 1/2배보다 큰 최소 정수인 것으로 정의되면, 1412는 라운드 2 제1 이벤트이다. 프로토콜이 더 오래 실행되면, 해시그래프는 위쪽으로 증가하고, 결국 다른 4명의 멤버도 이 도면의 맨 위 위에 라운드 2 제1 이벤트들을 가질 것이다. 각각의 라운드 2 제1 이벤트는 라운드 1 제1 이벤트 각각이 "유명"한지에 대한 "투표"를 가질 것이다. 이벤트 1412는 1401, 1402 및 1403이 유명한지에 대해 예에 투표할 것인데, 그 이유는 이들이 식별할 수 있는 라운드 1 제1 이벤트이기 때문이다. 이벤트 1412는 1412가 1404를 식별할 수 없기 때문에 1404가 유명한지에 대해 아니오에 투표할 것이다. 1402와 같은 주어진 라운드 1 제1 이벤트에 대해, 그것이 유명한지 여부에 대한 각각의 라운드 2 제1 이벤트의 투표를 계산함으로써 "유명"한지 여부에 대한 그 상태가 결정될 것이다. 이어서 그 투표들은 1402가 유명했는지에 대한 최종 합의에 도달할 때까지, 라운드 3 제1 이벤트들로, 그 후 라운드 4 제1 이벤트들 등으로 전파될 것이다. 다른 제1들에 대해 동일한 프로세스가 반복된다.

비잔틴 합의 프로토콜은 "유명" 이벤트들을 식별하기 위해 "라운드 R 제1" 이벤트들의 투표들 및/또는 결정들을 수집하고 이용할 수 있다. 예를 들어, Y가 이벤트 X를 "식별"할 수 있다면 "라운드 R+1 제1" 이벤트 Y가 "예"에 투표할 것이고, 그렇지 않으면 "아니오"에 투표한다. 그 후 임의의 멤버에 의해 결정에 도달할 때까지 각각의 라운드 G에 대해, G = R+2, R+3, R+4, 등에 대해 투표들이 계산된다. 결정에 도달할 때까지, 각각의 라운드 G에 대해 투표가 계산된다. 그 라운드들 중 일부는 "다수(majority)" 라운드들일 수 있고, 반면 일부 다른 라운드들은 "코인(coin)" 라운드들일 수 있다. 일부 경우들에서, 예를 들어, 라운드 R+2가 다수 라운드이고, 미래의 라운드들이 (예컨대, 미리 정의된 스케줄에 따라) 다수 또는 코인 라운드 중 어느 하나로 지정된다. 예를 들어, 일부 경우들에서, 미래의 라운드가 다수 라운드인지 또는 코인 라운드인지 여부는 2개의 연속적인 코인 라운드가 있을 수 없다는 조건에 따라, 임의로 결정될 수 있다. 예를 들어, 5개의 다수 라운드, 그 후 하나의 코인 라운드, 그 후 5개의 다수 라운드, 그 후 하나의 코인 라운드가 존재할 것이고, 이는 합의에 도달하는데 필요한 만큼 반복되는 것이 미리 정의될 수 있다.

일부 경우들에서, 라운드 G가 다수 라운드라면, 투표들은 다음과 같이 계산될 수 있다. V(여기서 V는 "예" 또는 "아니오")에 투표하는 적어도 M개의 라운드 G-1 제1들을 강력하게 식별하는 라운드 G 이벤트가 존재한다면, 컨센서스 결정은 V이고, 비잔틴 합의 프로토콜이 종료된다. 그렇지 않으면, 각각의 라운드 G 제1 이벤트는 각각의 라운드 G 제1 이벤트가 강력하게 식별할 수 있는 라운드 G-1 제1 이벤트들의 다수인 새로운 투표를 계산한다. 다수가 아니라 동점이 있는 경우들에서, 투표는 "예"로 지정될 수 있다.

유사하게 말해서, X가 라운드 R 목격자(또는 라운드 R 제1)이면, 라운드 R+1, R+2 등에서의 투표의 결과들이 계산될 수 있고, 여기서 각각의 라운드에서의 목격자들은 X가 유명한지 여부에 대해 투표한다. 라운드 R+1에서, X를 볼 수 있는 모든 목격자는 예에 투표하고, 다른 목격자들은 아니오에 투표한다. 라운드 R+2에서, 모든 목격자는 그것이 강력하게 볼 수 있는 라운드 R+1 목격자들의 다수의 투표들에 따라 투표한다. 유사하게, 라운드 R+3에서, 모든 목격자는 그것이 강력하게 볼 수 있는 라운드 R+2 목격자의 다수의 투표들에 따라 투표한다. 이는 다수의 라운드 동안 계속될 수 있다. 동점인 경우, 투표는 예로 설정될 수 있다. 다른 경우들에서, 동점은 아니오로 설정될 수 있거나 랜덤하게 설정될 수 있다. 임의의 라운드가 아니오에 투표하는 적어도 M명의 목격자를 갖는다면, 선거가 종료되고, X는 유명하지 않다. 임의의 라운드가 예에 투표하는 적어도 M명의 목격자를 갖는다면, 선거가 종료되고, X는 유명하다. 예 또는 아니오 어느 것도 적어도 M개의 투표를 갖지 않으면, 선거는 다음 라운드로 계속된다.

예로서, 도 8에서, 도시된 도면 아래에 있는 일부 라운드 제1 이벤트 X를 고려한다. 그 후, 각각의 라운드 1 제1 이벤트는 X가 유명한지 여부에 대한 투표를 가질 것이다. 이벤트 1412는 라운드 1 제1 이벤트들 1401, 1402 및 1408을 강력하게 식별할 수 있다. 그래서 그 투표는 그 투표들에 기반할 것이다. 이것이 다수 라운드라면, 1412는 {1401, 1402, 1408} 중 적어도 M개가 예의 투표를 가지고 있는지 여부를 체크할 것이다. 그들이 그렇다면, 그 결정은 예이고, 합의가 달성되었다. 그들 중 적어도 M개가 아니오에 투표한다면, 결정은 아니오이고, 합의가 달성되었다. 투표가 어느 방향으로도 적어도 M개를 갖지 않는다면, 1412에 1401, 1402 및 1408의 것들의 다수의 투표들인 투표가 주어진다(그리고 동점이 있다면 예에 투표함으로써 동점을 구분할 것이다). 그 투표는 그 후 다음 라운드에서 이용될 것이고, 합의에 도달할 때까지 계속된다.

일부 경우들에서, 라운드 G가 코인 라운드라면, 투표는 다음과 같이 계산될 수 있다. 이벤트 X가 V(여기서 V는 "예" 또는 "아니오")에 투표하는 적어도 M개의 라운드 G-1 제1들을 식별할 수 있다면, 이벤트 X는 그 투표를 V로 변경할 것이다. 그렇지 않고, 라운드 G가 코인 라운드라면, 각각의 라운드 G 제1 이벤트 X는 이벤트 X의 서명의 최하위 비트에 의해 정의되는 의사-랜덤 결정(일부 경우들에서는 코인 플립(coin flip)과 유사)의 결과로 그 투표를 변경한다.

유사하게 말해서, 이러한 경우들에서, 선거가 라운드 R+K(코인 라운드)에 도달하면 - 여기서 K는 지정된 계수(예컨대, 3, 6, 7, 8, 16, 32 또는 임의의 다른 적합한 수와 같은 수의 배수임) -, 선거는 그 라운드에서 종료되지 않는다. 선거가 이 라운드에 도달하면, 이것은 적어도 하나 더 많은 라운드에 대해 계속될 수 있다. 이러한 라운드에서, 이벤트 Y가 라운드 R+K 목격자라면, 그것이 V에 투표하는 라운드 R+K-1로부터 적어도 M명의 목격자를 강력하게 볼 수 있다면, Y는 V에 투표할 것이다. 그렇지 않으면, Y는 랜덤 값에 따라 투표할 것이다(예컨대, 암호 "공유 코인" 프로토콜 및/또는 임의의 다른 랜덤 결정을 이용하여, 이벤트 Y의 서명의 비트(예컨대, 최하위 비트, 최상위 비트, 랜덤하게 선택된 비트)에 따라, -여기서, 1=예 및 0=아니오임 -, 또는 반대로, 이벤트 Y의 타임 스탬프에 따라). 이 랜덤 결정은 Y가 생성되기 전에 예측할 수 없으며, 따라서 이벤트들 및 컨센서스 프로토콜의 보안성을 증가시킬 수 있다.

예를 들어, 도 8에서, 라운드 2가 코인 라운드이고, 투표가 라운드 1 이전의 일부 이벤트가 유명했는지에 대한 것이면, 이벤트 1412는 먼저 {1401, 1402, 1408} 중 적어도 M개가 예에 투표했는지, 또는 그들 중 적어도 M개가 아니오에 투표했는지 여부를 체크할 것이다. 이러한 경우라면, 1412는 동일한 방식으로 투표할 것이다. 어떤 방향으로도 적어도 M개의 투표가 없다면, 1412는 (예컨대, Ed는 그가 이벤트 1412를 생성 및/또는 정의한 시점에, 그가 그것에 서명했을 때 그것에 대해 생성한 디지털 서명의 최하위 비트에 기반하여) 랜덤 또는 의사랜덤 투표를 가질 것이다.

일부 경우들에서, 의사-랜덤 결정의 결과는, 예를 들어, 라운드 번호의 임계치 서명의 최하위 비트로서 구현될 수 있는 암호 공유 코인 프로토콜의 결과일 수 있다.

위에 설명된 바와 같이, 일부 구현들에서, 해시그래프 컨센서스 방법은, 예를 들어, 라운드 R에서의 목격자 X의 명성을 결정하는 단계를 포함할 수 있다. 위에 설명된 바와 같이, 초기 투표들이 라운드 R+1로부터 수집되어, 그것이 X의 후손인지에 따라 예 또는 아니오에 투표하는 각각의 이벤트를 카운트할 수 있다. 대안적 접근법은 "R+1" 대신 "R+2"(또는 "R+1" 대신에 "R+3", "R+4" 등)로부터 초기 투표들을 수집하는 것을 포함할 수 있다. 그 접근법에서, 추가적인 단계가 선택적으로 추가될 수 있다. 구체적으로, 이러한 구현에서, 라운드 R 제1 이벤트 X(또는 라운드 R 목격자 X)가 모집단의 2/3보다 많은 것에 의해 생성 및/또는 정의되는 라운드 R+1 목격자들의 조상일 때마다(즉, 2N/3 멤버들보다 많음), 그 후 X는 바로 유명한 것으로 선언되고, X에 대한 임의의 투표들이 계산되기 전에도 선거는 바로 종료된다. 제2 대안적 접근법은 R+1로부터 수집된 초기 투표를 이용하여 R에 대한 선거를 실행하는 것을 포함할 수 있고, 그 후 유명한 것으로 결정된 라운드 R에서 목격자를 생성 및/또는 정의한 멤버들의 수가 주어진 임계치 T 아래(예를 들어, 2N/3 멤버 아래)인 경우, R+2로부터 수집된 초기 투표를 이용하여 두 번째로 선거를 재실행한다. 유사하게 말하면, 라운드 R에 대한 유명한 목격자들의 수가 라운드 R+1로부터의 투표들을 이용하여 불충분하게 식별되면, 선거는 라운드 R+1보다는 라운드 R+2로부터의 투표들을 이용하여 처음부터 완전히 재실행될 수 있다(즉, 라운드 R+1로부터의 투표들을 이용하는 선거의 결과들은 폐기되고, 라운드 R+2로부터의 투표들을 이용하여 선거가 재실행된다). 일부 구현들에서, 다른 대안은 R+1로부터 수집된 초기 투표들을 이용하여 R에 대한 선거를 실행하는 것을 포함할 수 있고, 그 후 유명한 것으로 결정된 라운드 R에서 목격자들을 생성 및/또는 정의한 멤버들의 수가 주어진 임계치 T 아래(예를 들어, 2N/3 멤버 아래)인 경우, 라운드 R에 대한 유명한 목격자들(예를 들어, 판정단들)은 라운드 R+1에서 유명한 목격자들의 조상들인 라운드 R에서의 목격자들인 것으로 정의될 수 있다(일부는 멤버마다 라운드 R에서 하나의 유명한 목격자만을 보장하기 위해 제거된다).

시스템은 위에 설명된 의사-랜덤 결정의 결과를 계산하기 위한 방법들 중 어느 하나로부터 구축될 수 있다. 일부 경우들에서, 시스템은 일부 순서로 상이한 방법들을 통해 순환한다. 다른 경우들에서, 시스템은 미리 정의된 패턴에 따라 상이한 방법들 중에서 선택할 수 있다.

"수신된 라운드": 이벤트 X는 라운드 번호 R을 가진 유명 라운드 R 제1 이벤트들(또는 유명한 목격자들) 중 적어도 절반이 X의 후손들이고/이거나 X를 볼 수 있도록 R이 최소 정수인 경우 R의 "수신된 라운드"를 갖는다. 다른 경우들에서는, 임의의 다른 적합한 백분율이 이용될 수 있다. 예를 들어, 다른 경우에서, 이벤트 X는 라운드 번호 R을 가진 유명 라운드 R 제1 이벤트들(또는 유명한 목격자들)의 적어도 미리 결정된 백분율(예컨대, 40%, 60%, 80% 등)이 X의 후손들이고/이거나 X를 볼 수 있도록 R이 최소 정수인 경우 R의 "수신된 라운드"를 갖는다.

일부 경우들에서, 이벤트 X의 "수신된 세대"는 다음과 같이 계산될 수 있다. 이벤트 X를 식별할 수 있는 각각의 라운드 R 제1 이벤트를 생성 및/또는 정의한 멤버를 찾는다. 그 후 X를 식별할 수 있는 그 멤버에 의한 가장 이른 이벤트의 세대 번호를 결정한다. 그 후 X의 "수신된 세대"를 그 목록의 중앙값인 것으로 정의한다.

일부 경우들에서, 이벤트 X의 "수신된 타임스탬프" T는 X를 식별하고/하거나 보는 각각의 멤버에 의한 제1 이벤트를 포함하는 이벤트들에서의 타임스탬프들의 중앙값일 수 있다. 예를 들어, 이벤트 1401의 수신된 타임스탬프는 이벤트 1402, 1403, 1403, 및 1408에 대한 타임스탬프들의 값의 중앙값일 수 있다. 일부 경우들에서, 이벤트 1401에 대한 타임스탬프가 중앙값 계산에 포함될 수 있다. 다른 경우들에서, X에 대해 수신된 타임스탬프는 X를 식별하거나 보기 위한 각각의 멤버에 의한 제1 이벤트들인 이벤트들에서의 타임스탬프들의 값들의 조합 또는 임의의 다른 값일 수 있다. 예를 들어, X에 대한 수신된 타임스탬프는 타임스탬프들의 평균, 타임스탬프들의 표준 편차, (예컨대, 계산으로부터 가장 이른 및 최근의 타임스탬프들을 제거함으로써) 수정된 평균 등에 기반할 수 있다. 또 다른 경우들에서는, 확장된 중앙값이 이용될 수 있다.

일부 경우들에서, 이벤트들에 대한 전체 순서 및/또는 컨센서스 순서는 그 수신된 라운드에 의해 이벤트들을 정렬하고, 그 수신된 타임스탬프에 의해 동점을 구분하고, 그 서명들에 의해 그 동점들을 구분하는 것에 의해 계산된다. 다른 경우들에서, 이벤트에 대한 전체 순서는 그 수신된 라운드에 의해 이벤트들을 정렬하고, 그 수신된 세대에 의해 동점을 구분하고, 그 서명들에 의해 그 동점을 구분하는 것에 의해 계산될 수 있다. 전술한 단락들은 이벤트의 수신된 라운드, 수신된 타임스탬프, 및/또는 수신된 세대를 계산 및/또는 정의하는데 이용되는 함수들을 지정한다.

다른 경우들에서, 각각의 이벤트의 서명을 이용하는 대신에, 그 라운드에서 수신된 세대 및/또는 동일한 수신된 라운드를 갖는 유명 이벤트들 또는 유명한 목격자들의 서명들과 XOR된 그 이벤트의 서명이 이용될 수 있다. 다른 경우들에서, 이벤트 서명들의 임의의 다른 적합한 조합이 이벤트들의 컨센서스 순서를 정의하기 위해 동점을 구분하는데 이용될 수 있다. 주어진 라운드에서 유명한 목격자들의 XOR된 서명들의 결과는 잠재적 공격자들 및 다른 엔티티들이 예측 및/또는 조작하기 어려운 의사 난수를 나타낸다. 따라서, 일부 구현들에서, XOR된 서명들은 예측할 수 없는 난수들(즉, "랜덤 비컨")의 소스로서 이용될 수 있다. 난수들은 다양한 해시그래프 프로세스들에서 이용될 수 있다.

또 다른 경우들에서는 "수신된 세대"를 목록의 중앙값으로서 정의하는 대신, "수신된 세대"는 목록 자체인 것으로 정의될 수 있다. 그 후, 수신된 세대에 의해 정렬할 때, 2개의 수신된 세대는 그 목록들의 중간 요소들에 의해 비교될 수 있어, 중간 바로 이전의 요소에 의해 동점을 구분하고, 중간 직후의 요소에 의해 그 동점을 구분하고, 동점이 구분될 때까지 지금까지 이용된 것들 이전의 요소와 이후의 요소 사이를 번갈아 가며 계속한다.

일부 경우들에서, 중앙값 타임스탬프는 "확장된 중앙값"으로 대체될 수 있다. 이러한 경우들에서, 단일의 수신된 타임스탬프가 아니라 각각의 이벤트에 대해 타임스탬프들의 목록이 정의될 수 있다. 이벤트 X에 대한 타임스탬프들의 목록은 X를 식별하고/하거나 보는 각각의 멤버에 의한 제1 이벤트를 포함할 수 있다. 예를 들어, 도 8에서, 이벤트 1401에 대한 타임스탬프의 목록은 이벤트 1402, 1403, 1403 및 1408에 대한 타임스탬프들을 포함할 수 있다. 일부 경우들에서, 이벤트 1401에 대한 타임스탬프가 또한 포함될 수 있다. 타임스탬프들의 목록으로 동점을 구분할 때(즉, 2개의 이벤트가 동일한 수신된 라운드를 가짐), 각각의 이벤트의 목록의 중간 타임스탬프들(또는 동일한 길이로 이루어지는 경우, 2개의 중간 타임스탬프 중 제1 또는 제2의 미리 결정된 것)이 비교될 수 있다. 이 타임스탬프들이 동일하면, 중간 타임스탬프들 직후의 타임스탬프들이 비교될 수 있다. 이 타임스탬프들이 동일하면, 중간 타임스탬프들 직전의 타임스탬프들이 비교될 수 있다. 이 타임스탬프들도 동일하면, 이미 비교된 3개의 타임스탬프 이후의 타임스탬프들이 비교된다. 이는 동점이 구분될 때까지 계속 번갈아 행해질 수 있다. 위의 논의와 유사하게, 2개의 목록이 동일하면, 2개의 요소의 서명들에 의해 동점이 구분될 수 있다.

또 다른 경우들에서, "확장된 중앙값" 대신에 "잘린 확장된 중앙값(truncated extended median)"이 이용될 수 있다. 이러한 경우에, 각각의 이벤트에 대해 타임스탬프들의 전체 목록이 저장되지 않는다. 대신에, 목록의 중간 근처의 값들 중 소수만이 저장되어 비교에 이용된다.

수신된 중앙값 타임스탬프는 잠재적으로 이벤트들의 전체 순서를 계산하는 것에 추가하여 다른 목적으로 이용될 수 있다. 예를 들어, Bob은, X에 대한 수신된 타임스탬프가 특정 마감일에 있거나 그 이전이고, Alice가 동일한 계약서에 서명한 트랜잭션을 포함하는 이벤트 X가 존재하는 경우에 그리고 그 경우에만 계약서에 구속되는데 그가 동의한다고 하는 계약서에 서명할 수 있다. 그 경우, Bob은 위에 설명된 바와 같이, Alice가 "수신된 중앙값 타임스탬프"에 의해 표시된 마감일 이후에 계약서에 서명하는 경우 그것에 구속되지 않을 것이다.

일부 구현들에서, Alice가 포크들인(동일한 자기-부모를 가지는) 2개의 이벤트 X 및 Y를 생성하고, Bob이 X를 수신할 경우, Bob에 의해 정의된 후속적인 이벤트는 X를 볼 수 있다. 나중에, Bob이 Y를 수신할 때, 그 후의 그 미래의 이벤트들은 (Bob이 포크를 식별하기 때문에) 더 이상 X 또는 Y를 볼 수 없다. 일부 구현들에서, 이것은 Bob의 미래의 이벤트들이 X를 계속 볼 것이고, Y를 보지 않을 것이도록 변경될 수 있다. 유사하게 언급하면, 멤버가 이벤트를 볼 수 있으면, 그 보는 것은 "고정(sticky)"이고, 그 미래의 이벤트들은 그 이벤트를 계속 볼 것이지만, 그 이벤트의 임의의 포크들을 보지 않을 것이다. 이를 이용하여, 컨센서스 방법 및/또는 알고리즘은 더 이상 포크들을 검출하거나 그에 반응할 필요가 없다. 정의들은 술어들(x가 y를 볼 수 있는가?)로부터 함수들(어느 목격자가 x를 볼 수 있는가?)로 변경된다.

일부 구현들에서, 정의들 see, stronglySee, 및 fork 함수들이 삭제될 수 있고, 컨센서스 방법 및/또는 알고리즘은 lastSee, firstSee, stronglySeeP, stronglySeeS1, seeThruP, firstSelfWitnessS, 및 firstWitnessS의 항들을 이용할 수 있다(예를 들어, 도 13a 내지 도 13e에 도시된 함수들을 참조). 이러한 함수들 각각은 이벤트 x 및 멤버 m을 제공받고, 멤버 m에 의해 생성된 고유 이벤트를 반환하며, 이벤트 x에 의해 (특정 방식으로) 보여진다. S, S1 또는 P에서 종료되는 이름들 중 몇몇은 반환된 이벤트가 (각각) x의 자기 라운드(x의 라운드 생성), 자기 라운드 - 1, 또는 부모 라운드에 있다는 것을 나타낸다. 각각의 함수에 대해, 이러한 가시적 이벤트가 존재하지 않는 경우, 또는 (이벤트가 없음을 의미하는)

인 경우, 이것은

를 반환한다.

도 13a 내지 도 13e에서 이용되는 함수 구축자 표기법에서, 다수의 선들이 만족되는 "if"를 갖는 경우, 제1(상부) 선이 이용된다. 그리고 논리 OR(

)은 단락 회로로 가정되고, 따라서 p가 참이고 q가 정의되지 않은 경우에(예컨대, q의 정의가 무한 재귀(infinite recursion)를 가질 경우에)

가 참으로 정의된다.

도 13a 내지 도 13e에서의 예시적인 정의들은 효율적인 방식으로 직접 구현될 수 있다. 도 13a 및 도 13b의 방정식들에는 기존의 또는 보편적인 정량자들이 거의 없어서, 이들 계산들은 간단하다. 효율적인 구현은 함수들 lastSee, stronglySeeP, round, firstSelfWitnessS, 및 firstWitnessS를 메모하는 것을 수반할 것이다. 도 13b에서의 다른 함수들, 즉 parentRound, seeThru, stronglySeeS1, 및 firstSee는 메모되지 않을 수 있다. 각각은 이벤트 및 멤버의 함수이다. 따라서, 각각의 멤버에 대한 어레이의 하나의 요소와 함께, 각각의 이벤트에 대한 어레이를 저장함으로써 함수가 메모될 수 있다. 도 13a 내지 도 13e에서의 예시적인 정의들은 서로 재귀적으로 의존하며, 임의의 주어진 함수가 주어진 이벤트 x에 대해 호출될 때 그 함수가 x의 조상들에게만 x에 적용되는 그 함수 아래에 열거된 함수들에 의존하지 않도록 하는 순서로 열거된다.

일부 경우들에서, 컨센서스가 달성된 후에 분산 데이터베이스의 상태가 정의될 수 있다. 예를 들어, S(R)가 라운드 R에서 유명한 목격자들이 볼 수 있는 이벤트들의 세트이면, 결국 S(R) 내의 모든 이벤트들이 알려진 수신된 라운드 및 수신된 타임스탬프를 가질 것이다. 그 시점에서, S(R) 내의 이벤트들에 대한 컨센서스 순서는 알려져 있고 변경되지 않을 것이다. 이 시점에 도달하면, 멤버는 이벤트들 및 그 순서의 표현을 계산 및/또는 정의할 수 있다. 예를 들어, 멤버는 S(R) 내의 이벤트들의 해시 값을 그 컨센서스 순서로 계산할 수 있다. 그 후 멤버는 (그 멤버의 개인 키를 이용하여) 해시 값에 디지털 서명하고 그 멤버가 정의하는 다음 이벤트에 해시 값을 포함할 수 있다. 이는 S(R) 내의 이벤트들이 변경되지 않을 주어진 순서를 갖는다고 그 멤버가 결정했다는 것을 다른 멤버들에게 통지하는데 이용될 수 있다. 멤버들 중 적어도 M명(또는 임의의 다른 적합한 수 또는 백분율의 멤버들)이 S(R)에 대한 해시 값에 서명한(따라서 해시 값에 의해 표현되는 순서에 동의한) 후에, 멤버들의 서명들의 목록과 함께 이벤트들의 그 컨센서스 목록은 그 컨센서스 순서가 S(R) 내의 이벤트들에 대해 주장된 바와 같다는 것을 증명하는데 이용될 수 있는 단일 파일(또는 다른 데이터 구조)을 형성할 수 있다. 일부 경우들에서, 이벤트들이 (본 명세서에 설명된 바와 같이) 분산 데이터베이스 시스템의 상태를 업데이트하는 트랜잭션들을 포함한다면, 해시 값은 컨센서스 순서로 S(R) 내의 이벤트들의 트랜잭션들을 적용한 후의 분산 데이터베이스 시스템의 상태로 이루어질 수 있다.

일부 경우들에서, (위에 설명된 바와 같은) M은 전체 멤버들의 수의 단지 분수, 백분율 및/또는 값이 아니라, 각각의 멤버에 할당된 가중치 값들에 기반할 수 있다. 이러한 경우에, 각각의 멤버는 분산 데이터베이스 시스템에서 그 관심 및/또는 영향과 연관된 지분(stake)을 갖는다. 이러한 지분은 가중치 값일 수 있다. 그 멤버에 의해 정의된 각각의 이벤트는 그를 정의한 멤버의 가중치 값을 갖는다고 말할 수 있다. 그러면 M은 모든 멤버들의 전체 지분의 분수일 수 있다. M에 의존하는 것으로서 위에 설명된 이벤트들은 적어도 M의 지분 합을 갖는 멤버들의 세트가 동의할 때 발생할 것이다. 따라서, 그 지분에 기반하여, 특정 멤버는 컨센서스 순서가 도출되는 방식 및 시스템에 더 큰 영향을 미칠 수 있다. 일부 경우들에서, 이벤트에서의 트랜잭션은 하나 이상의 멤버의 지분을 변경하고, 새로운 멤버들을 추가하고, 및/또는 멤버들을 삭제할 수 있다. 이러한 트랜잭션이 R의 수신된 라운드를 가진다면, 수신된 라운드가 계산된 후에, 라운드 R 목격자들 이후의 이벤트들은 수정된 지분들 및 수정된 멤버들의 목록을 이용하여 그 라운드 번호들 및 다른 정보를 재계산할 것이다. 라운드 R 이벤트들이 유명한지 여부에 대한 투표들은 오래된 지분들 및 멤버 목록을 이용할 것이지만, R 이후의 라운드들에 대한 투표들은 새로운 지분들 및 멤버 목록들을 이용할 것이다. 컨센서스들을 결정하기 위해 가중치 값들을 이용하는 것에 관한 추가 상세들은 2016년 12월 21일자로 미국 특허 출원 제15/387,048호로서 출원되고 발명의 명칭이 "Methods And Apparatus For A Distributed Database Within A Network"인 미국 특허 제9,646,029호에 설명되어 있으며, 이 특허는 그 전체가 본 명세서에 참조로 포함된다.

일부 경우들에서, 특정 멤버들은 "레이지 멤버들(lazy members)"로서 식별 및/또는 지정될 수 있다. 이러한 경우들에서, 레이지 멤버들은 정상 멤버들 또는 비-레이지 멤버들(non-lazy members)과 유사한 이벤트들을 정의 및/또는 생성할 수 있다. 또한, 레이지 멤버들에 의해 정의 및/또는 생성된 이벤트들이 해시그래프에 포함될 수 있고 이러한 이벤트들에 대한 컨센서스 순서가 계산 및/또는 식별될 수 있다. 그러나, 레이지 멤버들에 의해 정의된 이벤트들에 대한 라운드 증분은 0이다. 따라서, 레이지 멤버들에 의해 정의된 이벤트에 대한 라운드 번호(또는 라운드 생성)는 이벤트의 부모들의 라운드 번호들의 최대치와 같다. 유사하게 말해서, 레이지 멤버들에 의해 정의된 이벤트에 대한 라운드 증분이 0이기 때문에, 레이지 멤버들에 의해 정의된 이벤트에 대한 라운드 번호(또는 라운드 생성)는 이벤트의 부모들의 라운드 번호들의 최대치보다 클 수 없다.

또한, 일부 경우들에서, 레이지 멤버들에 의해 정의된 이벤트들은 정의된 선거들에서 투표할 자격이 없고 레이지 멤버들에 의해 이벤트들은 라운드 R 제1 이벤트들 또는 목격자들이 될 자격이 없고/없거나, 다른 이벤트를 강력하게 보기 위해 정상 또는 비-레이지 멤버에 의해 정의된 이벤트에 대한 중간 이벤트들로서 카운팅하지 않는다. 따라서, 레이지 멤버들에 부과된 제한들은 보안 및 컨센서스 순서의 무결성을 여전히 유지하면서 해시그래프에 의해 수행되는 계산들의 감소를 야기한다. 멤버들은 임의의 적합한 기준들에 기반하여 레이지 멤버들로서 선택될 수 있다. 예를 들어, 일부 경우들에서 멤버들은 각각의 라운드에서 실행되는 결정론적 의사랜덤 선택에 기반하여 레이지 멤버들로서 지정되거나, 라운드의 시작에서, 신뢰 레벨들에 기반하여, 지분의 양에 기반하여, 다른 멤버들의 투표에 기반하여 미리 정의되거나, 및/또는 랜덤하게 선택될 수 있다. 일부 경우들에서, 레이지 멤버들로서 지정된 멤버들은 각각의 라운드에 대해 상이할 수 있는 반면, 일부 다른 경우들에서, 레이지 멤버들로서 지정된 멤버들은 상이한 라운드들에 걸쳐 동일하게 유지된다. 일부 다른 경우들에서, 멤버들이 아니라 이벤트들이 "레이지" 이벤트들로서 지정될 수 있다. 이러한 경우에, 멤버들을 선택하는 대신에 각각의 라운드에서 레이지 이벤트들이 선택될 수 있다.

따라서, 일부 경우들에서, 제1 멤버의 프로세서는 결정론적 의사랜덤 함수에 기반하여 멤버들(예컨대, 컴퓨팅 디바이스들)의 제1 그룹 및 멤버들(예컨대, 컴퓨팅 디바이스들)의 제2 그룹을 정의할 수 있다. 멤버들의 제1 그룹은 비-레이지 멤버들일 수 있고 멤버들의 제2 그룹은 레이지 멤버들일 수 있다. 일부 경우들에서, 멤버들의 제1 그룹은 분산 데이터베이스의 멤버들(예컨대, 컴퓨팅 디바이스들)에 관하여 멤버들의 제2 그룹의 절대 여집합(absolute complement)이다. 제1 멤버(또는 제1 멤버의 프로세서)는 제2 멤버(예컨대, 컴퓨팅 디바이스)로부터 멤버들의 세트(예컨대, 컴퓨팅 디바이스들의 세트)에 의해 정의된 이벤트들의 제1 세트에 링크된 이벤트를 수신할 수 있다. 멤버들의 세트는 멤버들의 제1 그룹으로부터의 적어도 하나의 멤버 및 멤버들의 제2 그룹으로부터의 적어도 하나의 멤버를 포함한다. 프로세서는 멤버들의 제1 그룹으로부터의 멤버에 의해 정의된 이벤트들의 제1 세트로부터의 이벤트의 파라미터(예컨대, 라운드 번호, 라운드 증분, 투표, 목격자임의 표시, 유명한 목격자임의 표시 등)에 대한 값을 이용하여 그리고 멤버들의 제2 그룹으로부터의 멤버에 의해 정의된 이벤트들의 제1 세트로부터의 이벤트에 파라미터에 대한 값을 이용하지 않고 (예컨대, 본 명세서에 설명된 바와 같이) 컨센서스 프로토콜의 결과로서 이벤트들의 제2 세트와 연관된 순서를 식별할 수 있다. 프로세서는 이벤트들의 제2 세트와 연관된 순서에 적어도 부분적으로 기반하여 분산 데이터베이스의 인스턴스에서 표시된 트랜잭션들의 세트와 연관된 순서를 식별할 수 있고 트랜잭션들의 세트와 연관된 순서를 분산 데이터베이스의 인스턴스에 저장할 수 있다.

전술한 용어들, 정의들, 및 알고리즘들은 도 8 내지 도 13e에서 설명된 실시예들 및 개념들을 예시하는데 이용된다. 도 10a 및 도 10b는 수학적 형식으로 도시된 컨센서스 방법 및/또는 프로세스의 제1 예시적인 응용을 예시한다. 도 11a 및 도 11b는 수학적 형태로 도시된 컨센서스 방법 및/또는 프로세스의 제2 예시적인 응용을 예시하고, 도 12a 및 도 12b는 수학적 형태로 도시된 컨센서스 방법 및/또는 프로세스의 제3 예시적인 응용을 예시하며, 도 13a 내지 도 13e는 수학적 형태로 도시된 컨센서스 방법 및/또는 프로세스의 제4 예시적인 응용을 예시한다.

도 2에서, 데이터베이스 수렴 모듈(211)과 통신 모듈(212)은 프로세서(210)에서 구현되는 것으로 도 2에 도시되어 있다. 일부 실시예들에서, 데이터베이스 수렴 모듈(211) 및/또는 통신 모듈(212)은 메모리(220)에서 구현될 수 있다. 일부 실시예들에서, 데이터베이스 수렴 모듈(211) 및/또는 통신 모듈(212)은 하드웨어 기반(예컨대, ASIC, FPGA 등)일 수 있다.

트랜잭션들이 (예를 들어, 도 1과 관련하여 본 명세서에 설명된 바와 같이) 분산 데이터베이스에서 데이터 및/또는 상태를 변경할 수 있는 것처럼, 트랜잭션들은 또한 분산 데이터베이스의 멤버들을 추가, 제거, 및/또는 수정함으로써 분산 데이터베이스의 멤버십(예를 들어, 분산 데이터베이스를 구현하는 컴퓨팅 디바이스들의 세트)을 수정할 수 있다. 일부 구현들에서, 분산 데이터베이스의 멤버들은 분산 데이터베이스를 구현하는 컴퓨팅 디바이스들의 세트(예를 들어, 도 1의 컴퓨팅 디바이스들(110, 120, 130, 140))로부터 하나 이상의 컴퓨팅 디바이스를 추가 및/또는 제거함으로써 시간 경과에 따라 변경될 수 있다. 유사하게 말하면, 분산 데이터베이스를 구현하는 컴퓨팅 디바이스들(110, 120, 130, 140)의 세트는 컴퓨팅 디바이스들(110, 120, 130, 140)의 세트로부터의 컴퓨팅 디바이스들이 컴퓨팅 디바이스들(110, 120, 130, 140)의 세트로부터 제거되고/되거나, 다른 컴퓨팅 디바이스들이 분산 데이터베이스를 구현하는 컴퓨팅 디바이스들(110, 120, 130, 140)의 세트에 추가됨에 따라, 시간 경과에 따라 변경될 수 있다. 일부 경우들에서, 제거된 컴퓨팅 디바이스들은 나중에 분산 데이터베이스 시스템에 재연결될 수 있다.

주소록은 임의의 주어진 시간에 분산 데이터베이스의 멤버들(즉, 분산 데이터베이스를 구현하는 컴퓨팅 디바이스들)을 추적하는데 이용될 수 있다. 도 14는 일 실시예에 따른, 분산 데이터베이스 시스템과 연관된 주소록(1400)을 도시한다. 주소록(1400)은 도 1의 분산 데이터베이스 시스템(100)에서의 컴퓨팅 디바이스들(110, 120, 130, 140) 각각에 대한 엔트리를 포함한다. 구체적으로, 주소록(1400)은 분산 데이터베이스를 구현하는 컴퓨팅 디바이스들(도 1과 관련하여 도시되고 설명된 컴퓨팅 디바이스들(110, 120, 130, 140))의 세트의 공개 키들(A, B, C 및 D)의 세트를 포함하도록 정의된다. 컨센서스를 결정하는데 지분(예를 들어, 디바이스의 지분은 디바이스가 컨센서스 프로세스에 대해 갖는 영향의 양을 나타냄)이 이용되는 구현들에서, 주소록(1400)은 또한 각각의 컴퓨팅 디바이스와 연관된 지분의 양을 포함할 수 있다.

트랜잭션들이 분산 데이터베이스를 구현하는 컴퓨팅 디바이스들의 세트로부터 컴퓨팅 디바이스들을 추가, 제거 및/또는 수정할 때, 트랜잭션들은 주소록을 변경 및/또는 업데이트할 수 있다. 예를 들어, 분산 데이터베이스로부터 컴퓨팅 디바이스(140)를 제거하기 위한 트랜잭션이 분산 데이터베이스에 입력되고 (예를 들어, 분산 데이터베이스의 컨센서스 순서 내에서) 순서화되는 경우, 트랜잭션이 실행될 수 있고, 컴퓨팅 디바이스(140)는 분산 데이터베이스로부터 제거될 수 있다. 이 트랜잭션에 응답하여, 컴퓨팅 디바이스(140)에 대한 엔트리를 포함하지 않는 새로운 주소록이 정의될 수 있다. 다른 예로서, 분산 데이터베이스에 새로운 컴퓨팅 디바이스를 추가하기 위한 트랜잭션이 분산 데이터베이스에 입력되고 (예를 들어, 분산 데이터베이스의 컨센서스 순서 내에서) 순서화되는 경우, (예를 들어, 공개 키 및/또는 지분의 양을 포함하는) 엔트리를 갖는 새로운 주소록이 새로운 컴퓨팅 디바이스에 대해 정의될 수 있다. 또 다른 예로서, 하나 이상의 컴퓨팅 디바이스와 연관된 지분의 양을 변경하기 위한 트랜잭션이 분산 데이터베이스에 입력되고 순서화되는 경우, 지분에서의 변경을 반영하는 새로운 주소록이 정의될 수 있다. 예를 들어, 지분이 각각의 컴퓨팅 디바이스에 의해 보유된 암호화폐 코인의 양을 반영하면, 트랜잭션은 컴퓨팅 디바이스(140)가 컴퓨팅 디바이스(130)에 5개의 코인을 이송하는 것을 반영할 수 있다. 트랜잭션이 순서화되고 실행된 후에, 컴퓨팅 디바이스(140)가 이제 70개의 코인을 갖는 반면 컴퓨팅 디바이스(130)는 35개의 코인을 갖는다는 것을 반영하는 새로운 주소록이 정의될 수 있다.

일부 구현들에서, 컨센서스 프로토콜의 각각의 라운드는 새로운 주소록을 가질 수 있다(예를 들어, 분산 데이터베이스를 구현하는 각각의 컴퓨팅 디바이스는 컨센서스 프로토콜의 각각의 라운드에 대해 그 주소록을 업데이트할 수 있다). 구체적으로, 주소록 내의 정보가 (예를 들어, 분산 데이터베이스를 구현하는 컴퓨팅 디바이스를 추가, 제거 및/또는 수정하기 위한 트랜잭션을 통해) 변경될 때, 각각의 컴퓨팅 디바이스는 주소록에 변경을 행하는 트랜잭션을 반영하기 위해 그 주소록을 업데이트할 수 있다. 이러한 변경들은 이러한 변경들을 포함하는 이벤트가 컨센서스 프로토콜을 통해 수신된 라운드를 할당받은 후에 라운드에 대해 주소록에 반영될 수 있다. 구체적으로, 라운드 r에 대한 주소록 A _r 은 r보다 작은 수신된 라운드를 갖는 이벤트들에서의 트랜잭션들(즉, r-1 이하의 수신된 라운드를 갖는 이벤트들에서의 트랜잭션들)을 반영할 수 있다. 유사하게, 일단 r의 수신된 라운드를 갖는 이벤트들이 식별되었으면, 라운드 r+1에 대한 새로운 주소록 A _r+1 이 정의되어 r+1보다 작은 수신된 라운드를 갖는 트랜잭션들을 구현할 수 있다. 따라서, 이러한 구현들에서, 주소록은 각각의 라운드에 대해 업데이트될 수 있다. 이것은 트랜잭션들이 주소록에 빠르게 영향을 미치는 것을 보장할 수 있다.

일부 구현들에서, 라운드 r에 대한 주소록 A _r 은 각각의 라운드에 대해 업데이트되지 않고, 대신에 r의 수신된 라운드를 갖는 이벤트들이 식별된 후에 미리 결정된 수의 라운드 p로 업데이트된다(예를 들어, 분산 데이터베이스를 구현하는 각각의 컴퓨팅 디바이스는 이에 따라 그 주소록을 업데이트할 수 있다). 예를 들어, 이러한 구현들에서, 라운드 r에 대한 주소록 A _r 은 r-p 이하의 수신된 라운드를 갖는 이벤트들에서 유효한 트랜잭션들에 의해 이후 수정되는 A _r-p 의 사본으로 정의된다. 따라서, p=2인 경우, 라운드 r에 대한 주소록 A _r 은 r-2 이하의 수신된 라운드를 갖는 이벤트들 내에서 주소록에 영향을 미치는 트랜잭션들로부터의 업데이트들(예를 들어, 분산 데이터베이스를 구현하는 컴퓨팅 디바이스들을 추가, 제거 및/또는 수정하는 것)을 포함한다. 일부 구현들에서, p에 대한 임의의 다른 적합한 값(예를 들어, 3, 4, 5 등)이 이용될 수 있다. 이것은 새로운 주소록이 컨센서스 프로토콜 내에서 이용되기 전에 컨센서스 트랜잭션들을 처리하기 위한 p-1 라운드들의 지속기간을 (예를 들어, 백그라운드 스레드를 이용하여) 컴퓨팅 디바이스에 제공한다. 이러한 가외의 시간은 컨센서스 프로토콜에서의 일시정지들 및/또는 지연들을 피하는 것을 도울 수 있다.

일부 구현들에서, 라운드 r에 대한 주소록 A _r 은 그 대신에 주소록에 대한 이전 업데이트 후에 미리 결정된 수의 라운드 p로 업데이트된다(예를 들어, 분산 데이터베이스를 구현하는 각각의 컴퓨팅 디바이스는 이에 따라 그 주소록을 업데이트할 수 있다). 예를 들어, 이러한 구현들에서, 라운드 r에 대한 주소록 A _r 은 p의 배수가 아닌 임의의 라운드에 대한 A _r-1 의 사본으로 정의될 수 있다. 그렇지 않으면, 주소록 A _r 은 r-1 이하의 수신된 라운드를 갖는 이벤트들에서의 트랜잭션들을 반영한다. 유사하게 말하면, 주소록은 p 라운드마다 업데이트될 수 있다. 예로서, p=10인 경우, A _r 은 10의 배수가 아닌 임의의 라운드 r에 대한 A _r-1 의 수정되지 않은 사본으로 정의될 수 있다. 그렇지 않고, r이 10의 배수인 경우, A _r 은 r-10 내지 r-1의 수신된 라운드들을 갖는 이벤트들에서 유효한 트랜잭션들에 의해 수정되는 A _r-10 의 사본이다. 일부 구현들에서, 배수 p는 임의의 적합한 수(예를 들어, 2, 5, 10, 20 등)일 수 있다. 이것은 (본 명세서에서 더 상세히 설명되는 바와 같이) 새로운 주소록들이 정의될 때 이벤트의 라운드 번호(또는 라운드 생성)의 더 적은 재계산을 가능하게 한다. 구체적으로, 주소록을 업데이트하기 전에 주소록에 대한 변경들의 다수의 라운드를 배치(batch)하는 것은 동일한 주소록이 다수의 라운드에 대한 라운드 번호들을 계산하고 재계산하는데 이용되는 것을 보장한다. 다수의 라운드에 대해 동일한 주소록을 이용하는 것은 주소록이 변경된 후에 이벤트의 라운드 번호(또는 라운드 생성)를 재계산할 필요성을 감소시킨다.

일부 구현들에서, 컨센서스 프로토콜은 주소록에 대한 이전 업데이트 후에 미리 결정된 수의 라운드 p를 대기할 뿐만 아니라 주소록을 업데이트하기 전에 컨센서스가 달성된 후에 미리 결정된 수의 라운드 k를 대기할 수 있다. 예를 들어, 이러한 구현들에서, 라운드 r에 대한 주소록 A _r 은 p의 배수가 아닌 임의의 라운드에 대한 A _r-1 의 사본으로 정의될 수 있다. 그렇지 않고, 라운드가 p의 배수이면, 주소록 A _r 은 r-k 이하의 수신된 라운드를 갖는 이벤트들에서의 트랜잭션들을 반영할 수 있다. 예로서, p=10 및 k=2인 경우, A _r 은 10의 배수가 아닌 임의의 r에 대한 A _r-1 의 수정되지 않은 사본으로 정의될 수 있다. 그렇지 않고, r이 10의 배수인 경우, A _r 은 r-11 내지 r-2의 수신된 라운드들을 갖는 이벤트들에서 유효한 트랜잭션들에 의해 수정되는 A _r-11 의 사본이다. 이것은 새로운 주소록이 컨센서스 프로토콜 내에서 이용되기 전에 컨센서스 트랜잭션들을 처리하기 위해 각각의 컴퓨팅 디바이스에 (예를 들어, 백그라운드 스레드를 이용하여) 추가적인 시간을 제공하는 이점과 함께 주소록에 적용하기 전에 변경들의 다수의 라운드를 배치하는 이점을 제공할 수 있다.

라운드 r에서 유명한 목격자들에 대한 컨센서스에 도달한 후에, r의 수신된 라운드를 갖는 이벤트들이 식별될 수 있고, 새로운 주소록 A _r+1 이 (위에서 논의된 바와 같이) 계산될 수 있다. 일부 구현들에서, 각각의 이벤트는 새로운 주소록 A _r+1 을 이용하여 그 라운드 생성이 재계산되게 할 수 있다. 이것은 라운드 r+1에서 유명한 목격자들을 식별하기 위해 행해진다. 따라서, 각각의 주소록에 대해 그리고 그 주소록과 연관된 라운드에 대해, 이벤트는 상이한 라운드 생성을 가질 수 있다.

일부 구현들에서, 이벤트들에 대한 재계산된 생성된 라운드들의 수를 감소시키기 위해, 일부 이벤트들은 동결된 것으로 식별될 수 있다. 동결된 이벤트는 새로운 주소록이 정의될 때 그 라운드 생성이 재계산되지 않는다. 구체적으로, 이벤트가 라운드 r 또는 그 이전의 임의의 유명한 목격자들의 조상인 경우, 이것은 동결된 것으로 고려될 수 있고, 그 라운드 생성은 후속 라운드들에서 또는 후속 주소록들을 이용하여 재계산되지 않는다. 그러나, 이벤트가 라운드 r 또는 그 이전의 임의의 유명한 목격자들의 조상이 아닌 경우, (라운드 r+1에 대한 주소록이 라운드 r에 대한 주소록으로부터 변경되었다면) 라운드 r+1에서 라운드 r+1에 대한 주소록 A _r+1 을 이용하여 그 라운드 생성이 재계산된다. 유사하게, 앞으로 이동하면, 라운드 r+1에서의 유명한 목격자들이 식별되고 r+1의 수신된 라운드를 갖는 이벤트들이 식별된 후에, 추가적인 이벤트들은 이들이 라운드 r+1 또는 그 이전의 유명한 목격자의 조상인 경우에 동결될 수 있다. 이러한 동결된 이벤트들은 라운드 r+2에서 그 라운드 생성이 재계산되지 않을 것이다. 이것은 유사하게 컨센서스 프로토콜의 미래의 라운드들에 대해 계속될 수 있다.

일부 구현들에서, 재계산은, 부모 라운드가 r+2일 때 (강력하게 보는 것이 아니라) 다수를 보고(또는 식별하고), 부모 라운드가 r+1일 때 (대다수가 아니라) 단지 하나를 보는, 2개의 라운드에 대해 수정될 수 있다. 이것은 레이턴시와 계산 복잡성 사이의 절충을 제어할 수 있고, 이것은 계산 비용을 증가시키지만, 컨센서스를 달성하기 위한 레이턴시를 감소시킨다. 일부 구현들에서, 분산 데이터베이스를 구현하는 각각의 컴퓨팅 디바이스가 많은 다른 컴퓨팅 디바이스들과 실질적으로 동시에 동기화되게 함으로써, 예컨대 각각의 이벤트가 다수의 다른 부모 이벤트를 갖는 것을 허용함으로써 레이턴시가 또한 감소될 수 있다.

도 15는 일 실시예에 따른, 주소록을 업데이트하는 방법(1500)을 예시하는 흐름도이다. 방법(1500)은 분산 데이터베이스를 구현하는 컴퓨팅 디바이스들의 세트로부터의 컴퓨팅 디바이스의 프로세서에 의해 실행될 수 있다. 방법(1500)은, 1502에서, 분산 데이터베이스에 대한 주소록을 정의하는 단계를 포함한다. 일부 구현들에서, 주소록은 네트워크를 통해 분산 데이터베이스를 구현하는 컴퓨팅 디바이스들의 세트로부터의 각각의 컴퓨팅 디바이스에 대한 식별자(예를 들어, 공개 키) 및/또는 다른 정보(예를 들어, 지분 값)를 포함한다.

1504에서, 주소록을 업데이트하기 위한 트랜잭션을 포함하는 이벤트가 수신된다. 예를 들어, 이벤트는 분산 데이터베이스를 구현하는 컴퓨팅 디바이스들의 세트에 컴퓨팅 디바이스를 추가하고, 분산 데이터베이스를 구현하는 컴퓨팅 디바이스들의 세트로부터 컴퓨팅 디바이스를 제거하고, 분산 데이터베이스를 구현하는 컴퓨팅 디바이스들의 세트로부터의 컴퓨팅 디바이스와 연관된 지분 값을 업데이트하는 것 등을 위한 트랜잭션을 포함할 수 있다.

1506에서, 주소록을 이용하는 분산 데이터베이스의 컨센서스 프로토콜에 기반하여, 이벤트에 대한 수신된 라운드가 계산된다. 예를 들어, 본 명세서에 개시된 것들과 같은 임의의 적합한 컨센서스 프로토콜이 이벤트에 대한 수신된 라운드(또는 순서와 연관된 속성)를 계산하는데 이용될 수 있다.

1508에서, 이벤트에 대한 수신된 라운드 또는 주소록에 대한 이전 업데이트 중 적어도 하나 후에 미리 결정된 수의 라운드로 업데이트된 주소록을 정의하기 위해 주소록이 트랜잭션에 기반하여 업데이트된다. 전술한 바와 같이, 일부 구현들에서, 주소록은 이벤트에 대한 수신된 라운드 후에 미리 결정된 수의 라운드로 트랜잭션에 기반하여 업데이트될 수 있다. 일부 구현들에서, 주소록은 주소록에 대한 이전 업데이트(예를 들어, 라운드가 p의 배수일 때 발생하는 주소록에 대한 업데이트들) 후에 미리 결정된 수의 라운드로 업데이트될 수 있다.

일부 구현들에서, 컨센서스 프로토콜은 컨센서스 프로토콜의 각각의 라운드에 대한 이벤트들(예를 들어, 유명한 목격자들)의 세트를 식별하도록 구성된다. 각각의 라운드에 대한 이벤트들의 세트는 이벤트들의 그룹으로부터의 각각의 이벤트에 대한 수신된 라운드를 결정하기 위해 컨센서스 프로토콜에 의해 이용될 수 있다. 더욱이, 주소록을 이용하여 이벤트들의 그룹으로부터의 각각의 이벤트에 대해 속성(예컨대, 라운드 생성)이 계산될 수 있다. 그 이벤트가 업데이트된 주소록이 정의되는 라운드에 대한 이벤트들의 세트로부터의 적어도 하나의 이벤트의 조상이 아닐 때, 업데이트된 주소록을 이용하여 이벤트들의 그룹으로부터의 각각의 이벤트에 대해 속성이 재계산될 수 있다. 유사하게, 이벤트들의 그룹으로부터의 그 이벤트가 업데이트된 주소록이 정의되는 라운드에 대한 이벤트들의 세트로부터의 적어도 하나의 이벤트의 조상일 때, 업데이트된 주소록을 이용하여 이벤트들의 그룹으로부터의 각각의 이벤트에 대해 속성이 재계산되지 않는다.

일부 구현들에서, 이벤트들은 분산 데이터베이스에 그리고/또는 DAG의 일부로서 무기한으로 유지된다. 일부 구현들에서, 이벤트들은 이벤트들이 오래됨에 따라 폐기될 수 있다. 예를 들어, 이벤트가 충분히 오래된 경우, 그 이벤트는 고대(ancient)로서 분류될 수 있다. 일부 구현들에서, 컴퓨팅 디바이스는 선택적으로 분산 데이터베이스의 그 컴퓨팅 디바이스의 인스턴스로부터 고대 이벤트를 삭제할 수 있다. 이벤트가 훨씬 더 오래된 경우, 이벤트는 만료된 것으로 분류될 수 있고, 컴퓨팅 디바이스는 분산 데이터베이스의 그 컴퓨팅 디바이스의 인스턴스로부터 그 이벤트를 폐기한다. 분산 데이터베이스가 이벤트가 고대인 시간까지 이벤트에 대한 컨센서스에 도달하지 않은 경우(예를 들어, 분산 데이터베이스가 그 이벤트에 대한 수신된 라운드를 식별하지 않은 경우), 그 이벤트는 진부한(stale) 것으로 분류될 수 있다. 이러한 구현들에서, 진부한 것으로 분류된 이벤트는 수신된 라운드 또는 컨센서스 타임스탬프를 할당받지 않을 것이고, 컨센서스 순서의 일부가 되지 않을 것이고, 이벤트 내의 트랜잭션들은 처리되지 않을 것이다. 따라서, 이벤트 내의 트랜잭션들은 공유 상태 또는 주소록에 영향을 미치지 않을 것이다. 더욱이, 이벤트가 만료될 때, 이벤트는 다른 멤버들(분산 데이터베이스를 구현하는 컴퓨팅 디바이스들)과의 동기화 동안 더 이상 전송되지 않는다. 그러나, 일부 구현들에서, 멤버들은 동기화 동안 고대 이벤트들을 계속 교환하여, 뒷 시간(behind time)일 수 있는 멤버들이 이러한 이벤트들을 여전히 고려하게 할 수 있다(예를 들어, 뒤에 있는 이러한 멤버들은 여전히 이러한 이벤트들을 고대로서 고려하지 않을 수 있다).

일부 경우들에서, 이벤트는 모든 그 부모들이 DAG 또는 해시그래프에 이미 존재하는 경우에만 DAG 또는 해시그래프에 추가된다. 다른 구현들에서, 부모가 DAG 또는 해시그래프에 존재하지 않지만 그 부모가 고대이거나 만료된 경우, 이벤트는 여전히 DAG 또는 해시그래프에 추가될 수 있다.

일부 구현들에서, 만료된 및/또는 고대 이벤트들에 대한 임계치는 이벤트가 생성될 때부터 고대 또는 만료될 때까지의 라운드들의 수에 의해 정의될 수 있다. 예로서, 임계치들은 expiredDuration > ancientDuration > 0으로서 정의될 수 있다. ancientDuration 및 expiredDuration에 대한 값들은 임의의 적합한 값들일 수 있다. 예를 들어, 일부 구현들에서, ancientDuration = 4 및 expiredDuration = 8이다. 다른 구현들에서, 임의의 다른 값들이 ancientDuration 및/또는 expiredDuration에 이용될 수 있다.

일부 구현들에서, 각각의 이벤트는 그 이벤트의 부모 이벤트들 각각에 대한 주장된 세대 번호(또는 세대)의 표시를 포함할 수 있다. 이러한 구현들에서, 이벤트에 대한 세대 번호는 이벤트의 부모들의 주장된 세대 번호들 중 최대치에 1을 더한 것일 수 있다. 부모가 없는 이벤트는 1의 세대 번호를 가질 수 있다.

분산 데이터베이스(또는 분산 데이터베이스를 구현하는 컴퓨팅 디바이스(들)), DAG 또는 해시그래프가 특정 수신된 라운드(예를 들어, 분산 데이터베이스가 수신된 라운드 r에 대한 컨센서스를 이전에 갖지 않았던 수신된 라운드 r)를 갖는 이벤트들에 대한 컨센서스에 도달할 때, 라운드 r에 대한 세대 번호는 라운드 r에서 유명한 목격자인 이벤트들의 최소 세대 번호일 수 있다. 일부 구현들에서, 이벤트 x는 이벤트 x가 컨센서스 미만 ancientDuration(consensus less ancientDuration)을 달성하기 위한 가장 최근의 라운드와 동일한 라운드의 세대 번호보다 작은 세대 번호를 갖는 경우 고대인 것으로 고려될 수 있다. 유사하게 말하면, 이벤트 x는 gen(x) < gen(r - ancientDuration)인 경우 고대인 것으로 고려될 수 있고, 여기서 gen(x)는 이벤트 x의 세대 번호이고, gen(r-ancientDuration)은 컨센서스 마이너스 ancientDuration을 달성하기 위한 가장 최근의 라운드 r로부터 생기는 라운드의 세대 번호이다. 유사하게, 일부 구현들에서, 이벤트 x는 이벤트 x가 컨센서스 미만 expiredDuration을 달성하기 위한 가장 최근의 라운드와 동일한 라운드의 세대 번호보다 작은 세대 번호를 갖는 경우(또는 gen(x) < gen(r - expiredDuration)인 경우) 만료된 것으로 고려될 수 있다.

일부 구현들에서, 라운드 r에 대한 이벤트들의 코어 세트 S _r 이 정의될 수 있다. 라운드 r에 대한 이벤트들의 코어 세트는 라운드 r에 대한 컨센서스에 도달한 직후에 동결된, 비-고대, 비-만료된 이벤트들로서 정의될 수 있다. 유사하게 말하면, 라운드 r에 대한 이벤트들의 코어 세트 S _r 은 라운드 r에서의 동결된 목격자들의 세트와 함께, 라운드 r 및 이전 라운드들에서의 그 조상들일 수 있고, 그 세대들은 이벤트들이 고대 또는 만료되지 않도록 충분히 최근이다. 이벤트들의 코어 세트는 본 명세서에 설명된 분산 데이터베이스 시스템들이 ABFT(asynchronous byzantine fault tolerance) 속성을 계속 갖는 것을 증명하는데 유용할 수 있다. 예를 들어, 이벤트들이 아직 폐기되지 않았고 주소록이 아직 변경되지 않았기 때문에, 라운드 1의 기본 사례에 대한 컨센서스가 보장될 수 있다. 그 후, 라운드 r에 대해 컨센서스가 참이고, 모든 정직한 멤버들이 이벤트들의 동일한 코어 세트 S _r 및 라운드 r+1에 대한 동일한 주소록을 갖는다면, 모두가 라운드 r+1에서 동일한 컨센서스에 도달하여, 이벤트들의 동일한 코어 세트 S _r+1 및 r+1에 대한 컨센서스 이벤트들 및 r+2에 대한 주소록에 대해 동의할 것이다. 따라서, 유도에 의해 컨센서스가 증명될 수 있다.

일부 구현들에서, 새로운 멤버(컴퓨팅 디바이스)가 분산 데이터베이스에 조인하는 경우 및/또는 멤버가 분리된 후에 분산 데이터베이스에 재연결하는 경우, 그 멤버는 컨센서스가 획득된 최근 라운드 r에서와 같은, 다른 멤버(컴퓨팅 디바이스)로부터 분산 데이터베이스와 연관된 최신 정보 및 이벤트들을 수신할 수 있다. 일부 구현들에서, 최신 정보는 미리 결정된 수 및/또는 백분율의 현재 멤버들 및/또는 분산 데이터베이스의 지분(예를 들어, 멤버들의 1/3 및/또는 분산 데이터베이스 내의 총 지분의 1/3)에 의해 디지털 서명된 분산 데이터베이스의 상태일 수 있다. 라운드 r까지의 컨센서스 트랜잭션들의 결과들을 반영하는 라운드 r에서와 같은 서명된 상태에 더하여, 새로운 또는 재연결 멤버는 해시그래프, DAG 및/또는 분산 데이터베이스에 관한 추가 정보를 획득할 수 있다. 예를 들어, 새로운 또는 재연결 멤버는, 다른 멤버로부터, 라운드 r에 대한 코어 세트 S _r 내의 이벤트들, 라운드 r에 대한 코어 세트 S _r 내의 이벤트들의 해시 값들 및/또는 r이 컨센서스를 갖는 최신 라운드인 순간에서와 같은, 각각의 비-고대 라운드에서 고유 유명한 목격자들의 최소 세대를 수신할 수 있다. 이러한 정보가 주어지면, 새로운 또는 재연결 멤버는 해시그래프, DAG 및/또는 분산 데이터베이스에 조인하거나 다시 조인할 수 있다.

일부 구현들에서, 가능한 경우, 재연결 멤버는 해시그래프, DAG 및/또는 분산 데이터베이스를 재부팅하거나 떠나기 전에 그 이벤트들 및/또는 그 해시그래프, DAG 및/또는 분산 데이터베이스의 인스턴스의 상태를 메모리에 기입할 수 있다. 그 후 재연결 멤버는 재부팅 후에 그리고/또는 해시그래프, DAG 및/또는 분산 데이터베이스에 재연결할 때 이벤트들 및/또는 상태를 판독할 수 있다. 이것은 재부팅 후에 그리고/또는 멤버가 해시그래프, DAG 및/또는 분산 데이터베이스에 재연결 및/또는 다시 조인할 때 동기화를 위한 대역폭을 절약할 수 있지만, 요구되지는 않는다.

예로서, 멤버 컴퓨팅 디바이스 Alice는 (컴퓨팅 디바이스 Alice에서의 프로세서를 이용하여) 분산 데이터베이스의 Alice의 인스턴스에서 DAG 및/또는 해시그래프를 이용하여 라운드 r까지 그리고 이를 포함하는 라운드들에 대한 분산 데이터베이스의 유명한 목격자들을 결정 및/또는 식별할 수 있다. Alice는 그 후 r 이하의 수신된 라운드를 갖는 이벤트들에 대한 컨센서스 순서를 계산할 수 있다. 컨센서스 순서를 이용하여, Alice는 컨센서스 순서로 이벤트들 내의 트랜잭션들을 처리하여 분산 데이터베이스의 상태를 결정할 수 있다. Alice는 분산 데이터베이스의 상태의 해시 값을 계산하고, 그 상태의 해시 값을 포함하는 트랜잭션과 함께 새로운 이벤트를 정의하고 이를 전송할 수 있다. Alice는 Alice의 개인 키를 이용하여 이 이벤트 및/또는 트랜잭션에 디지털 서명할 수 있다. 그 후 Alice는 분산 데이터베이스의 상태가 미리 결정된 수 및/또는 백분율의 현재 멤버들 및/또는 분산 데이터베이스의 지분(예를 들어, 적어도 멤버들의 1/3 및/또는 분산 데이터베이스 내의 총 지분의 1/3)에 의해 디지털 서명되도록 그 상태와 일치하는 분산 데이터베이스의 다른 멤버들로부터 디지털 서명들을 수집할 수 있다.

이 예에서, 컴퓨팅 디바이스 Bob이 (예를 들어, 이벤트에서 트랜잭션을 통해 주소록에 추가됨으로써) 네트워크에 조인(또는 재연결)하면, Alice는 그에게 라운드 r에 대한 서명된 상태(예를 들어, 미리 결정된 수 및/또는 백분율의 현재 멤버들 및/또는 분산 데이터베이스의 지분에 의해 디지털 서명되는 라운드 r에 대한 상태)를 전송할 수 있다. 그 후 Bob은 분산 데이터베이스의 다른 멤버들과의 동기화를 시작할 수 있다. 구체적으로, 그는 다른 멤버들과의 동기화를 통해 이벤트들을 수신할 수 있다. Bob은 먼저 (라운드 r의 끝에서와 같은 고대의 정의에 따라) 고대는 아니지만 그 부모가 고대인 이벤트를 수락할 수 있다. 그 후 Bob은 그 부모가 고대이거나, 또는 Bob이 수신한 더 오래된 이벤트들 중의 이벤트들을 수락할 수 있다. 이러한 이벤트들을 이용하여, Bob은 DAG를 구성 및/또는 정의하기 시작할 수 있다. 이것은 Bob이 현재까지의 이벤트들을 수신할 때까지 계속될 수 있고, 그 시점에서 Bob은 따라잡히고 전체 참여 멤버일 수 있다.

참여 멤버로서, Bob은 Bob이 앞으로 수신하는 이벤트들에 대한 수신된 라운드를 계산할 수 있다. 상이한 주소록들이 (본 명세서에서 논의된 바와 같이) 상이한 라운드들에 대해 이용되기 때문에, Bob은 주소록 A _r+1 을 이용하여 이벤트들 각각에 대한 수신된 라운드를 간단히 계산할 수 없다. 따라서, 일부 구현들에서, 서명된 상태는 S _r 에서의 각각의 이벤트에 대한 라운드 생성과 함께, S _r 에서의 각각의 이벤트를 갖는 (Alice로부터의) Bob을 포함하고/하거나 Bob에 전송될 수 있다. 그 후 Bob은 S _r 에서의 각각의 이벤트에 대한 컨센서스 라운드 생성을 알 것이다. 이 정보를 이용하여, Bob은 이어서 라운드들 r-1 및 그 이후의 라운드들에서의 이벤트들에 대한 컨센서스 라운드 생성을 계산할 수 있다. r-1 이전에 라운드 생성을 갖는 이벤트들에 대해, Bob은 라운드 생성을 알지 못할 것이지만, 이러한 이벤트들은 라운드 r+1 및 그 이후에 유명한 목격자들의 계산에 이용되지 않을 것이기 때문에 중요하지 않을 것이다.

S _r 에서의 각각의 이벤트를 Bob에게 전송하는 것으로서 위에서 설명되었지만, 일부 구현들에서는, 그 둘 다의 부모 이벤트들의 라운드 생성보다 더 큰 라운드 생성을 갖는 S _r 에서의 이러한 이벤트들만이 조인(또는 재연결) 멤버(예를 들어, Bob)에게 서명된 상태와 함께 전송된다. 이것은 다른 이벤트들이 최고 라운드 생성을 갖는 그 부모 이벤트로부터의 라운드 생성을 복사함으로써 Bob에 의해 재계산된 그 라운드 생성을 갖기에 충분한 정보를 제공한다.

일부 구현들에서, 서명된 상태와 함께 전송되는 것으로서 위에서 논의된 S _r 에서의 각각의 이벤트의 해시 값은 이벤트 자체보다는, 서명된 상태와 함께 전송된다. 따라서, 이러한 구현들에서, 그 상태는 해시 값들의 3개의 목록, 즉 그 부모들 둘 다에 대한 라운드 생성보다 더 큰 라운드 생성 및 라운드들 r, r-1 및 r-2에서의 생성을 갖는 S _r 에서의 이벤트들에 대한 해시 값들을 포함하고/하거나 이들과 함께 전송된다. 이러한 구현들에서, 재연결 시에 또는 새로 연결할 때, Bob은 Bob이 그 해시 값들이 서명된 상태에 저장되고/되거나 서명된 상태와 함께 전송되는 이벤트들을 수신할 때까지 다른 멤버들과 동기화할 수 있다. 구체적으로는, Bob은 Bob이 수신하는 각각의 이벤트에 대한 해시 값을 계산하고 그 해시 값을 Bob이 그 상태와 함께 수신한 해시 값들과 비교함으로써 동기화 동안 이러한 이벤트들을 식별할 수 있다. 그 후 Bob은 그 상태에 해시 값을 갖고/갖거나 그 상태와 함께 전송된 하나의 이벤트의 조상 및 그 상태에 해시 값을 갖고/갖거나 그 상태와 함께 전송된 다른 이벤트의 후손 둘 다인 임의의 이벤트에 적절한 라운드 생성을 할당할 수 있다. Bob은 또한 Bob이 부모 이벤트들을 갖지 않는 임의의 다른 이벤트에 미리 결정된 라운드 생성 값(예를 들어, -∞)을 할당할 수 있다. 이 정보에 기반하여, Bob은 DAG를 정의할 수 있고, Bob은 주소록 A _r+1 을 이용하여 전술한 바와 같이 Bob이 수신하는 다른 이벤트들에 대한 라운드 생성 값들을 계산할 수 있다. 그 후 Bob은 추가 라운드들이 컨센서스에 도달함에 따라 그리고 Bob이 다른 멤버들과의 동기화를 통해 추가 이벤트들을 수신함에 따라 정상 참여 멤버로서 그곳으로부터 계속될 수 있다.

도 16은 컴퓨팅 디바이스가 분산 데이터베이스에 연결하고/하거나 분산 데이터베이스에 조인하는 방법(1600)을 예시하는 흐름도이다. 방법(1600)은 컴퓨팅 디바이스의 프로세서에 의해 실행될 수 있다. 방법(1600)은 1602에서 네트워크를 통해, 분산 데이터베이스를 구현하는 컴퓨팅 디바이스들의 세트에 그리고 분산 데이터베이스를 구현하는 노드로서 연결하는 단계를 포함한다. 예를 들어, 컴퓨팅 디바이스는 분산 데이터베이스의 주소록에 추가됨으로써 멤버 및/또는 노드로서 분산 데이터베이스에 조인할 수 있다. 이것은 (본 명세서에 설명된 바와 같이) 분산 데이터베이스의 컨센서스 프로토콜을 이용하여 순서화되는 이벤트 내의 트랜잭션을 이용하여 행해질 수 있다.

1604에서, 컨센서스 프로토콜의 완료된 라운드와 연관된 분산 데이터베이스의 상태가 컴퓨팅 디바이스들의 세트로부터의 컴퓨팅 디바이스로부터 수신된다. 일부 구현들에서, 이 상태는 미리 결정된 수 및/또는 백분율의 현재 멤버들 및/또는 분산 데이터베이스의 지분(예를 들어, 적어도 멤버들의 1/3 및/또는 분산 데이터베이스 내의 총 지분의 1/3)에 의해 디지털 서명될 수 있다. 상태는 (예를 들어, r 또는 그 이전의 수신된 라운드가 실행 및/또는 처리된 이벤트들에 포함된 트랜잭션들을 갖는) 주어진 라운드 r에서와 같은 분산 데이터베이스의 상태일 수 있다. 일부 구현들에서, 상태는 이벤트들의 코어 세트로부터의 각각의 이벤트에 대한 라운드 식별자와 함께 완료된 라운드와 연관된 이벤트들의 코어 세트의 표시(예를 들어, 이벤트들의 코어 세트로부터의 각각의 이벤트의 해시 값)를 포함하거나 그와 함께 전송된다. 일부 구현들에서, 이벤트들의 코어 세트는 완료된 라운드 이전의 미리 결정된 수의 라운드인(예를 들어, 만료되고/되거나 고대인) 세대를 갖는 이벤트들을 포함하지 않는다.

1606에서, 상태와 연관된 이벤트들의 세트가 컴퓨팅 디바이스들의 세트로부터 수신된다. 이벤트들의 세트는 컴퓨팅 디바이스들의 세트로부터의 다른 컴퓨팅 디바이스들과의 동기화에 기반하여 수신될 수 있다.

1608에서, 이벤트들의 코어 세트 및 이벤트들의 코어 세트로부터의 각각의 이벤트에 대한 라운드 식별자에 기반하여 이벤트들의 세트로부터의 각각의 이벤트에 대한 속성들의 세트가 계산된다. 예를 들어, 컨센서스 프로토콜(예를 들어, 라운드 생성, 각각의 라운드에 대한 유명한 목격자들 등)과 관련하여 본 명세서에 설명된 속성들은 이벤트들의 세트로부터의 각각의 이벤트에 대해 계산될 수 있다.

방향성 비순환 그래프(DAG)는 1610에서 이벤트들의 세트 및 이벤트들의 세트에 대한 속성들의 세트에 기반하여 구성되고, 1612에서 컨센서스 프로토콜의 다음 라운드와 연관된 이벤트들의 순서가 DAG를 이용하여 계산된다. 분산 데이터베이스에 연결 및/또는 조인하는 컴퓨팅 디바이스는 앞으로 완전히 기능하는 최신 멤버로서 계속 기능할 수 있다.

일부 경우들에서, 분산 데이터베이스(예컨대, 도 1에 관하여 도시되고 설명된 것)는 암호화폐를 구현하는데 이용될 수 있다. 이러한 경우에, 각각의 분산 데이터베이스 인스턴스(114, 124, 134, 144)는 암호화폐를 저장하기 위해 하나 이상의 지갑 데이터 구조(본 명세서에서 지갑이라고도 지칭됨)를 정의할 수 있다. 일부 경우들에서, 분산 데이터베이스와 연관되지 않은 사용자들(예컨대, 분산 데이터베이스의 멤버들이 아닌 컴퓨팅 디바이스들)도 이러한 지갑들을 생성 및/또는 정의할 수 있다. 지갑 데이터 구조는 키 쌍(공개 키 및 개인 키)을 포함할 수 있다. 일부 경우들에서, 지갑에 대한 키 쌍은 그 지갑이 비롯되는 컴퓨팅 디바이스에 의해 생성될 수 있다. 예를 들어, Alice가 지갑(W, K)을 정의하고, W가 공개 키(지갑에 대한 식별자로서도 역할할 수 있음)이고 K가 개인 키라면, 그녀는 분산 데이터베이스의 나머지 인스턴스들에 (예컨대, 이벤트에서) W를 공개할 수 있지만, 그녀의 아이덴티티를 익명으로 유지할 수 있으므로, 분산 데이터베이스의 다른 인스턴스들(또는 그 사용자들)은 지갑 W가 Alice와 연관되는 것을 식별할 수 없다.

도 7은 일 실시예에 따른, 이벤트들을 동기화하는 2개의 컴퓨팅 디바이스의 신호 흐름도를 예시한다. 구체적으로, 일부 실시예들에서, 분산 데이터베이스 인스턴스들(703 및 803)은 수렴을 획득하기 위해 이벤트들을 교환할 수 있다. 컴퓨팅 디바이스(700)는 컴퓨팅 디바이스(700)와의 관계에 기반하여, 컴퓨팅 디바이스(700)와의 근접성에 기반하여, 컴퓨팅 디바이스(700)와 연관된 순서화된 목록에 기반하여, 등으로 컴퓨팅 디바이스(800)와 랜덤하게 동기화하도록 선택할 수 있다. 일부 실시예들에서, 컴퓨팅 디바이스(800)는 분산 데이터베이스 시스템에 속한 컴퓨팅 디바이스들의 세트로부터 컴퓨팅 디바이스(700)에 의해 선택될 수 있기 때문에, 컴퓨팅 디바이스(700)는 연속하여 여러 번 컴퓨팅 디바이스(800)를 선택할 수 있거나, 한동안 컴퓨팅 디바이스(800)를 선택하지 않을 수 있다. 다른 실시예들에서, 이전에 선택된 컴퓨팅 디바이스들의 표시가 컴퓨팅 디바이스(700)에 저장될 수 있다. 이러한 실시예들에서, 컴퓨팅 디바이스(700)는 컴퓨팅 디바이스(800)를 다시 선택할 수 있기 전에 미리 결정된 수의 선택을 대기할 수 있다. 위에 설명된 바와 같이, 분산 데이터베이스 인스턴스들(703 및 803)은 컴퓨팅 디바이스(700)의 메모리 및 컴퓨팅 디바이스(800)의 메모리에 각각 구현될 수 있다.

일부 구현들에서, 컴퓨팅 디바이스(700)는 동시에 실행되는 다수의 스레드를 가질 수 있고, 각각의 스레드는 다른 멤버와 동기화한다. 따라서, 컴퓨팅 디바이스(700)는 컴퓨팅 디바이스(800)에 추가하여 다른 컴퓨팅 디바이스들(도 7에 도시되지 않음)과 동기화할 수 있다. 일부 경우들에서, 컴퓨팅 디바이스(700)는 초기 또는 처음에 각각의 스레드에 대한 연결들을 확립하고 그 후, 주기적으로 하트비트(heartbeat) 메시지를 전송(예컨대, 초당 2회 하트비트를 전송)함으로써 각각의 연결을 살아 있는 또는 개방 상태로 유지할 수 있다. 따라서, 일부 경우들에서, 컴퓨팅 디바이스(700)는 컴퓨팅 디바이스가 동기화를 위해 다른 멤버 또는 컴퓨팅 디바이스와의 연결을 확립할 때마다 TLS(Transfer Layer Security) 프로토콜들(예컨대, 기록 프로토콜 및 핸드셰이크 프로토콜)에 의해 달리 야기되는 동기화 레이턴시 또는 지연들을 방지할 수 있다. (연결들의 풀로서 포함하는) 다른 멤버들 또는 컴퓨팅 디바이스들과의 연결들을 확립하고 유지하는 것과 관련된 추가 상세들은 2018년 7월 11일자로 미국 특허 출원 제16/032,652호로서 출원되고 발명의 명칭이 "Methods and Apparatus for Efficiently Implementing a Distributed Database within a Network"인 미국 특허 제10,375,037호에서 발견될 수 있으며, 이 특허는 그 전체가 본 명세서에 참조로 포함된다.

도 3 내지 도 6은 일 실시예에 따른 해시그래프의 예들을 예시한다. 5명의 멤버가 있고, 그 각각은 어두운 수직선으로 표현된다. 각각의 원은 이벤트를 나타낸다. 이벤트로부터의 2개의 하향 선은 2개의 이전 이벤트의 해시들을 나타낸다. 이 예의 모든 이벤트는 각각의 멤버의 제1 이벤트를 제외하고 2개의 하향 선(동일한 멤버에 대한 하나의 어두운 선과 다른 멤버에 대한 하나의 밝은 선)을 갖는다. 시간은 위쪽으로 진행된다. 도 3 내지 도 6에서, 분산 데이터베이스의 컴퓨팅 디바이스들은 Alice, Bob, Carol, Dave, 및 Ed로 표시된다. 이러한 표시는 도 1에 관하여 도시되고 설명된 컴퓨팅 디바이스들(110, 120, 130 및 140)과 구조적 및 기능적으로 유사한 컴퓨팅 디바이스들을 지칭하는 것으로 이해되어야 한다. 다음의 단락들은 분산 데이터베이스를 구현하기 위한 예시적인 시스템들을 포함한다. 예들 중 임의의 것이 이하에 열거되거나 본 명세서에 달리 설명된 다른 예들, 디바이스들, 방법들 및/또는 시스템들과 조합될 수 있다는 것이 이해되어야 한다.

예시적인 시스템 1: 컴퓨팅 디바이스(700)가 Alice로 불리고, 컴퓨팅 디바이스(800)가 Bob이라 불리면, 이들 사이의 동기화는 도 7에 예시된 바와 같을 수 있다. Alice와 Bob 사이의 동기화는 예를 들어 다음과 같을 수 있다:

- Alice는 분산 데이터베이스(703)에 저장된 이벤트들을 Bob에게 전송한다.

- Bob은 다음을 포함하는 새로운 이벤트를 생성 및/또는 정의한다:

-- Bob이 생성 및/또는 정의한 마지막 이벤트의 해시

-- Alice가 생성 및/또는 정의한 마지막 이벤트의 해시

-- 위의 Bob에 의한 디지털 서명

- Bob은 분산 데이터베이스(803)에 저장된 이벤트를 Alice에게 전송한다.

- Alice는 새로운 이벤트를 생성 및/또는 정의한다.

- Alice는 그 이벤트를 Bob에게 전송한다.

- Alice는 해시그래프의 함수로서 이벤트들에 대한 전체 순서를 계산한다.

- Bob은 해시그래프의 함수로서 이벤트들에 대한 전체 순서를 계산한다.

임의의 주어진 시간에, 멤버는 지금까지 수신된 이벤트들을, 각각의 이벤트를 생성 및/또는 정의한 분산 데이터베이스 인스턴스 및/또는 컴퓨팅 디바이스와 연관된 식별자와 함께 저장할 수 있다. 초기 이벤트(부모 해시가 없음)와 각각의 새로운 멤버에 대한 제1 이벤트(이들을 조인하도록 초대한 기존 멤버의 이벤트를 나타내는 단일의 부모 이벤트 해시를 가짐)를 제외하고, 각각의 이벤트는 2개의 이전 이벤트의 해시들을 포함한다. 이 이벤트들의 세트를 나타내는 다이어그램이 그려질 수 있다. 이것은 각각의 멤버에 대한 수직선과, 그 멤버에 의해 생성 및/또는 정의된 각각의 이벤트에 대한 그 선 상의 점 또는 원을 나타낼 수 있다. 이벤트(상위 점)가 이전 이벤트(하위 점)의 해시를 포함할 때마다 2개의 점 사이에 대각선이 그려진다. 이벤트는 그 이벤트의 해시를 통해 그 이벤트가 다른 이벤트를 참조할 수 있는 경우(직접 또는 중개 이벤트들을 통해) 다른 이벤트에 링크되어 있다고 말할 수 있다.

예를 들어, 도 3은 해시그래프(600)의 예를 예시한다. 이벤트(602)는 Carol과 동기화 후에 그 결과로서 Bob에 의해 생성 및/또는 정의된다. 이벤트(602)는 이벤트(604)(Bob에 의해 생성 및/또는 정의된 이전 이벤트)의 해시 및 이벤트(606)(Carol에 의해 생성 및/또는 정의된 이전 이벤트)의 해시를 포함한다. 일부 실시예들에서, 예를 들어, 이벤트(602) 내에 포함된 이벤트(604)의 해시는 그 직계 조상 이벤트들인 이벤트들(608 및 610)에 대한 포인터를 포함한다. 그에 따라, Bob은 이벤트(602)를 이용하여 이벤트들(608 및 610)을 참조하고 이전 이벤트들에 대한 포인터를 이용하여 해시그래프를 재구성할 수 있다. 일부 경우들에서, 이벤트(602)는 이전 조상 이벤트들을 통해 해시그래프(600) 내의 이벤트들 각각을 참조할 수 있으므로 이벤트(602)는 해시그래프(600) 내의 다른 이벤트들에 링크되어 있다고 말할 수 있다. 예를 들어, 이벤트(602)는 이벤트(604)를 통해 이벤트(608)에 링크된다. 다른 예로서, 이벤트(602)는 이벤트(606) 및 이벤트(612)를 통해 이벤트(616)에 링크된다.

예시적인 시스템 2: 예시적인 시스템 1(또는 본 명세서에 개시된 임의의 다른 예시적인 시스템)로부터의 시스템으로서, 여기서 이벤트는 또한 트랜잭션들의 "페이로드" 또는 기록할 다른 정보를 포함한다. 이러한 페이로드는 컴퓨팅 디바이스의 바로 이전 이벤트 이후에 발생 및/또는 정의된 임의의 트랜잭션들 및/또는 정보로 이벤트들을 업데이트하는데 이용될 수 있다. 예를 들어, 이벤트(602)는 이벤트(604)가 생성 및/또는 정의된 이후 Bob에 의해 수행되는 임의의 트랜잭션들을 포함할 수 있다. 따라서, 이벤트(602)를 다른 컴퓨팅 디바이스들과 동기화할 때, Bob은 이 정보를 공유할 수 있다. 따라서, Bob에 의해 수행된 트랜잭션들은 이벤트와 연관되고 이벤트들을 이용하는 다른 멤버들과 공유될 수 있다. 일부 구현들에서, 예시적인 시스템 2는 또한 예시적인 시스템 2를 구체적으로 참조하지 않을 수 있는 본 명세서에 개시된 다른 예시적인 시스템들에 적용될 수 있다.

예시적인 시스템 3: 예시적인 시스템 1(또는 본 명세서에 개시된 임의의 다른 예시적인 시스템)로부터의 시스템으로서, 여기서 이벤트는 또한 디버깅, 진단 및/또는 다른 목적에 유용한 현재 시간 및/또는 날짜를 포함한다. 시간 및/또는 날짜는 컴퓨팅 디바이스(예컨대, Bob)가 이벤트를 생성 및/또는 정의하는 로컬 시간 및/또는 날짜일 수 있다. 이러한 실시예들에서, 이러한 로컬 시간 및/또는 날짜는 나머지 디바이스들과 동기화되지 않는다. 다른 실시예들에서, 시간 및/또는 날짜는 디바이스들에 걸쳐 동기화될 수 있다(예컨대, 이벤트들을 교환할 때). 또 다른 실시예들에서, 글로벌 타이머가 시간 및/또는 날짜를 결정하는데 이용될 수 있다.

예시적인 시스템 4: 예시적인 시스템 1(또는 본 명세서에 개시된 임의의 다른 예시적인 시스템)로부터의 시스템으로서, 여기서 Alice는 Bob에 의해 생성 및/또는 정의된 이벤트들, 또는 이러한 이벤트의 조상 이벤트들 중 어느 것도 Bob에게 전송하지 않는다. y가 x의 해시를 포함하거나, y가 x의 후손인 이벤트의 해시를 포함하면 이벤트 x는 이벤트 y의 조상이다. 유사하게 말해서, 이러한 실시예들에서, Bob은 Alice에 의해 아직 저장되지 않은 이벤트들을 Alice에게 전송하고, Alice에 의해 이미 저장된 이벤트들은 전송하지 않는다.

예를 들어, 도 4는 이벤트(622)(검은 원)의 조상 이벤트들(점표시 원들) 및 후손 이벤트들(줄무늬 원들)을 예시하는 예시적인 해시그래프(620)를 예시한다. 이 선들은 이벤트에 대한 부분 순서를 확립하고, 여기서 조상들은 검은 이벤트 전에 오고, 후손들은 검은 이벤트 후에 온다. 부분 순서는 흰색 이벤트들이 검은 이벤트들의 전인지 또는 후인지를 나타내지 않으므로, 전체 또는 컨센서스 순서가 그 시퀀스를 결정하는데 이용된다. 다른 예로서, 도 5는 하나의 특정 이벤트(중실 원) 및 각각의 멤버가 그 이벤트(줄무늬 원들)의 표시를 수신하는 제1 시간을 예시하는 예시적인 해시그래프를 예시한다. Carol이 Dave와 동기화하여 이벤트(624)를 생성 및/또는 정의할 때, Dave는 이벤트(622)의 조상 이벤트들을 Carol에게 전송하지 않는데 그 이유는 Carol이 이미 이러한 이벤트들을 인식하고 수신했기 때문이다. 대신, Dave는 Carol이 아직 수신하고/하거나 Carol의 분산 데이터베이스 인스턴스에서 저장하지 않은 이벤트들을 Carol에게 전송한다. 일부 실시예들에서, Dave는 Carol이 이전에 수신한 이벤트들에 관해 Dave의 해시그래프가 드러내는 것에 기반하여 Carol에게 전송할 이벤트들을 식별할 수 있다. 이벤트(622)는 이벤트(626)의 조상이다. 따라서, 이벤트(626)의 시점에, Dave는 이미 이벤트(622)를 수신했다. 도 4는 Dave가 Carol로부터 이벤트(622)를 수신한 Bob으로부터 이벤트(622)를 수신한 Ed로부터 이벤트(622)를 수신한 것을 나타낸다. 또한, 이벤트(624)의 시점에, 이벤트(622)는 Carol에 의해 생성 및/또는 정의된 Dave가 수신한 마지막 이벤트이다. 따라서, Dave는 이벤트(622) 및 그 조상들 이외에 Dave가 저장한 이벤트들을 Carol에게 전송할 수 있다. 추가적으로, Dave로부터 이벤트(626)를 수신하면, Carol은 Carol의 분산 데이터베이스 인스턴스에 저장된 이벤트들 내의 포인터들에 기반하여 해시그래프를 재구성할 수 있다. 다른 실시예들에서, Dave는, Carol이 Dave에게 이벤트(622)를 전송하고(도 4에 도시되지 않음) Dave가 이벤트(622)(및 그 내부의 참조들)를 이용하여 식별함으로써 Carol이 이미 수신한 이벤트들을 식별하는 것에 기반하여 Carol에게 어느 이벤트들을 전송할지를 식별할 수 있다. 해시그래프를 재구성함으로써, Carol은 컨센서스 프로토콜의 각각의 라운드에 대해 Dave로부터 실제로 투표들을 수신하지 않고 전술한 컨센서스 프로토콜들에서 Dave가 어떻게 투표할지를 결정할 수 있다. 유사하게, Carol의 해시그래프에 기반하여, Carol은 그 투표들을 구체적으로 수신하지 않고 분산 데이터베이스의 각각의 나머지 멤버가 어떻게 투표할지를 결정할 수 있다. 이것은 컨센서스 프로토콜의 각각의 라운드에 대한 투표들이 분산 데이터베이스의 멤버들 사이에서 교환되지 않기 때문에 네트워크 트래픽을 감소시킨다.

예시적인 시스템 5: 예시적인 시스템 1(또는 본 명세서에 개시된 임의의 다른 예시적인 시스템)로부터의 시스템으로서, 여기서 수신자가 그 이벤트의 조상들을 수신 및/또는 저장한 후까지 이벤트가 전송되지 않도록 하는 순서로 양쪽 멤버들이 다른 멤버에게 이벤트를 전송한다. 따라서, 전송자는 가장 오래된 것부터 가장 새로운 것까지 이벤트들을 전송하고, 따라서 수신자는, 2개의 해시를 이미 수신된 2개의 조상 이벤트와 비교함으로써, 이벤트가 수신될 때 각각의 이벤트에 대한 2개의 해시를 체크할 수 있다. 전송자는 전송자의 해시그래프의 현재 상태(예컨대, 전송자에 의해 정의된 데이터베이스 상태 변수) 및 수신자가 이미 수신한 그 해시그래프가 표시하는 것에 기반하여 수신자에 전송할 이벤트들을 식별할 수 있다. 도 3을 참조하면, 예를 들어, Bob이 이벤트(602)를 정의하기 위해 Carol과 동기화하는 경우, Carol은 이벤트(619)가 Carol이 수신한 Bob에 의해 생성 및/또는 정의된 마지막 이벤트임을 식별할 수 있다. 따라서 Carol은 Bob이 그 이벤트, 및 그 조상들을 알고 있다고 결정할 수 있다. 따라서, Carol은 Bob에게 이벤트(618) 및 이벤트(616)를 먼저 전송할 수 있다(즉, Carol이 수신한 Bob이 아직 수신하지 못한 가장 오래된 이벤트). 그 후 Carol은 Bob에게 이벤트(612)를 전송하고 그 후 이벤트(606)를 전송할 수 있다. 이는 Bob이 이벤트들을 용이하게 링크하고 Bob의 해시그래프를 재구성할 수 있게 한다. Carol의 해시그래프를 이용하여 Bob이 아직 수신하지 못한 이벤트들을 식별하는 것은 Bob이 Carol에게 이벤트들을 요청하지 않으므로 동기화의 효율을 증가시킬 수 있고 네트워크 트래픽을 감소시킬 수 있다.

다른 실시예들에서, 가장 최근의 이벤트가 먼저 전송될 수 있다. 수신자가 2개의 이전 이벤트 중 하나를 아직 수신하지 못했다고(가장 최근 이벤트에서의 2개의 이전 이벤트의 해시 및/또는 가장 최근 이벤트에서의 이전 이벤트들에 대한 포인터들에 기반하여) 결정하는 경우, 수신자는 전송자에게 이러한 이벤트들을 전송하도록 요청할 수 있다. 이는 수신자가 가장 최근 이벤트들의 조상들을 수신 및/또는 저장할 때까지 발생할 수 있다. 도 3을 참조하면, 이러한 실시예들에서, 예를 들어, Bob이 Carol로부터 이벤트(606)를 수신할 때, Bob은 이벤트(606)에서 이벤트(614) 및 이벤트(612)의 해시를 식별할 수 있다. Bob은 이벤트(604)를 생성 및/또는 정의할 때 이벤트(614)가 Alice로부터 이전에 수신되었다고 결정할 수 있다. 따라서, Bob은 Carol에게 이벤트(614)를 요청할 필요가 없다. Bob은 또한 이벤트(612)가 아직 수신되지 않았다고 결정할 수 있다. 그 후 Bob은 Carol에게 이벤트(612)를 요청할 수 있다. 그 후 Bob은 이벤트(612) 내의 해시들에 기반하여, Bob이 이벤트들(616 또는 618)을 수신하지 못했다고 결정할 수 있고 따라서 Carol에게 이 이벤트들을 요청할 수 있다. 이벤트들(616 및 618)에 기반하여, Bob은 그 후 그가 이벤트(606)의 조상들을 수신했다고 결정할 수 있다.

예시적인 시스템 6: 예시적인 시스템 5(또는 본 명세서에 개시된 임의의 다른 예시적인 시스템)로부터의 시스템으로서, 멤버가 다음에 전송할 여러 이벤트들 사이에서 선택할 때, 이벤트는 그 멤버에 의해 생성 및/또는 정의된 지금까지 전송된 총 바이트 수를 최소화하도록 선택된다고 하는 추가적인 제약을 갖는다. 예를 들어, Alice가 Bob에게 전송할 이벤트가 2개만 남아 있고, 하나는 100 바이트이고 Carol에 의해 생성 및/또는 정의되었고, 하나는 10 바이트이고 Dave에 의해 생성 및/또는 정의되었고, 지금까지 이 동기화에서 Alice가 Carol에 의한 이벤트 중 200 바이트, 그리고, Dave에 의한 210 바이트를 이미 전송했다면, Alice는 Dave 이벤트를 먼저 전송하고, 그 후 후속하여 Carol 이벤트를 전송해야 한다. 이는 210 + 10 < 100 + 200이기 때문이다. 이는 단일 멤버가 단일의 거대한 이벤트, 또는 작은 이벤트들의 플러드(flood)를 송출하는 공격들을 어드레싱하는데 이용될 수 있다. 트래픽이 (예시적인 시스템 7에 관하여 논의된 바와 같이) 대부분의 멤버들의 바이트 제한을 초과하는 경우, 예시적인 시스템 6의 방법은 합법적인 사용자들의 이벤트들이 아니라 공격자의 이벤트들이 무시되는 것을 보장할 수 있다. 유사하게 말해서, (연결을 묶어놓는 하나의 거대한 이벤트에 대항하여 방어하기 위해) 더 큰 이벤트들 전에 더 작은 이벤트들을 전송함으로써 공격이 감소될 수 있다. 또한, 멤버가 (예컨대, 네트워크 제한, 멤버 바이트 제한 등으로 인해) 단일 동기화에서 이벤트들 각각을 전송할 수 없다면, 그 멤버는, 공격자에 의해 정의 및/또는 생성된 이벤트들만을 전송하고 다른 멤버들에 의해 생성 및/또는 정의된 이벤트들은 아무 것도 전송하지 않는(또는 소수 전송하는) 것이 아니라, 각각의 멤버로부터의 소수의 이벤트를 전송할 수 있다.

예시적인 시스템 7: 예시적인 시스템 1(또는 본 명세서에 개시된 임의의 다른 예시적인 시스템)로부터의 시스템으로서, Bob이 그가 이 동기화 동안에 수신하고자 하는 최대 바이트 수를 표시하는 수를 Alice에게 전송하고, Alice가 그녀의 제한으로 응답하는 추가적 제1 단계를 갖는다. 그 후 Alice는 다음 이벤트가 이 제한을 초과할 때 전송을 중단한다. Bob도 동일한 것을 행한다. 이러한 실시예에서, 이는 전송되는 바이트 수를 제한한다. 이는 수렴 시간까지의 시간을 증가시킬 수 있지만, 동기화당 네트워크 트래픽의 양을 감소시킬 것이다.

대안적으로 또는 추가적으로, 일부 구현들에서, 동기화 프로세스마다 동기화되도록 허용되는 이벤트들의 수 및/또는 동기화 프로세스마다의 바이트 수의 제한이 분산 데이터베이스에서 구현된다. 예를 들어, Alice는 Bob에 의해 아직 알려지지 않은 이벤트들을 Bob에게 전송할 수 있고, 그 후 Alice와 연관된 데이터베이스의 인스턴스는 다음 이벤트가 허용가능한 바이트 수(즉, 동기화된 데이터의 양) 또는 동기화될 허용된 이벤트들의 허용가능한 수에 기반하여 동기화 임계치 값을 초과하고/하거나 그에 도달할 때 데이터 패킷들 및/또는 이벤트들의 전송을 중단 및/또는 종료할 수 있다. 이러한 경우들에서 이벤트들의 전송은 양쪽 이벤트가 동기화되고 있는 경우 이벤트들을 전송하기 전에 이벤트의 부모를 전송함으로써 수행될 수 있다.

일부 경우들에서, Alice가 Bob과 동기화하고 있고, 그녀가 2개의 이벤트, 예를 들어, 이벤트 X 및 이벤트 Y를 그에게 전송할 필요가 있고, Bob이 그 이벤트들 둘 다의 모든 부모들을 이미 가지고 있는 경우에는, Alice는 어느 것을 먼저 전송할지를 선택할 수 있다. 일부 구현들에서, Alice는 이 동기화 동안에 그녀가 이미 전송한 X의 생성자에 의한 모든 이벤트들에서의 바이트들 더하기 X에서의 모든 바이트들의 총 바이트들(Bx)을 계산할 수 있다. 유사하게, 그녀는 지금까지 전송된 Y의 생성자에 의한 이벤트들 및 Y에서의 바이트들에 대한 총 바이트들(By)을 계산할 수 있다. 그 후 그녀는 Bx<By이면 Y 전에 X를 전송하고, By<Bx이면 X 전에 Y를 전송하고, Bx=By이면 그것들을 어느 순서로든 전송하기로 선택할 수 있다.

일부 경우들에서, 2명의 멤버 사이의 동기화는 (예컨대, 서비스 부인 공격들을 방지하기 위해) 동기화마다 수신된 이벤트들의 최대 수로 제한될 수 있다. 그 동기화와 관련된 모든 이벤트들이 수신되기 전에 이러한 제한에 도달하면, 동기화가 조기에 종료된다. 일부 다른 경우들에서, 각각의 동기화 이벤트는 (수신된 이벤트들의 수로 제한되는 것 대신에 또는 그에 추가하여) 수신된 바이트들의 최대 수로 제한될 수 있다. 따라서, 동기화 동안 다른 멤버(예컨대, Alice)로부터 수신자 멤버(예컨대, Bob)에 의해 수신 및/또는 수락되는 이벤트들 및/또는 바이트들의 수를 제약하거나 규제하기 위해 수신된 이벤트들의 최대 수 및 수신된 바이트들의 최대 수와 같은 제한들이 이용될 수 있다. 앞서 언급된 제한들은 악의적인 멤버가 큰 이벤트를 생성하거나, 엄청난 수의 작은 이벤트들로 네트워크를 플러딩하는 공격들을 방지할 수 있다. 이들 제한은 또한, 예를 들어, 하나의 멤버가 데이터 트래픽의 급증이 아니라 데이터 트래픽의 평균 양을 핸들링하기 위한 저-대역폭 연결을 갖는 경우에 우아한 성능저하(graceful degradation)를 보장한다.

일부 구현들에서, 멤버들 또는 컴퓨팅 디바이스들은 컨센서스가 아직 식별되지 않은 알려진 이벤트들 모두가 어떤 트랜잭션도 포함하지 않는 빈 이벤트들이라면 다른 멤버 또는 컴퓨팅 디바이스와의 동기화를 개시하지 않는다. 이는 새로운 트랜잭션이 없는 긴 기간이 있다면 멤버들이 대역폭을 낭비하지 않을 것임을 보장한다.

일부 경우들에서, 컨센서스의 결핍은 멤버의 또는 컴퓨팅 디바이스 메모리의 오버플로우를 야기할 수 있다. 예를 들어, 컨센서스가 아직 식별되지 않은 이벤트들의 세트는, 예를 들어, 모집단의 적어도 1/3이 오프라인일 때, 주어진 임계치를 지나 증가 또는 증대할 수 있는데, 그 이유는 너무 적은 수의 멤버들이 온라인일 때 컨센서스가 도출되지 않을 수 있기 때문이다. 따라서, 멤버의 또는 컴퓨팅 디바이스의 메모리는 컨센서스에 도달할 수 없는 이벤트들의 누적 수로 오버플로우할 수 있다. 컨센서스가 달성될 수 없는 누적된 이벤트들로 인한 메모리 오버플로우를 방지하기 위해, 각각의 멤버 및/또는 컴퓨팅 디바이스는 컨센서스가 아직 달성되지 않은 이벤트들의 임계치에 도달되면, 그 멤버 또는 컴퓨팅 디바이스가 그 멤버 또는 컴퓨팅 디바이스가 그 멤버 또는 컴퓨팅 디바이스가 인식하는 이벤트들 중 일부에 대한 컨센서스에 도달할 때까지 임의의 새로운 이벤트들을 정의 및/또는 생성하기를 거절할 수 있도록 구성될 수 있다. 다르게 말해서, 일부 경우들에서 컨센서스의 결핍은 컨센서스를 달성할 수 없다면(예컨대, 너무 적은 수의 멤버들이 온라인이고 컨센서스를 도출할 수 있을 때) 오버플로우를 야기할 수 있다. 따라서, (예컨대, 너무 적은 수의 멤버들이 온라인이기 때문에) 컨센서스 순서에 넣어질 수 없는 이벤트들의 오버플로우를 방지하기 위해, 멤버는 더 오래된 이벤트들 중 일부에 대한 컨센서스에 도달하기 위해 오프라인 멤버들 중 일부로부터 이벤트들을 수신할 수 있을 때까지 어떤 추가 이벤트들도 정의하지 않는다.

예시적인 시스템 8: 예시적인 시스템 1(또는 본 명세서에 개시된 임의의 다른 예시적인 시스템)로부터의 시스템으로서, 동기화 프로세스를 시작할 때 다음의 단계들이 추가된다:

- Alice는 Bob에 의해 생성 및/또는 정의된 또는 Bob에 의해 생성 및/또는 정의된 이벤트들의 조상들인 이벤트들을 건너 뛰고, 그녀가 수신 및/또는 저장한 이벤트들의 세트 S를 식별한다.

- Alice는 S에서 각각의 이벤트를 생성 및/또는 정의한 멤버들을 식별하고, 그 멤버들의 ID 번호들의 목록을 Bob에게 전송한다. Alice는 또한 그녀가 이미 수신 및/또는 저장한 각각의 멤버들에 의해 생성 및/또는 정의된 이벤트들의 수를 전송한다.

- Bob은 다른 멤버들에 의해 생성 및/또는 정의된 얼마나 많은 이벤트를 그가 수신하였는지의 목록으로 응답한다.

- 그 후 Alice는 Bob에게 그가 아직 수신하지 않은 이벤트들만을 전송한다. 예를 들어 Alice가 Bob에게 그녀가 Carol에 의해 생성 및/또는 정의된 100개의 이벤트를 수신했음을 표시하고, Bob이 Carol에 의해 생성 및/또는 정의된 95개의 이벤트를 수신했다고 응답하면, Alice는 Carol에 의해 생성 및/또는 정의된 가장 최근의 5개의 이벤트만 전송할 것이다.

예시적인 시스템 9: 예시적인 시스템 1(또는 본 명세서에 개시된 임의의 다른 예시적인 시스템)로부터의 시스템으로서, 치터(cheater)들을 식별 및/또는 핸들링하기 위한 추가적인 메커니즘을 갖는다. 각각의 이벤트는 2개의 해시를 포함하는데, 하나는 그 멤버에 의해 생성 및/또는 정의된 마지막 이벤트로부터의 것이고("자기 해시")이고, 하나는 다른 멤버에 의해 생성 및/또는 정의된 마지막 이벤트로부터의 것("외부 해시")이다. 멤버가 동일한 자기 해시를 가진 2개의 상이한 이벤트를 생성 및/또는 정의하면, 그 멤버는 "치터"이다. Alice가 동일한 자기 해시를 갖는 Dave에 의해 생성 및/또는 정의된 2개의 상이한 이벤트를 수신함으로써, 그가 치터라는 것을 발견하면, 그녀는 그가 치터라는 표시자를 저장하고 미래에 그와 동기화하는 것을 삼간다. 그녀가 그가 치터라는 것을 발견하지만, 여전히 그와 다시 동기화하고, 그 사실을 기록 하는 새로운 이벤트를 생성 및/또는 정의한다면, Alice도 치터가 되고, Alice가 Dave와 추가로 동기화하는 것에 대해 알게 되는 다른 멤버들은 Alice와의 동기화를 중단한다. 일부 실시예들에서, 이는 단지 한 가지 방식으로 동기화에 영향을 미친다. 예를 들어, Alice가 식별자들의 목록과 각각의 멤버에 대해 그녀가 수신한 이벤트들의 수를 전송할 때, 그녀는 치터에 대한 ID 또는 카운트를 전송하지 않으므로, Bob은 어떤 대응 번호로도 응답하지 않는다. 그 후, Alice는 Bob에게 그녀가 수신한 치터의 이벤트들로서 그녀가 Bob이 이러한 이벤트들을 수신했다는 표시를 수신하지 않은 이벤트들을 전송한다. 동기화가 끝난 후에, Bob 또한 Dave가 치터라고 결정할 수 있고(그가 Dave를 치터로 아직 식별하지 않은 경우), Bob 또한 그 치터와의 동기화를 거절할 것이다.

예시적인 시스템 10: 예시적인 시스템 9(또는 본 명세서에 개시된 임의의 다른 예시적인 시스템)에서의 시스템으로서, Alice가 그녀가 식별한 치터들의 그리고 그녀가 여전히 저장하고 있는 그 이벤트들의 목록을 Bob에게 전송함으로써 동기화 프로세스를 시작하고, Bob은 Alice가 식별한 치터들에 추가하여 그가 식별한 임의의 치터들로 응답하는 추가 구성을 갖는다. 그 후 이들은 정상적으로 계속되지만, 서로 동기화할 때 치터들에 대한 카운트들은 제공하지 않는다.

예시적인 시스템 11: 예시적인 시스템 1(또는 본 명세서에 개시된 임의의 다른 예시적인 시스템)에서의 시스템으로서, 동기화 동안 수신되는 임의의 새로운 이벤트들 내부의 트랜잭션들에 기반하여 현재 상태(예컨대, 시스템의 멤버에 의해 정의된 데이터베이스 상태 변수에 의해 캡처된)를 반복적으로 업데이트하는 프로세스를 갖는다. 이는 또한 이벤트들의 시퀀스가 변경될 때마다, 이전 상태의 사본으로 돌아가서 새로운 순서로 이벤트들을 처리하여 현재 상태를 재계산함으로써, 그 상태(예컨대, 이벤트들의 순서)를 반복적으로 재구축하는 제2 프로세스를 포함할 수 있다. 따라서, 예를 들어, 각각의 컴퓨팅 디바이스는 상태의 2개의 버전을 유지할 수 있다(하나는 (부분 순서에 기반하여) 새로운 이벤트들 및 트랜잭션들이 수신됨에 따라 업데이트되고, 하나는 (전체 또는 컨센서스 순서에 기반하여) 컨센서스가 달성된 후에만 업데이트된다). 어떤 시점에(예컨대, 일정 기간 후, 주어진 수의 이벤트들이 정의 및/또는 수신된 후, 등), 새로운 이벤트들 및 트랜잭션들이 수신됨에 따라 업데이트되는 상태의 버전이 폐기될 수 있고, 컨센서스가 달성된 후에만 업데이트되는 상태의 새로운 사본이 새로운 이벤트들 및 트랜잭션들이 수신됨에 따라 업데이트되는 상태의 새로운 버전으로서 만들어질 수 있다. 이는 양쪽 상태들의 동기화를 보장할 수 있다.

일부 실시예들에서, 현재 상태는 트랜잭션들의 결과와 연관된 상태, 잔고, 조건 등이다. 유사하게 말해서, 상태는 트랜잭션들에 의해 수정된 데이터 구조 및/또는 변수들을 포함할 수 있다. 예를 들어, 트랜잭션들이 은행 계좌들 사이의 금전 이체이면, 현재 상태는 계좌의 현재 잔고일 수 있다. 다른 예로서, 트랜잭션들이 멀티플레이어 게임과 연관되면, 현재 상태는 게임과 연관된 위치, 생존의 수, 획득된 아이템, 게임의 상태 등일 수 있다.

예시적인 시스템 12: 예시적인 시스템 11(또는 본 명세서에 개시된 임의의 다른 예시적인 시스템)에서의 시스템으로서, 상태(예컨대, 은행 계좌 잔고, 게임 상태 등)를 유지하기 위해 "고속 복제(fast clone)" arrayList의 이용에 의해 더 빨라진다. 고속 복제 arrayList는 하나의 추가적인 특징을 갖는 어레이처럼 작용하는 데이터 구조이다: 이는 원본의 사본인 새로운 객체를 생성 및/또는 정의하는 것처럼 보이는 "복제" 연산을 지원한다. 복제본은 마치 실제 사본인 것처럼 작용하는데, 그 이유는 복제본에 대한 변경이 원본에 영향을 미치지 않기 때문이다. 그러나, 복제 연산은 실제 사본을 생성하는 것보다 빠른데, 그 이유는 복제본을 생성하는 것은 실제로는 하나의 arrayList의 전체 내용을 다른 것으로 복사 및/또는 업데이트하는 것을 수반하지 않기 때문이다. 원본 목록의 2개의 복제본 및/또는 사본을 갖는 대신, 해시 테이블과 원본 목록에 대한 포인터를 각각 갖는 2개의 작은 객체가 이용될 수 있다. 복제본에 대해 기입이 행해질 때, 해시 테이블은 어느 요소가 수정되었는지와 새로운 값을 기억한다. 위치에 대해 판독이 수행될 때, 해시 테이블이 먼저 체크되고, 그 요소가 수정되면, 해시 테이블로부터의 새로운 값이 반환된다. 그렇지 않으면, 원본 arrayList로부터의 그 요소가 반환된다. 이러한 방식으로, 2개의 "복제본"은 처음에는 원본 arrayList에 대한 포인터들일 뿐이다. 그러나 각각이 반복적으로 수정됨에 따라, 이것은 원본 목록과 그 자체 사이의 차이점들을 저장하는 큰 해시 테이블을 갖도록 성장한다. 복제본들 자체가 복제되어, 데이터 구조가 객체들의 트리로 확장되게 할 수 있고, 각각의 객체는 그 자신의 해시 테이블 및 그 부모에 대한 포인터를 갖는다. 따라서 판독은 요청된 데이터를 갖는 정점(vertex)이 발견되거나 루트에 도달할 때까지 트리를 따라 걷기를 야기한다. 정점이 너무 커지거나 복잡해지면, 이것은 부모의 실제 사본으로 대체될 수 있고, 사본에 대해 해시 테이블에서의 변경들이 행해질 수 있고, 해시 테이블은 폐기된다. 또한, 복제본이 더 이상 필요하지 않으면, 가비지 수집 동안에 이것은 트리로부터 제거될 수 있고, 트리는 축소될 수 있다.

예시적인 시스템 13: 예시적인 시스템 11(또는 본 명세서에 개시된 임의의 다른 예시적인 시스템)에서의 시스템으로서, 상태(예컨대, 은행 계좌 잔고, 게임 상태 등)를 유지하기 위해 "고속 복제" 해시 테이블의 이용에 의해 더 빨라진다. 이는 트리의 루트가 arrayList가 아니라 해시 테이블이라는 점을 제외하고는 시스템 12와 동일하다.

예시적인 시스템 14: 예시적인 시스템 11(또는 본 명세서에 개시된 임의의 다른 예시적인 시스템)에서의 시스템으로서, 상태(예컨대, 은행 계좌 잔고, 게임 상태 등)를 유지하기 위해 "고속 복제" 관계형 데이터베이스의 이용에 의해 더 빨라진다. 예를 들어, 예시적인 시스템 11에 관하여 논의된 바와 같이, 고속 복제 데이터베이스는 상태의 2개의 사본을 유지하는데 이용될 수 있다. 이는 기존 관계형 데이터베이스 관리 시스템(RDBMS)을 둘러싼 래퍼로서 작용하는 객체이다. 각각의 명백한 "복제본"은 실제로는 데이터베이스를 포함하는 객체에 대한 포인터 및 ID 번호를 갖는 객체이다. 사용자의 코드가 데이터베이스에 대해 SQL(Structure Query Language) 질의를 수행하려고 시도할 때, 그 질의는 먼저 수정된 다음 실제 데이터베이스로 전송된다. 각각의 테이블이 복제본 ID에 대해 하나의 추가적인 필드를 갖는 것을 제외하면, 실제 데이터베이스는 클라이언트 코드에서 볼 수 있는 데이터베이스와 동일하다. 예를 들어, 복제본 ID 1을 갖는 원본 데이터베이스가 존재하고, 그 후 데이터베이스의 2개의 복제본이 만들어지고, ID 2 및 ID 3(예컨대, 상태의 2개 사본을 유지하는데 이용됨)을 갖는다고 가정하자. 각각의 테이블 내의 각각의 행은 복제본 ID 필드에 1, 2, 또는 3을 가질 것이다. 질의가 사용자 코드로부터 복제본 2 내로 올 때, 그 필드에 2 또는 1이 있는 행들로부터만 질의가 판독되도록 질의가 수정된다. 유사하게, 3에 대한 판독은 3 또는 1 ID를 갖는 행들을 찾는다. SQL(Structured Query Language) 커맨드가 복제본 2로 진행하고 행을 삭제한다고 하고, 그 행에 1이 있으면, 커맨드는 단지 1을 3으로 변경해야 하고, 이는 행을 더 이상 복제본 2 및 3에 의해 공유되지 않고 이제는 단지 3에만 가시적인 것으로 마킹한다. 동작 중인 여러 복제본들이 있으면, 행의 여러 사본들이 삽입될 수 있고, 각각은 상이한 복제본의 ID로 변경될 수 있고, 따라서 새로운 행들은 그 행을 막 "삭제한" 복제본을 제외한 복제본들에 대해 가시적이다. 유사하게, 행이 복제본 2에 추가되면, 행은 2의 ID를 갖는 테이블에 추가된다. 행의 수정은 삭제 후 삽입과 동등하다. 이전처럼, 여러 클론들이 가비지 수집되면, 트리는 단순화될 수 있다. 그 트리의 구조는 복제본들에게 액세스가능하지 않고, 순전히 내부적으로 이용되는 추가적인 테이블에 저장될 것이다.

예시적인 시스템 15: 예시적인 시스템 11(또는 본 명세서에 개시된 임의의 다른 예시적인 시스템)에서의 시스템으로서, 상태를 유지하기 위해 "고속 복제" 파일 시스템의 이용에 의해 더 빨라진다. 이는 파일 시스템을 둘러싼 래퍼로서 작용하는 객체이다. 파일 시스템은 파일 시스템의 상이한 버전들을 관리하기 위해 고속 복제 관계형 데이터베이스를 이용하여, 기존 파일 시스템의 위에 구축된다. 하부의 파일 시스템은 다수의 파일을 하나의 디렉토리에 또는 (디렉토리들을 작게 유지하기 위해) 파일 이름에 따라 분할하여 저장한다. 디렉토리 트리는 데이터베이스에 저장될 수 있고, 호스트 파일 시스템에 제공되지 않는다. 파일이나 디렉토리가 복제될 때, "복제본"은 ID 번호를 갖는 객체일 뿐이고, 데이터베이스는 이 복제본이 이제 존재함을 반영하도록 수정된다. 고속 복제 파일 시스템이 복제되면, 이것은 사용자에게 마치 기존 하드 드라이브의 사본으로 초기화된 새로운 하드 드라이브 전체가 생성 및/또는 정의된 것처럼 보인다. 하나의 사본에 대한 변경들은 다른 사본들에는 영향을 미치지 않을 수 있다. 실제로는, 각각의 파일 또는 디렉토리의 단 하나의 사본만 있고, 파일이 하나의 복제본을 통해 수정될 때 복사가 발생한다.

예시적인 시스템 16: 예시적인 시스템 15(또는 본 명세서에 개시된 임의의 다른 예시적인 시스템)에서의 시스템으로서, 고속 복제 파일 시스템에서 파일의 각각의 N 바이트 부분에 대해 호스트 운영 체제 상에 별개의 파일이 생성 및/또는 정의된다. N은 예를 들어 4096 또는 1024와 같은 일부 적합한 크기일 수 있다. 이러한 방식으로, 큰 파일에서 하나의 바이트가 변경되면, 큰 파일의 하나의 청크만이 복사되고 수정된다. 이는 또한 단지 소수의 바이트들이 상이한 많은 파일들을 드라이브 상에 저장할 때 효율을 증가시킨다.

예시적인 시스템 17: 예시적인 시스템 11(또는 본 명세서에 개시된 임의의 다른 예시적인 시스템)에서의 시스템으로서, 각각의 멤버는 그들이 생성 및/또는 정의하는 이벤트들의 일부 또는 전부에 그 시점까지 발생한 이벤트들의 수와 함께 일부 이전 시간에서의 상태의 해시를 포함하여, 멤버가 이제 이벤트들의 순서에 대한 컨센서스가 존재함을 인식 및/또는 식별하는 것을 표시한다. 멤버가 주어진 상태에 대해 다수의 사용자로부터 이러한 해시를 포함하는 서명된 이벤트들을 수집한 후, 멤버는 그 후 그 시점에서 컨센서스 상태에 대한 증명으로서 그것을 저장하고 그 시점 이전의 이벤트들 및 트랜잭션들을 메모리로부터 삭제할 수 있다.

예시적인 시스템 18: 예시적인 시스템 1(또는 본 명세서에 개시된 임의의 다른 예시적인 시스템)에서의 시스템으로서, 중앙값 또는 다수를 계산하는 연산들이 가중 중앙값 또는 가중 다수로 대체되고, 여기서 멤버들은 그 "지분"에 의해 가중된다. 지분은 그 멤버의 투표가 얼마나 카운트하는지를 표시하는 수이다. 지분은 암호화폐에서의 홀딩들이거나, 단지 멤버가 처음에 조인하도록 초대받을 할당된 다음, 멤버가 조인하도록 초대한 새로운 멤버들 사이에 분할된 임의의 수일 수 있다. 충분한 멤버들이 그 전체 지분이 존재하는 지분의 다수가 되도록 컨센서스 상태에 동의했을 때 오래된 이벤트들은 폐기될 수 있다. 전체 순서가 멤버들이 기여한 랭크들의 중앙값을 이용하여 계산되면, 결과는 멤버들의 절반이 더 높은 랭크를 갖고 절반은 더 낮은 랭크를 갖는 수이다. 다른 한편, 전체 순서가 가중 중앙값을 이용하여 계산되면, 결과는 전체 지분의 약 절반이 그보다 낮은 랭크들과 연관되고, 절반이 그보다 높은 수이다. 가중 투표와 중앙값들은 한 멤버가, 각각이 초대 멤버에 의해 제어되는 단순히 가명일 수 있는 엄청난 수의 "삭 퍼핏(sock puppet)" 사용자들을 조인하도록 초대하는 Sybil 공격을 막는데 유용할 수 있다. 초대 멤버에게 그 지분을 초대 받은 자들과 나누도록 강제하면, 삭 퍼핏들은 컨센서스 결과들을 제어하려고 시도하는 공격자들에게 유용하지 않을 것이다. 따라서, 일부 상황들에서는 지분 증명(proof-of-stake)이 유용할 수 있다.

예시적인 시스템 19: 예시적인 시스템 1(또는 본 명세서에 개시된 임의의 다른 예시적인 시스템)에서의 시스템으로서, 단일 분산 데이터베이스 대신에, 계층 구조의 다수의 데이터베이스가 존재한다. 예를 들어, 사용자들이 멤버들인 단일의 데이터베이스와, 그 후 각각이 멤버들의 서브세트를 갖는 여러 더 작은 데이터베이스들, 또는 "청크들"이 있을 수 있다. 청크에서 이벤트들이 발생할 때, 그것들은 그 청크의 멤버들 사이에 동기화되고 그 청크 외부의 멤버들 사이에는 동기화되지 않는다. 그 후, 때때로, 청크 내에서 컨센서스 순서가 결정된 후에, 결과 상태(또는 그 컨센서스 전체 순서를 갖는 이벤트)는 큰 데이터베이스의 전체 멤버십과 공유될 수 있다.

예시적인 시스템 20: 예시적인 시스템 11(또는 본 명세서에 개시된 임의의 다른 예시적인 시스템)에서의 시스템으로서, (예컨대, 시스템의 멤버에 의해 정의된 데이터베이스 상태 변수에 의해 캡처된) 상태를 업데이트하기 위해 소프트웨어를 업데이트하는 이벤트를 갖는 능력을 갖는다. 예를 들어, 이벤트 X 및 Y는 그 이벤트들 내의 트랜잭션들을 판독하고, 그 후 상태를 적절하게 업데이트하는 소프트웨어 코드에 따라 상태를 수정하는 트랜잭션들을 포함할 수 있다. 그 후, 이벤트 Z는 새로운 버전의 소프트웨어가 이제 이용가능하다는 알림을 포함할 수 있다. 전체 순서가 이벤트들이 X, Z, Y 순서로 발생한다고 말하면, X에서의 트랜잭션들은 오래된 소프트웨어로 처리한 다음, Y에서의 트랜잭션들은 새로운 소프트웨어로 처리함으로써 상태가 업데이트될 수 있다. 그러나 컨센서스 순서가 X, Y, Z라면, X와 Y 둘 다 오래된 소프트웨어로 업데이트될 수 있고, 이는 상이한 최종 상태를 제공할 수 있다. 따라서, 이러한 실시예들에서, 코드를 업그레이드하기 위한 알림은 이벤트 내에서 발생할 수 있어서, 커뮤니티는 오래된 버전으로부터 새로운 버전으로 스위칭할 때에 대한 컨센서스를 달성할 수 있다. 일부 실시예들에서, 코드는 (코드를 업그레이드하기 위한 알림을 포함하는) 이벤트 Z의 수신된 라운드 이후의 라운드들에서 오래된 버전으로부터 새로운 버전으로 스위칭할 수 있다. 따라서, 이벤트 Z가 수신된 라운드 r을 갖는 것으로 결정되면, 라운드 r 또는 그 이전의 수신된 라운드를 갖는 임의의 이벤트들은 오래된 버전을 이용하여 순서화될 것이다. 유사하게, 라운드 r에서와 같은 수신된 라운드를 아직 갖지 않은 임의의 이벤트들은 새로운 버전을 이용하여 순서화될 것이다. 이것은 멤버들이 동기화된 상태들을 유지할 것임을 보장한다. 이것은 또한 프로세스를 재부팅하거나 재시작할 필요 없이 업그레이드 동안에도, 시스템이 계속 실행되는 것을 보장한다.

예시적인 시스템 21: 예시적인 시스템 1(또는 본 명세서에 개시된 임의의 다른 예시적인 시스템)에서의 시스템으로서, 해시그래프의 멤버들 또는 컴퓨팅 디바이스들은 분산 데이터베이스의 서명된 상태를 정의함으로써 분산 데이터베이스의 인스턴스들로부터 불필요한 이벤트들을 제거하도록 구성된다. 일부 구현들에서, 멤버들 또는 컴퓨팅 디바이스들은 메모리의 오버플로우를 방지하고/하거나 메모리 리소스들을 절약하기 위해 추가적인 프로세스들을 실행할 수 있다. 예를 들어, 멤버들 또는 컴퓨팅 디바이스들은 규칙들 또는 기준들의 세트에 기반하여 오래된 이벤트들을 주기적으로 폐기할 수 있다. 규칙은, 예를 들어, 수신된 이벤트의 라운드에서 라운드 번호(또는 라운드 생성)를 뺀 것이 주어진 임계치를 초과하는 경우 또는 이벤트의 생성이 (예를 들어, expiredDuration 또는 ancientDuration에 기반하여) 임계치보다 작은 경우, 이벤트에서의 트랜잭션들을 무시하거나 폐기하는 상태일 수 있다. 일부 경우들에서, 이벤트들은 그 부모들의 해시들 및 각각의 부모에 대한 라운드 생성을 포함한다. 따라서, 주어진 이벤트는, 하나 이상의 부모가 너무 많은 라운드 전에 생성되었기 때문에(예를 들어, 본 명세서에 설명된 바와 같이, 고대이거나 만료되었기 때문에) 무시되거나 폐기된 것으로 인해 누락되더라도, 동기화 동안에 여전히 수락될 수 있다. 따라서, 서명된 상태들은 서명된 상태 전이기는 하지만, 그것들이 무시되거나 폐기될 정도로 서명된 상태보다 오래 전은 아닌 라운드들에서 정의 및/또는 생성된 이벤트들의 해시를 포함할 수 있다. 불필요한 이벤트들을 제거하거나 폐기하는 것은 분산 데이터베이스를 구현하는 컴퓨팅 디바이스들의 세트(예컨대, 해시그래프의 멤버들) 사이에 중복 또는 무관한 이벤트들을 동기화함으로써 야기되는 오버헤드를 감소시키고 이러한 컴퓨팅 디바이스들의 세트의 로컬 메모리들의 불충분한 활용을 감소시킨다. 이벤트들을 제거 및/또는 폐기하는 것에 관한 추가 상세들은 2017년 12월 19일자로 출원되었으며 발명의 명칭이 "Methods and Apparatus for a Distributed Database that Enables Deletion of Events"인 미국 특허 출원 제15/846,402호로서 출원된 미국 특허 출원 공개 제2018/0173747호에서 발견될 수 있으며, 이는 그 전체가 본 명세서에 참조로 포함된다.

더욱이, 일부 구현들에서, 다른 멤버와의 동기화 동안, 컴퓨팅 디바이스는 구문론적으로 부정확한(예를 들어, 파싱하지 않는) 또는 무효한 디지털 서명을 갖는 수신된 이벤트들을 거절할 수 있다. 더욱이, 일부 구현들에서, 동기화 동안, 만료된 수신된 이벤트들이 거절될 수 있다. 또한, 일부 구현들에서, 동기화 동안, 컴퓨팅 디바이스에서 누락된(예를 들어, 그 컴퓨팅 디바이스 또는 분산 데이터베이스의 인스턴스의 메모리 또는 DAG에 있지 않은) 비-고대, 비-만료 부모 이벤트를 갖는 수신된 이벤트는 비-고대, 비-만료 부모 이벤트가 수신될 때까지 거절될 수 있다.

위에 설명된 시스템들은 최종적인 컨센서스를 갖는, 분산 컨센서스를 위한 효율적인 수렴 메커니즘을 생성 및/또는 달성할 것으로 예상된다. 다음에 제시된 바와 같이, 이에 관해 여러 정리들이 증명될 수 있다.

예시적인 정리 1: 이벤트 x가 부분 순서에서 이벤트 y에 선행하면, 주어진 시간에 다른 멤버들에 대한 주어진 멤버의 지식에서, 다른 멤버들 각각은 y 이전에 x의 표시를 수신할 것이거나, 아직 y의 표시를 수신하지 않았을 것이다.

증명: 이벤트 x가 부분 순서에서 이벤트 y에 선행하면, x는 y의 조상이다. 멤버가 처음으로 y의 표시를 수신하면, 그 멤버는 x 표시를 이전에 이미 수신했거나(그 경우 그것들은 y 이전에 x에 대해 들음), 또는 이것은 그 동기화가 x 및 y 둘 다를 그 멤버에게 제공하는 경우일 것이다(그 경우 그것들은 그 동기화 동안 y 이전에 x에 대해 들을 것인데, 그 이유는 단일 동기화 동안 수신된 이벤트들은 예시적인 시스템 5에 관하여 설명된 바와 같이 조상 관계들과 일치하는 순서로 수신된 것으로 간주되기 때문이다)(QED).

예시적인 정리 2: 임의의 주어진 해시그래프에 대해, x가 부분 순서에서 y에 선행하면, x는 그 해시그래프에 대해 계산된 전체 순서에서 y에 선행할 것이다.

증명: x가 부분 순서에서 y에 선행하면, 정리 1에 의해,

모든 i에 대해, rank(i,x) < rank(i,y)이고,

여기서 rank(i,x)는 멤버 i에 의해 이벤트 x에 할당된 랭크이고, 이는 x가 멤버 i에 의해 수신된 제1 이벤트이면 1이고, 제2 이벤트이면 2인 것 등등이다. med(x)를 모든 i에 걸쳐 rank(i,x)의 중앙값이라고 하고, med(y)에 대해서도 유사하게 한다.

주어진 k에 대해, rank(i1,x)가 k 번째 가장 작은 x 랭크이고 rank(i2,y)가 k 번째 가장 작은 y 랭크가 되도록 i1과 i2를 선택한다. 그러면,

rank(i1,x) < rank(i2,y)이다.

이는 rank(i2,y)가 y 랭크들의 k보다 크거나 같고, 그 각각이 대응하는 x 랭크보다 절대적으로 크기 때문이다. 따라서, rank(i2,y)는 x 랭크들 중 적어도 k보다 절대적으로 크므로 k 번째 가장 작은 x 랭크보다 절대적으로 크다. 이 논거는 임의의 k에 대해 성립한다.

n을 멤버들의 수(i 값들의 수임)라고 하자. 그러면 n은 홀수이거나 짝수여야 한다. n이 홀수이면 k=(n+1)/2로 하고, k 번째 가장 작은 랭크는 중앙값일 것이다. 따라서, med(x) < med(y)이다. n이 짝수이면, k = n/2일 때, k 번째 가장 작은 x 랭크는 k 번째 가장 작은 y 랭크보다 절대적으로 작을 것이고, 또한 (k+1) 번째 가장 작은 x 랭크는 (k+1) 번째 가장 작은 y 랭크보다 절대적으로 작을 것이다. 따라서 2개의 x 랭크의 평균은 2개의 y 랭크의 평균보다 작을 것이다. 따라서, med(x) < med(y)이다. 따라서 양쪽 경우에서, x 랭크들의 중앙값은 y 랭크들의 중앙값보다 절대적으로 작다. 따라서 전체 순서가 중앙값 랭크에 의해 액션들을 정렬하여 정의되면, x는 전체 순서에서 y에 선행할 것이다(QED).

예시적인 정리 3: "가십 기간(gossip period)"이 기존 이벤트들이 모든 멤버들에 동기화하는 것을 통해 전파되는 시간의 양이면,

1 가십 기간 이후: 모든 멤버들이 이벤트들을 수신했다.

2 가십 기간 이후: 모든 멤버들이 그 이벤트들의 순서에 동의한다.

3 가십 기간 이후: 모든 멤버들이 합의에 도달하였음을 안다.

4 가십 기간 이후: 모든 멤버들이 모든 다른 멤버들로부터 디지털 서명을 획득하여, 이 컨센서스 순서를 지지한다.

증명: 주어진 시간 T0에 의해 생성 및/또는 정의된 이벤트들의 세트를 S0이라고 하자. 모든 멤버가 결국 모든 다른 멤버와 종종 무한히 동기화될 것이면, 확률 1로 결국, 모든 멤버가 모든 이벤트들을 인식하도록, S0 내의 이벤트들이 모든 멤버에게 확산된 시간 T1이 있을 것이다. 이는 제1 가십 기간의 끝이다. S1을 시간 T1에 존재하고 T0에는 아직 존재하지 않은 이벤트들의 세트라고 하자. 그러면 확률 1로 결국 모든 멤버가 시간 T1에 존재한 것들인 세트 S1 내의 모든 이벤트를 수신한 시간 T2가 있을 것이다. 이는 제2 가십 기간의 끝이다. 유사하게, T3은 T1 이전에는 아니지만 T2에는 존재하는 것들인 S2의 모든 이벤트들이 모든 멤버들에 확산된 때이다. 각각의 가십 기간은 결국 확률 1로 끝난다는 점에 유의한다. 평균적으로, n명의 멤버가 있는 경우, 각각은 log2(n) 동기화를 수행하는데 걸리는 만큼 지속될 것이다.

시간 T1까지는, 모든 멤버가 S0 내의 모든 이벤트를 수신할 것이다.

시간 T2까지는, 주어진 멤버인 Alice가 S0 내의 모든 이벤트를 수신하는 다른 멤버들 각각의 기록을 수신할 것이다. 따라서 Alice는 모든 멤버에 대한 S0 내의 모든 액션에 대한 랭크(이는 그 멤버가 그 액션을 수신한 순서임)를 계산하고, 그 후 랭크들의 중앙값에 의해 이벤트들을 정렬할 수 있다. S0 내의 이벤트들에 대해, 결과적인 전체 순서는 변경되지 않는다. 그 이유는 결과적인 순서는 각각의 멤버가 그 이벤트들 각각의 표시를 먼저 수신한 순서의 함수이고, 이는 변경되지 않기 때문이다. Alice의 계산된 순서에는 S0 이벤트들 사이에 산재된 S1의 일부 이벤트들이 있을 것이라는 것이 가능하다. 그 S1 이벤트들은 S0 이벤트들의 시퀀스 내에서 그들이 속하는 곳을 여전히 변경할 수 있다. 그러나 S0 내의 이벤트들의 상대적 순서는 변경되지 않을 것이다.

시간 T3까지는, Alice가 S0과 S1의 합집합에 대한 전체 순서를 알게 될 것이고, 그 합집합에서의 이벤트들의 상대적 순서는 변경되지 않을 것이다. 또한, 그녀는 이 시퀀스 내에서 S1로부터 가장 이른 이벤트를 찾을 수 있고, S1 이전의 이벤트들의 시퀀스가 변경되지 않을 것이며, 심지어 S0의 외부의 새로운 이벤트들을 삽입에 의해서조차도 변경되지 않을 것이라고 결론을 내릴 수 있다. 따라서, 시간 T3까지는, Alice는 제1 S1 이벤트 이전의 이력에서의 이벤트들의 순서에 대해 컨센서스가 달성되었다고 결정할 수 있다. 그녀는 이러한 이벤트들이 이 순서대로 발생한 결과로 생기는 상태의 해시(예컨대, Alice에 의해 정의된 데이터베이스 상태 변수에 의해 캡처된)에 디지털 서명하고, 그 서명을 그녀가 생성 및/또는 정의하는 다음 이벤트의 일부로서 송출할 수 있다.

시간 T4까지는, Alice가 다른 멤버들로부터 유사한 서명들을 수신할 것이다. 그 시점에서 그녀는 단순히 그 서명들의 목록을 그것들이 증명하는 상태와 함께 유지할 수 있고, 그녀는 제1 S1 이벤트 이전에 그녀가 저장한 이벤트들을 폐기할 수 있다(QED).

본 명세서에 설명된 시스템들은 컨센서스를 신속하고 안전하게 달성하는 분산 데이터베이스를 설명한다. 이는 많은 응용들에 대해 유용한 빌딩 블록이 될 수 있다. 예를 들어, 트랜잭션들이 하나의 암호화폐 지갑에서 다른 암호화폐 지갑으로의 암호화폐의 전송을 설명한다면, 그리고 상태가 단순히 각각의 지갑 내의 현재 금액에 대한 진술이라면, 이 시스템은 기존 시스템들에서의 고가의 작업 증명(proof-of-work)을 피하는 암호화폐 시스템을 구성할 것이다. 자동 규칙 시행은 이것이 현재 암호화폐들에서 일반적이지 않은 특징들을 추가할 수 있게 한다. 예를 들어, 지갑이 특정 시간 기간 동안 암호화폐를 전송하지도 수신하지도 않으면, 그 지갑이 삭제되고, 그 가치를 다른 기존 지갑들에 그들이 현재 포함하고 있는 양에 비례하여 분배하는 규칙을 시행함으로써, 손실 코인들이 회수되어, 통화 수축을 피할 수 있다. 이러한 방식으로, 지갑에 대한 개인 키가 손실되더라도 금전 공급은 증가하거나 축소되지 않을 것이다.

다른 예는 분산 게임으로서, 이는 서버에서 플레이되는 MMO(Massively Multiplayer Online) 게임처럼 작용하지만, 그럼에도 중앙 서버를 이용하지 않고 그것을 달성한다. 컨센서스는 제어되는 임의의 중앙 서버 없이 달성될 수 있다.

다른 예는 이러한 데이터베이스의 위에 구축되는 소셜 미디어를 위한 시스템이다. 트랜잭션들이 디지털 서명되고, 멤버들이 다른 멤버들에 관한 정보를 수신하기 때문에, 이는 현재 시스템들에 비해 보안성 및 편의의 이점들을 제공한다. 예를 들어, 강력한 스팸 방지 정책들을 갖는 이메일 시스템이 구현될 수 있는데, 그 이유는 이메일들이 반환 주소들을 위조할 수 없을 것이기 때문이다. 이러한 시스템은 또한 이메일, 트윗, 텍스트, 포럼, 위키, 및/또는 다른 소셜 미디어에 의해 현재 행해지는 기능들을 단일의 분산 데이터베이스에 결합하여, 통합된 소셜 시스템이 될 수 있다.

다른 응용들은 그룹 전체가 계약서 또는 문서에 서명하도록 협력하는 그룹 디지털 서명과 같은 더 복잡한 암호 함수들을 포함할 수 있다. 이러한, 그리고, 다른 다자간 계산의 형태들은 이러한 분산 컨센서스 시스템을 이용하여 유용하게 구현될 수 있다.

다른 예는 공용 원장 시스템(public ledger system)이다. 누구든지 시스템에 어떤 정보를 저장하기 위해 지불할 수 있으며, 시스템에 정보를 저장하기 위해 연간 바이트당 소량의 암호화폐(또는 실제 화폐)를 지불한다. 그 후 이러한 자금들은 그 데이터를 저장한 멤버들에게, 그리고 컨센서스를 달성하기 위해 작업하도록 반복적으로 동기화하는 멤버들에게 자동으로 분배될 수 있다. 이것은 멤버들에게 그들이 동기화할 때마다 소량의 암호화폐를 자동으로 전송할 수 있다.

이 예들은 분산 컨센서스 데이터베이스가 많은 응용들의 컴포넌트로서 유용함을 보여준다. 데이터베이스는 고가의 작업 증명을 이용하지 않고, 대신에 더 저렴한 지분 증명을 이용할 수 있기 때문에, 데이터베이스는 더 작은 컴퓨터 또는 심지어 모바일 및 내장 디바이스들에서 전체 노드가 운용되는 식으로 운용될 수 있다.

2개의 이전 이벤트의 해시(하나는 자기 해시 그리고 하나는 외부 해시)를 포함하는 이벤트로서 위에 설명되었지만, 다른 실시예들에서, 한 멤버가 2명의 다른 멤버와 동기화하여 3개의 이전 이벤트의 해시들(하나는 자기 해시 그리고 2개는 외부 해시)을 포함하는 이벤트를 생성 및/또는 정의할 수 있다. 또 다른 실시예들에서, 임의의 수의 멤버로부터의 이전 이벤트들의 임의의 수의 이벤트 해시가 이벤트 내에 포함될 수 있다. 일부 실시예들에서, 상이한 이벤트들은 상이한 수의 이전 이벤트들의 해시들을 포함할 수 있다. 예를 들어, 제1 이벤트는 2개의 이벤트 해시를 포함될 수 있고 제2 이벤트는 3개의 이벤트 해시를 포함될 수 있다.

이벤트들이 이전 이벤트들의 해시들(또는 암호 해시 값)을 포함하는 것으로 위에 설명되었지만, 다른 실시예들에서, 이벤트는 포인터, 식별자 및/또는 이전 이벤트에 대한 임의의 다른 적합한 참조를 포함하도록 생성 및/또는 정의될 수 있다. 예를 들어, 이전 이벤트와 연관되고 그를 식별하는데 이용되는 일련 번호를 포함하도록 이벤트가 생성 및/또는 정의될 수 있고, 따라서 이벤트들을 링크할 수 있다. 일부 실시예들에서, 이러한 일련 번호는, 예를 들어, 이벤트를 생성 및/또는 정의한 멤버와 연관된 식별자(예컨대, 매체 액세스 제어(MAC) 주소, 인터넷 프로토콜(IP) 주소, 할당된 주소, 등) 및 그 멤버에 의해 정의된 이벤트의 순서를 포함할 수 있다. 예를 들어, 10의 식별자를 갖는 그리고 이벤트가 그 멤버에 의해 생성 및/또는 정의된 15 번째 이벤트인 멤버는 그 이벤트에 1015의 식별자를 할당할 수 있다. 다른 실시예들에서, 임의의 다른 적합한 포맷이 이벤트들에 대한 식별자를 할당하는데 이용될 수 있다.

다른 실시예들에서, 이벤트들은 전체 암호 해시들을 포함할 수 있지만, 동기화 동안 그 해시들 중 일부들만 전송된다. 예를 들어, Alice가 Bob에게 해시 H를 포함하는 이벤트를 전송하고 J가 H의 처음 3 바이트이고, Alice가 그녀가 저장한 이벤트들 및 해시들 중, H가 J로 시작하는 유일한 해시라고 결정하면, 그녀는 동기화 동안 H 대신 J를 전송할 수 있다. 그 후, Bob이 J로 시작하는 다른 해시를 가지고 있다고 결정하면, 그는 Alice에게 응답하여 전체 H를 요청할 수 있다. 이러한 방식으로, 해시들이 전송 동안에 압축될 수 있다.

위에 도시되고 설명된 예시적인 시스템들은 다른 시스템을 참조하여 설명되었지만, 다른 실시예들에서는, 예시적인 시스템들 및 그 연관된 기능들의 임의의 조합이 분산 데이터베이스를 생성 및/또는 정의하도록 구현될 수 있다. 예를 들어, 예시적인 시스템(1), 예시적인 시스템(2) 및 예시적인 시스템 3을 조합하여 분산 데이터베이스를 생성 및/또는 정의할 수 있다. 다른 예로서, 일부 실시예들에서, 예시적인 시스템 10은 예시적인 시스템 1로, 그러나, 예시적인 시스템 9 없이 구현될 수 있다. 또 다른 예로서, 예시적인 시스템 7은 예시적인 시스템 6과 조합되어 구현될 수 있다. 또 다른 실시예들에서, 예시적인 시스템의 임의의 다른 적합한 조합들이 구현될 수 있다.

다양한 실시예들이 위에 설명되었지만, 그것들은 제한이 아니라, 단지 예로서 제시되었다는 것이 이해되어야 한다. 위에 설명된 방법들이 특정 순서로 발생하는 특정 이벤트들을 표시하는 경우, 그 특정 이벤트들의 순서는 수정될 수 있다. 추가적으로, 이벤트들 중 특정 이벤트는 가능한 경우 병렬 프로세스에서 동시에 수행될 수 있을 뿐만 아니라 위에 설명된 바와 같이 순차적으로 수행될 수 있다.

본 명세서에 설명된 일부 실시예들은 다양한 컴퓨터 구현 동작들을 수행하는 명령어들 또는 컴퓨터 코드를 그 위에 갖는 비일시적 컴퓨터 판독가능한 매체(또한 비일시적 프로세서 판독가능한 매체라고도 지칭될 수 있음)를 가지는 컴퓨터 저장 제품과 관련된다. 컴퓨터 판독가능한 매체(또는 프로세서 판독가능한 매체)는 일시적인 전파 신호들 자체(예컨대, 공간 또는 케이블과 같은 전송 매체를 통해 정보를 운반하는 전파하는 전자기파)를 포함하지 않는다는 점에서 비일시적이다. 매체와 컴퓨터 코드(또한 코드라고도 지칭될 수 있음)는 특정 목적 또는 목적들을 위해 설계되고 구성된 것들일 수 있다. 비일시적 컴퓨터 판독가능한 매체의 예들은 다음의 것들을 포함하지만 이에 제한되는 것은 아니다: 하드 디스크들, 플로피 디스크들, 및 자기 테이프와 같은 자기 저장 매체; 콤팩트 디스크/디지털 비디오 디스크들(CD/DVD들), 콤팩트 디스크-판독 전용 메모리들(CD-ROM들), 및 홀로그래픽 디바이스들과 같은 광학 저장 매체; 광 디스크들과 같은 자기 광학 저장 매체; 반송파 신호 처리 모듈들; 애플리케이션-특정 집적 회로들(ASIC들), 프로그램 가능 로직 디바이스들(PLD들), 판독 전용 메모리(ROM), 및 랜덤 액세스 메모리(RAM) 디바이스들과 같은 프로그램 코드를 저장하고 실행하도록 특별히 구성되는 하드웨어 디바이스들을 포함한다. 본 명세서에 설명된 다른 실시예들은 예를 들어 본 명세서에서 논의된 명령어들 및/또는 컴퓨터 코드를 포함할 수 있는 컴퓨터 프로그램 제품과 관련된다.

컴퓨터 코드의 예들은 마이크로-코드 또는 마이크로-명령어들, 컴파일러에 의해 생성된 것과 같은 머신 명령어들, 웹 서비스를 생성하는데 이용된 코드, 및 인터프리터를 이용하여 컴퓨터에 의해 실행되는 상위-레벨 명령어들을 포함하는 파일들을 포함하지만, 이에 제한되는 것은 아니다. 예를 들어, 실시예들은 명령형 프로그래밍 언어(예컨대, C, Fortran 등), 함수형 프로그래밍 언어(Haskell, Erlang 등), 논리적 프로그래밍 언어(예컨대, Prolog), 객체 지향 프로그래밍 언어(예컨대, Java, C++ 등) 또는 다른 적합한 프로그래밍 언어 및/또는 개발 툴을 이용하여 구현될 수 있다. 컴퓨터 코드의 추가적인 예들은 제어 신호들, 암호화된 코드, 및 압축된 코드를 포함하지만, 이에 제한되는 것은 아니다.

다양한 실시예들이 위에 설명되었지만, 이들은 제한이 아니라 단지 예로서 제시되었고, 형태 및 상세에 있어서 다양한 변경들이 이루어질 수 있다는 것이 이해되어야 한다. 본 명세서에 설명된 장치들 및/또는 방법들의 임의의 부분은 상호 배타적인 조합을 제외한 임의의 조합으로 조합될 수 있다. 본 명세서에 설명된 실시예들은 설명된 상이한 실시예들의 기능들, 컴포넌트들 및/또는 특징들의 다양한 조합들 및/또는 하위 조합들을 포함할 수 있다.

Claims

방법으로서,
분산 데이터베이스에 대한 주소록을 정의하는 단계 - 상기 주소록은 네트워크를 통해 상기 분산 데이터베이스를 구현하는 복수의 컴퓨팅 디바이스로부터의 각각의 컴퓨팅 디바이스에 대한 식별자를 포함함 -;
상기 복수의 컴퓨팅 디바이스로부터의 컴퓨팅 디바이스로부터, 상기 주소록을 업데이트하기 위한 트랜잭션을 포함하는 이벤트를 수신하는 단계;
상기 주소록을 이용하는 상기 분산 데이터베이스의 컨센서스 프로토콜에 기반하여, 상기 이벤트에 대한 수신된 라운드(round)를 계산하는 단계; 및
상기 이벤트에 대한 상기 수신된 라운드 또는 상기 주소록에 대한 이전 업데이트 중 적어도 하나 후에 미리 결정된 수의 라운드로 업데이트된 주소록을 정의하기 위해 상기 트랜잭션에 기반하여 상기 주소록을 업데이트하는 단계
를 포함하는, 방법.
제1항에 있어서,
상기 주소록을 업데이트하기 위한 상기 트랜잭션은 상기 분산 데이터베이스를 구현하는 상기 복수의 컴퓨팅 디바이스에 컴퓨팅 디바이스를 추가하는 것 또는 상기 분산 데이터베이스를 구현하는 상기 복수의 컴퓨팅 디바이스로부터 컴퓨팅 디바이스를 제거하는 것 중 적어도 하나를 포함하는, 방법.
제1항에 있어서,
상기 주소록은 상기 분산 데이터베이스를 구현하는 상기 복수의 컴퓨팅 디바이스로부터의 각각의 컴퓨팅 디바이스에 대한 지분 값(stake value)을 포함하고, 상기 주소록을 업데이트하기 위한 상기 트랜잭션은 상기 복수의 컴퓨팅 디바이스로부터의 적어도 하나의 컴퓨팅 디바이스에 대한 상기 지분 값을 수정하는 것을 포함하는, 방법.
제1항에 있어서,
상기 분산 데이터베이스와 연관된 복수의 이벤트로부터의 각각의 이벤트에 대한 수신된 라운드는 그 이벤트에 대한 후손 이벤트들의 세트에 기반하고, 상기 후손 이벤트들의 세트는 상기 업데이트 전에 상기 주소록을 이용하여 계산되고, 상기 후손 이벤트들의 세트는 상기 업데이트 후에 상기 업데이트된 주소록을 이용하여 계산되는, 방법.
제1항에 있어서,
상기 컨센서스 프로토콜은 상기 컨센서스 프로토콜의 각각의 라운드에 대한 이벤트들의 세트를 식별하도록 구성되고, 각각의 라운드에 대한 상기 이벤트들의 세트는 복수의 이벤트로부터의 각각의 이벤트에 대한 수신된 라운드를 결정하기 위해 상기 컨센서스 프로토콜에 의해 이용되고,
상기 주소록을 이용하여 상기 복수의 이벤트로부터의 각각의 이벤트에 대해 속성이 계산되고,
그 이벤트가 상기 업데이트된 주소록이 정의되는 라운드에 대한 상기 이벤트들의 세트로부터의 적어도 하나의 이벤트의 조상이 아닐 때, 상기 업데이트된 주소록을 이용하여 상기 복수의 이벤트로부터의 각각의 이벤트에 대해 상기 속성이 재계산되는, 방법.
제1항에 있어서,
상기 컨센서스 프로토콜은 상기 컨센서스 프로토콜의 각각의 라운드에 대한 이벤트들의 세트를 식별하도록 구성되고, 각각의 라운드에 대한 상기 이벤트들의 세트는 복수의 이벤트로부터의 각각의 이벤트에 대한 수신된 라운드를 결정하기 위해 상기 컨센서스 프로토콜에 의해 이용되고,
상기 주소록을 이용하여 상기 복수의 이벤트로부터의 각각의 이벤트에 대해 속성이 계산되고,
상기 복수의 이벤트로부터의 그 이벤트가 상기 업데이트된 주소록이 정의되는 라운드에 대한 상기 이벤트들의 세트로부터의 적어도 하나의 이벤트의 조상일 때, 상기 업데이트된 주소록을 이용하여 상기 복수의 이벤트로부터의 각각의 이벤트에 대해 상기 속성이 재계산되지 않는, 방법.
제1항에 있어서,
상기 업데이트하는 단계는 상기 주소록에 대한 상기 이전 업데이트 후에 상기 미리 결정된 수의 라운드로 상기 업데이트된 주소록을 정의하는 단계를 포함하고, 상기 업데이트된 주소록은 상기 주소록에 대한 상기 이전 업데이트가 발생한 라운드와 상기 업데이트된 주소록이 정의되는 라운드 사이의 수신된 라운드 번호를 갖는 이벤트들 내의 상기 주소록에 대한 업데이트들을 포함하는, 방법.
제1항에 있어서,
상기 업데이트하는 단계는 상기 이벤트에 대한 상기 수신된 라운드 후에 상기 미리 결정된 수의 라운드로 상기 업데이트된 주소록을 정의하는 단계를 포함하고, 상기 미리 결정된 수의 라운드는 1보다 큰, 방법.
제1항에 있어서,
상기 복수의 컴퓨팅 디바이스로부터의 각각의 컴퓨팅 디바이스에 대한 상기 식별자는 상기 복수의 컴퓨팅 디바이스로부터의 그 컴퓨팅 디바이스에 대한 공개 키인, 방법.
장치로서,
복수의 컴퓨팅 디바이스에 동작가능하게 결합된 네트워크를 통해 상기 복수의 컴퓨팅 디바이스에 의해 구현되는 분산 데이터베이스와 연관된 컴퓨팅 디바이스의 메모리; 및
상기 메모리에 동작가능하게 결합된 프로세서
를 포함하며, 상기 프로세서는,
상기 분산 데이터베이스에 대한 주소록을 정의하고 - 상기 주소록은 상기 분산 데이터베이스를 구현하는 상기 복수의 컴퓨팅 디바이스로부터의 각각의 컴퓨팅 디바이스에 대한 식별자를 포함함 -;
상기 복수의 컴퓨팅 디바이스로부터의 컴퓨팅 디바이스로부터, 상기 주소록을 업데이트하기 위한 트랜잭션을 포함하는 이벤트를 수신하고;
복수의 이벤트로부터의 각각의 이벤트에 대한 속성을 계산하고 - 상기 이벤트는 상기 복수의 이벤트에 포함됨 -;
상기 주소록을 이용하는 상기 분산 데이터베이스의 컨센서스 프로토콜에 기반하여, 상기 이벤트에 대한 수신된 라운드를 계산하고 - 상기 수신된 라운드는 상기 이벤트의 후손들인 이벤트들의 세트로부터의 임계 수의 이벤트들에 기반함 -;
상기 이벤트에 대한 상기 수신된 라운드 또는 상기 주소록에 대한 이전 업데이트 중 적어도 하나 후에 미리 결정된 수의 라운드로 업데이트된 주소록을 정의하기 위해 상기 트랜잭션에 기반하여 상기 주소록을 업데이트하고;
상기 업데이트된 주소록을 이용하여, 그 이벤트가 상기 이벤트들의 세트로부터의 후손 이벤트를 갖지 않을 때 상기 복수의 이벤트로부터의 각각의 이벤트에 대한 상기 속성을 재계산하도록 구성되는, 장치.
제10항에 있어서,
상기 프로세서는 상기 이벤트에 대한 상기 수신된 라운드 후에 상기 미리 결정된 수의 라운드로 상기 업데이트된 주소록을 정의하기 위해 상기 트랜잭션에 기반하여 상기 주소록을 업데이트하도록 구성되고, 상기 미리 결정된 수의 라운드는 1보다 큰, 장치.
제10항에 있어서,
상기 프로세서는 상기 주소록에 대한 상기 이전 업데이트 후에 상기 미리 결정된 수의 라운드로 상기 업데이트된 주소록을 정의하기 위해 상기 트랜잭션에 기반하여 상기 주소록을 업데이트하도록 구성되고, 상기 업데이트된 주소록은 상기 주소록에 대한 상기 이전 업데이트가 발생한 라운드와 상기 업데이트된 주소록이 정의되는 라운드 사이의 수신된 라운드 번호를 갖는 이벤트들 내의 상기 주소록에 대한 업데이트들을 포함하는, 장치.
제10항에 있어서,
상기 주소록을 업데이트하기 위한 상기 트랜잭션은 상기 분산 데이터베이스를 구현하는 상기 복수의 컴퓨팅 디바이스에 컴퓨팅 디바이스를 추가하는 것 또는 상기 분산 데이터베이스를 구현하는 상기 복수의 컴퓨팅 디바이스로부터 컴퓨팅 디바이스를 제거하는 것 중 적어도 하나를 포함하는, 장치.
제10항에 있어서,
상기 프로세서는, 상기 업데이트된 주소록을 이용하여, 그 이벤트가 상기 이벤트들의 세트로부터의 후손 이벤트를 가질 때 상기 복수의 이벤트로부터의 각각의 이벤트에 대한 상기 속성을 재계산하지 않도록 구성되는, 장치.
프로세서에 의해 실행될 명령어들을 나타내는 코드를 저장한 비일시적 프로세서 판독가능한 매체로서, 상기 코드는 상기 프로세서로 하여금,
네트워크를 통해, 분산 데이터베이스를 구현하는 복수의 컴퓨팅 디바이스에 그리고 상기 분산 데이터베이스를 구현하는 노드로서 연결하게 하고;
상기 복수의 컴퓨팅 디바이스로부터의 컴퓨팅 디바이스로부터, 컨센서스 프로토콜의 완료된 라운드와 연관된 상기 분산 데이터베이스의 상태를 수신하게 하고 - 상기 상태는 이벤트들의 코어 세트로부터의 각각의 이벤트에 대한 라운드 식별자와 함께 상기 완료된 라운드와 연관된 상기 이벤트들의 코어 세트의 표시를 포함함 -;
상기 복수의 컴퓨팅 디바이스로부터, 상기 상태와 연관된 복수의 이벤트를 수신하게 하고;
상기 이벤트들의 코어 세트 및 상기 이벤트들의 코어 세트로부터의 각각의 이벤트에 대한 상기 라운드 식별자에 기반하여 상기 복수의 이벤트로부터의 각각의 이벤트에 대한 속성들의 세트를 계산하게 하고;
상기 복수의 이벤트 및 상기 복수의 이벤트에 대한 상기 속성들의 세트에 기반하여 방향성 비순환 그래프(directed acyclic graph)(DAG)를 구성하게 하고;
상기 DAG를 이용하여, 상기 컨센서스 프로토콜의 다음 라운드와 연관된 이벤트들의 순서를 계산하게 하는 코드를 포함하는, 비일시적 프로세서 판독가능한 매체.
제15항에 있어서,
상기 이벤트들의 코어 세트의 표시는 상기 이벤트들의 코어 세트로부터의 각각의 이벤트에 대한 해시 값을 포함하는, 비일시적 프로세서 판독가능한 매체.
제15항에 있어서,
상기 이벤트들의 코어 세트는 상기 완료된 라운드 이전의 미리 결정된 수의 라운드에서 라운드의 세대(generation)인 세대를 갖는 이벤트들을 포함하지 않는, 비일시적 프로세서 판독가능한 매체.
제15항에 있어서,
상기 프로세서로 하여금, 상기 복수의 이벤트로부터, 상기 완료된 라운드 이전의 미리 결정된 수의 라운드에서 라운드의 세대인 세대를 갖는 이벤트를 폐기하게 하는 코드를 더 포함하는, 비일시적 프로세서 판독가능한 매체.
제15항에 있어서,
상기 상태는 상기 복수의 컴퓨팅 디바이스로부터의 미리 결정된 백분율의 컴퓨팅 디바이스들에 의해 디지털 서명되는, 비일시적 프로세서 판독가능한 매체.
제15항에 있어서,
상기 프로세서로 하여금 상기 복수의 이벤트를 수신하게 하는 상기 코드는 상기 프로세서가 상기 복수의 이벤트로부터의 다른 이벤트들을 수락하기 전에 상기 이벤트들의 코어 세트로부터의 각각의 이벤트를 수락하도록 상기 프로세서로 하여금 상기 복수의 이벤트를 수신하게 하는 코드를 포함하는, 비일시적 프로세서 판독가능한 매체.