PeaceFounder.Model

struct AckConsistency{T}
    proof::ConsistencyProof
    commit::Commit{T}
end

Represents an ackknowledgment from the issuer that a root is permanetly included in the ledger. This acknowledgemnt assures that ledger up to index(ack) is included in the current ledger which has has index index(commit(ack)). This is useful in a combination with AckInclusion to privatelly update it's validity rather than asking an explicit element. Also ensures that other elements in the ledger are not being tampered with.

Interface: root, id, issuer, commit, index, verify

struct AckInclusion{T}
    proof::InclusionProof
    commit::Commit{T}
end

Represents an acknowldgment from the issuer that a leaf is permanently included in the ledger. In case the ledger is tampered with this acknowledgement acts as sufficient proof to blame the issuer.

Interface: leaf, id, issuer, commit, index, verify

Commit{T}
    state::T
    seal::Seal
end

Represents a commited ledger state to which issuer can be held accountable for integrity. It is assumed that T implements index and root necessaary to fix a ledger state.

Interface: id, issuer, verify, index, root, state

struct CryptoSpec
    hasher::Hash
    group::Spec
    generator::Generator
end

Specification of cryptographic parameters which are used for public key cryptography, message hashing and authetification codes.

struct Digest
    data::Vector{UInt8}
end

A message digest obtained applying a hash function on a message or a document. See method digest.

struct Generator
    data::Vector{UInt8}
end

Datatype which stores cryptogrpahic group point in standart octet form intended to be used as a base. See also Pseudonym.

struct HMAC
    key::Vector{UInt8}
    hasher::Hash
end

Represent a hash message authetification code authorizer.

Interface: hasher, digest, key

struct Hash
    spec::String
end

A specification for a hasher. See method digest.

struct Pseudonym
    pk::Vector{UInt8}
end

A datatype which stores public key in canonical standart octet form.

struct Seal
    pbkey::Pseudonym
    sig::Signature
end

A wrapper type for a signature which adds a public key of signature issuer. See seal method.

Interface: pseudonym, verify

struct Signer
    spec::CryptoSpec
    pbkey::Pseudonym
    key::BigInt
end

A signer type. See a method generate(Signer, spec) for initialization.

Interface: pseudonym, id, sign, seal, approve

leaf(ack::AckInclusion)

Access a leaf diggest for which the acknowledgment is made.

root(x::AckConsistency)

Access a root diggest for which the acknowledgment is made.

root(x)::Digest

Return a ledger root hash.

commit(x)

Access a commit of an object x.

digest(message::Vector{UInt8}, hasher::Hash)::Digest
digest(document, spec) = digest(canonicalize(message)::Vector{UInt8}, hasher(spec)::Hash)

Return a resulting digest applying hasher on the given message. When message is not octet string a canonicalize method is applied first.

digest(bytes::Vector{UInt8}, hasher::Hash)::Digest
digest(x, spec) = digest(canonicalize(x)::Vector{UInt8}, hasher(spec)::Hash)

Compute a hash digest. When input is not in bytes the canonicalize method is applied first.

generate(Signer, spec::CryptoSpec)::Signer

Generate a unique private key and return a Signer object.

generator(crypto::CryptoSpec)::Generator

Return a generator of the specification.

generator(spec::Spec)::Generator

Return a generator of spec.

hasher(spec)::Hash

Access a hasher function from a given specification.

index(ack::AckConsistency)

Return an index for a root at which the consistency proof is made. To obtain the current ledger index use index(commit(ack)).

index(ack::AckInclusion)::Int

Return an index at which the leaf is recorded in the ledger. To obtain the current ledger index use index(commit(ack)).

index(x)::Int

Return an index of a ledger state.

isbinding(x, y, spec::Hash)::Bool
isbinding(x, y, spec) = isbinding(x, y, hasher(spec)::Hash)

Check binding of two objects x and y. Some general examples:

• Check that a document is bound to it's signature.
• Check that a record is included in the ledger.
• Check that a given object is consistent with a ledger.

issuer(x)

In case an object x is cryptographically signed return an issuer of who have issued the signature. See also id.

key(x)

Access a secret key of an object x.

seal(message::Vector{UInt8}[, generator::Generator], signer::Signer)::Seal

Sign a bytestring message with signer's private key and specification and return a signature as a Seal. When generator is provided it is used as a base for the signature. See also sign.

sign(digest::Digest[, generator::Generator], signer::Signer)::Signature

Sign a digest as an integer with signer's private key and specification. This method avoids running hashing twice when that is done externally. When generator is provided it is used as a base for the signature.

sign(message::Vector{UInt8}[, generator::Generator], signer::Signer)::Signature

Sign a bytestring message with signer's private key and specification. When generator is provided it is used as a base for the signature.

state(commit::Commit{T})::T

Return a ledger state. T implements index and root.

ToDo: a well specified encoding is essential here. Binary tree encoding may suffice here. More fancy approach would be to use a DER encoding. Meanwhile JSON shall be used.

pseudonym(signer::Signer, [generator])::Pseudonym

Return a pseudonym of a signer at a given relative generator. If generator is not passed returns identity pseudonym. (See also id)

pseudonym(seal::Seal)::Pseudonym

Return a pseudonym of a seal. Note that it is not equal to identity when the signature is issued on a relative generator.

pseudonym(vote::Vote)::Pseudonym

Return a pseudonym used to seal the vote.

id(document)::Pseudonym

Return identity pseudonym of a document issuer.

id(signer)::Pseudonym

Return identity pseudonym of a signer.

verify(message, seal::Seal, [generator::Generator], crypto::CryptoSpec)::Bool
verify(message, pk::Pseudonym, sig::Signature, [generator::Generator], crypto::CryptoSpec)::Bool

Verify the cryptographic signature of the message returning true if valid. An optional generator can be given when signature is issued on a relative generator differing from a base specification crypto.

verify(document[, generator::Generator], crypto::CryptoSpec)::Bool

Verify a cryptographic signature of the document returning true if valid.

verify(braidwork::BraidWork, crypto::CryptoSpec)::Bool

Verify a braider issued cryptographic signature for the braidwork and a zero knowledge proofs. Returns true if both checks succeed.

struct Admission
    ticketid::TicketID
    id::Pseudonym
    timestamp::DateTime
    approval::Union{Seal, Nothing}
end

Represents an admission certificate for a pseudonym id.

Interface: approve, issuer, id, ticket, isadmitted

mutable struct Ticket
    const ticketid::TicketID
    timestamp::DateTime
    salt::Vector{UInt8}
    auth_code::Digest
    token::Digest
    admission::Union{Admission, Nothing}
end

Represents a ticket state for ticket with ticketid. timestamp represents time when the ticket have been issued by a recruiter client in authorization system of choice, for instance, Recruiters.jl; salt contains a random bytestring generated by the server from which the reccruiter client can derive a token as token(ticketid, salt, hmac). auth_code is a server generated authetification code for a given salt and current metadata. Lastly admission contains a certified member pseudonym which was authetificated by the user with token.

struct TicketID
    id::Vector{UInt8}
end

Represents a unique identifier for which a recruit tooken is issued. In case of necessity id can contain a full document, for instance, registration form, proof of identity and etc. In case a privacy is an issue the id can contain a unique identifier which can be matched to an identity in an external database.

struct TicketStatus ticketid::TicketID timestamp::DateTime admission::Union{Nothing, Admission} end

Represents a public state of a ticket. See ticket_status and isadmitted methods.

struct TokenRecruiter
    metadata::Ref{Vector{UInt8}} 
    tickets::Vector{Ticket}
    signer::Signer
    hmac::HMAC
end

Represents a state for token recruiter service. To initialize the service it's necessary to create a signer who can issue a valid admisssion certificates and a secret key with which a recruit client can exchange authorized messages. See also method generate(TokenRecruiter, spec).

Metadata is used as means to securelly deliver to the client most recent server specification.

Interface: select, hmac, hasher, key, id, tickets, in, set_metadata!, enlist!, admit!, isadmitted, ticket_status

in(ticketid::TicketID, recruiter::TokenRecruiter)::Bool

Return true if there already is a ticket with ticketid.

admit!(recruiter::TokenRecruiter, id::Pseudonym, ticketid::TicketID, auth_code::Digest)::Admission

Attempt to admit an identity pseudonym id for ticket ticketid with provided authorization code. This function retrieves a ticket with given ticketid and uses it's recorded token to check whether the request is binding. In the case of success an admnission certificate is formed with provided indenty pseudonym id and is signed by the recruter's private key. Otherwise when either of checks fail an error is raised. In the case ticket is already addmitted, returns previously stored admission.

approve(x::T, signer::Signer)::T

Cryptographically sign a document x::T and returns a signed document with the same type. To check whether a document is signed see issuer method.

auth(id::Pseudonym, hmac::HMAC)::Digest
auth(id::Pseudonym, token::Digest, hasher::Hash) = auth(id, HMAC(bytes(token), hasher))

Compute a hash authorization code for identity pseudonym using token as a key.

auth(ticketid::TicketID, time::DateTime, hmac::HMAC)::Digest

Compute a hash authorization code for ticketid at given time. The message needs to reach token recruiter within a 60 second window before it is obseleted.

auth(metadata::Vector{UInt8}, ticketid::TicketID, salt::Vector{UInt8}, hmac::HMAC)::Digest

Compute a hash authorization code for a metadata, salt from which a token is derived. Metadata can be configured to contain most recent server specification DemeSpec; ticketid takes session identifier role.

enlist!(recruiter::TokenRecruiter, ticketid::TicketID, timestamp::DateTime, ticket_auth_code::Digest)::Tuple{Vector{UInt8}, Vector{UInt8}, Digest}

Attempt to enlist a ticket with given ticketid authetificated by a recruit client at timestmap. This function checks the age of the request which need to be less than 60 seconds to be considered. Then the hash authorization code is checked after which a triplet of metadata, salt and reply_auth_code is returned. If either of theses checks fail an error is raised and needs to be dealt by the user. See a token method on how the token is derived.

generate(TokenRecruiter, spec::CryptoSpec)

Generate a new token recruiter with unique signer and athorization key.

hmac(x)::HMAC

Return HMAC authorizer from a given object.

isadmitted(ticketid::TicketID, recruiter::TokenRecruiter)

Check whether a ticket is already admitted. Returns false when either ticket is nonexistent or it's admission is nothing.

isadmitted(status::TicketStatus)

Check whether ticket is addmitted.

isbinding(id::Pseudonym, auth_code::Digest, token::Digest, hasher::Hash)

Check whether a request for a new identity pseudonym admission is authetificated. The token is delivered to a user by recruit client.

isbinding(ticketid::TicketID, timestamp::DateTime, auth_code::Digest, hmac::HMAC)

Check whether request for a new ticketid is authorized by recruit client. Note that freshness of the request is not considered within this method.

isbinding(metadata::Vector{UInt8}, ticketid::TicketID, salt::Vector{UInt8}, auth_code::Digest, hmac::HMAC)

Check whether a reply for a new ticketid is authorized by the recruit server.

select(Admission, ticketid::TicketID, recruiter::TokenRecruiter)::Union{Admission, Nothing}

Return admission for a ticket with given a given identity pseudonym from recruiter. If no ticket with given id is found OR ticket is not yet admitted returns nothing.

select(Admission, ticketid::TicketID, recruiter::TokenRecruiter)::Union{Admission, Nothing}

Return admission for a ticket with given ticketid from recruiter. If no ticket with given ticketid is found OR ticket is not yet admitted returns nothing.

select(T, predicate::Function, recruiter::TokenRecruiter)::Union{T, Nothing}

From a list of all recruiter tickets return T <: Union{Ticket, Admission} for which predicate is true. If none succeds returns nothing.

set_metadata!(recruiter::TokenRecruiter, metadata::Vector{UInt8})

Replace metadata for a recruiter. Note when data is replaced all unfinalized tokens need to be flushed.

ticket(x::Admission)

Return a TicketID which is admitted.

ticket_status(ticketid::TicketID, recruiter::TokenRecruiter)::Union{TicketStatus, Nothing}

Return a ticket status for a ticketid. In case ticket is not found return nothing.

tickets(recruiter::TokenRecruiter)::Vector{TicketID}

Return a list of registered ticket ids.

token(ticketid::TicketID, salt::Vector{UInt8}, hmac::HMAC)

Compute a recruit token for a given ticket with provided salt.

struct BraidChain
    members::Set{Pseudonym}
    ledger::Vector{Transaction}
    spec::DemeSpec
    generator::Generator
    tree::HistoryTree
    commit::Union{Commit{ChainState}, Nothing}
end

Represents a braidchain ledger with it's associated state. Can be instantitated with a demespec file using BraidChain(::DemeSpec) method.

Interface: push!, record!, state, length, list, select, roll, constituents, generator, commit, commit_index, ledger, leaf, root, ack_leaf, ack_root, members, commit!

struct ChainState
    index::Int
    root::Digest
    generator::Generator
    member_count::Int
end

Represents a chain state metadata which is sufficient for integrity checks.

Interface: index, root, generator

struct DemeSpec <: Transaction
    uuid::UUID
    title::String
    crypto::CryptoSpec
    guardian::Pseudonym
    recorder::Pseudonym
    recruiter::Pseudonym
    braider::Pseudonym
    proposer::Pseudonym 
    collector::Pseudonym
    timestamp::Union{DateTime, Nothing} = nothing
    signature::Union{Signature, Nothing} = nothing
end

Represents a deme configuration parameters issued by the guardian.

• uuid::UUID an unique random generated community identifier;
• title::String a community name with which deme is represented;
• crypto::CryptoSpec cryptographic parameters for the deme;
• guardian::Pseudonym an issuer for this demespec file. Has authorithy to set a roster:
  • recorder::Pseudonym an authorithy which has rights to add new transactions and is responsable for braidchain's ledger integrity. Issues Commit{ChainState};
  • recruiter::Pseudonym an authorithy which has rights to authorize new admissions to the deme. See Admission and Member;
  • braider::Pseudonym an authorithy which can do a legitimate braid jobs for other demes. See BraidWork;
  • proposer::Pseudonym an authorithy which has rights to issue a proposals for the braidchain. See Proposal;
  • collector::Pseudonym an authorithy which is repsonsable for collecting votes for proposals. This is also recorded in the proposal itself.
• timestamp::Union{DateTime, Nothing} time when signature is being issued;
• signature::Union{Signature, Nothing} a guardian issued signature.

struct Member <: Transaction
    admission::Admission
    generator::Generator
    pseudonym::Pseudonym
    approval::Union{Signature, Nothing} 
end

A new member certificate which rolls in (anouances) it's pseudonym at current generator signed with identity pseudonym certified with admission certificate issued by registrar. This two step process is necessary as a checkpoint in situations when braidchain ledger get's locked during a new member resgistration procedure.

Transaction

Represents an abstract record type which can be stored in the braidchain ledger.

push!(ledger::BraidChain, t::Transaction)

Add an element to the BraidChain bypassing transaction verification with the chain. This should only be used when the ledger is loaded from a trusted source like a local disk or when final root hash is validated with a trusted source.

leaf(ledger::BraidChain, N::Int)::Digest

Return a ledger's element digest at given index.

root(ledger::BraidChain[, N::Int])::Digest

Return a ledger root digest. In case when index is not given a current index is used.

ack_leaf(ledger::BraidChain, index::Int)::AckInclusion

Return a proof for record inclusion with respect to a current braidchain ledger history tree root.

ack_root(ledger::BraidChain, index::Int)

Return a proof for the ledger root at given index with respect to the current braidchain ledger history tree root.

approve(member::Member, signer::Signer)::Member

Sign a member certificate and return it with approval field filled.

commit!(ledger::BraidChain, signer::Signer)

Commit a current braidchain ledger state with a signer's issued cryptographic signature.

commit(ledger::BraidChain)

Return a current commit for a braichain.

constituents(ledger::BraidChain)::Set{Pseudonym}

Return all member identity pseudonyms.

generator(ledger[, index])

Return a generator at braidchain ledger row index. If index is omitted return the current state value.

generator(ledger::BraidChain)

Return a current relative generator for a braidchain ledger.

generator(member::Member)::Generator

Generator at which member tries to roll in the braidchain.

id(member::Member)::Pseudonym

Identity pseudonym for a member.

isbinding(admission::Admission, spec::DemeSpec)

Check whether issuer of admission is a recruiter set in spec.

isbinding(record::Transaction, ack::AckInclusion{ChainState}, crypto::CryptoSpec)

A generic method checking whether transaction is included in the braidchain.

issuer(member::Member)::Pseudonym

The identiy of registrar who signed admission.

list(T, ledger::BraidChain)::Vector{Tuple{Int, T}}

List braidchain elements with a given type together with their index.

members(ledger::BraidChain[, index::Int])::Set{Pseudonym}

Return a set of member pseudonyms at relative generator at braidchain ledger row index. If index is omitted return a current state value.

pseudonym(member::Member)::Pseudonym

Pseudonym for a member at the generator(member).

reset_tree!(ledger::BraidChain)

Recompute a chain tree hash.

roll(ledger::BraidChain)::Vector{Member}

Return all member certificates from a braidchain ledger.

select(T, predicate::Function, ledger::BraidChain)::Union{T, Nothing}

Return a first element from a ledger with a type T which satisfies a predicate.

state(ledger::BraidChain)

Return a current braidchain ledger state metadata.

ticket(member::Member)

Ticket for a member admission certificate.

struct BraidWork <: Transaction
    braid::Simulator
    consumer::DemeSpec
    producer::DemeSpec
    approval::Union{Seal, Nothing}
end

Represents a braider's computation which is supported with zero knowledge proof of shuffle and decryption assuring it's corectness stored in a braid field; consumer denotes a deme for which the braid is intended and producer denotes a deme where the braid is made. To assert latter the the braider signs the braidwork and stores that in the aproval field. See a braid method.

Interface: approve, verify, input_generator, input_members, output_generator, output_members

approve(braid::BraidWork, braider::Signer)

Sign a braidwork with a braider. Throws an error if braider is not in the producer demespec.

braid(generator::Generator, members::Union{Vector{Pseudonym}, Set{Pseudonym}}, consumer::DemeSpec, producer::DemeSpec; verifier = (g) -> ProtocolSpec(; g))

Selects a private exponent x at random and computes a new generator $g' = g^x$ and $member_i'=member_i^x$ returns the latter in a sorted order and provides a zero knowledge proof that all operations have been performed honestly. In partucular, not including/droping new member pseudonyms in the process. consumer attributes are necessary to interepret generator and pseudonym group elements with which the computation is performed.

By default a Verificatum compatable verifier is used for performing reencryption proof of shuffle

A verifier can be configured with a keyword argument. By default a Verificatum compatable verifier for a proof of shuffle is used.

input_generator(braid::BraidWork)

Return input generator of the braid.

input_members(braid::BraidWork)

Return input member pseudonyms of the braid at provided input generator. See input_generator

output_generator(braid::BraidWork)

Return output genertor of the braid.

output_members(braid::BraidWork)

Return output member pseudonyms of the braid at a resulting output generator. See output_generator

verify(braid::BraidWork, crypto::CryptoSpec)

Verifies a braid approval and then it's zero knowledge proofs. A crypto argument is provided to avoid downgrading attacks.

struct Ballot
    options::Vector{String}
end

Represents a simple ballot form for multiple choice question.

mutable struct BallotBox
    proposal::Proposal
    voters::Set{Pseudonym} # better than members
    collector::Pseudonym
    seed::Union{Digest, Nothing}
    crypto::CryptoSpec # on the other hand the inclusion of a vote should be binding enough as it includes proposal hash.
    queue::Vector{Vote}
    ledger::Vector{CastRecord}
    tree::HistoryTree
    commit::Union{Commit{BallotBoxState}, Nothing}
end

Represents a ballot box for a proposal. Contains proposal, a set of eligiable voters a collector who collects the votes and a seed which is selected at random when the voting starts. queue contains a list of valid votes which yet to be comitted to a ledger. A history tree is built on leafs of ledger's receipts (see a receipt method). A commit contains a collector seal on the current ballotbox state.

Interface: reset_tree!, generator, uuid, members, ledger, spine, index, seed, leaf, root, record, receipt, commit, tally, set_seed!, ack_leaf, ack_root, ack_cast, commit_index, commit_state, push!, state, validate, record!, commit!

struct BallotBoxState
    proposal::Digest
    seed::Digest
    index::Int
    root::Digest
    tally::Union{Nothing, Tally} 
    view::Union{Nothing, BitVector} # 
end

Represents a public ballot box state. Contains an immutable proposal and seed digest; a current ledger index, history tree root. When ellections end a tally is included in the state and a view is added listing all counted votes. Note that the view attribute is important for a client to know whether it's key have leaked and somone lese havbe superseeded it's vote by revoting.

struct CastAck
    receipt::CastReceipt
    ack::AckInclusion{BallotBoxState}
end

Represents a reply to a voter when a vote have been included in the ballotbox ledger. Contains a receipt and inlcusion acknowledgment. In future would also include a blind signature in the reply for a proof of participation. To receive this reply (with a blind signature in the future) a voter needs to send a vote which is concealed during ellections and thus tagging votes with blind signatures from reply to monitor revoting would be as hard as monitoring the submitted votes.

struct CastReceipt
    vote::Digest
    timestamp::DateTime
end

Represents a ballotbox ledger receipt which is hashed for a history tree. It's sole purpose is to assure voters that their vote is included in the ledger while also adding additional metadata as timestamp and. In contrast to CastRecord it does not reveal how voter have voted thus can be published during ellections without violating fairness property. For some situations it may be useful to extend the time until the votes are published as that can disincentivice coercers and bribers as they would not know whether their coerced vote have been superseeded in revoting. See receipt method for it's construction from a CastRecord.

Note that a blind signature could be commited as H(signature|H(vote)) to avoid tagging the use of pseudonym during ellections while collector could issue only a one blind signature for a voter. Note that members whoose private key could have been stolen could not obtain a valid signature for participation and that could be a good thing!

struct CastRecord
    vote::Vote
    timestamp::DateTime
end

Represents a ballotbox ledger record. Adds a timestamp when the vote have been recorded. In future, the record will also contain a blind signature with which members could prove to everyone that they had cast their vote without revealing the link to the vote.

struct PollingStation
    halls::Vector{BallotBox}
    crypto::CryptoSpec
end

Represents a pooling station which hosts ballotbox ledgers for every proposal collector manages.

Interface: add!, ballotbox, record!, commit!, commit, ack_leaf, ack_root, ack_cast, record, receipt, spine, ledger, tally, set_seed!

struct Proposal <: Transaction 
    uuid::UUID
    summary::String
    description::String
    ballot::Ballot
    open::DateTime
    closed::DateTime
    collector::Union{Pseudonym, Nothing} # 
    anchor::Union{ChainState, Nothing}
    approval::Union{Seal, Nothing} 
end

Represents a proposal for a ballot specyfing voting window, unique identifier, summary, description. Set's the collector identity which collects votes and issues vote inclusion receipts and is responsable for maintaining the ledger's integrity. The proposal also includes an anchor which sets a relative generator with which members vote anonymously. To be considered valid is signed by proposer authorizing vote to take place.

struct Selection
    option::Int
end

Represents voter's selection for a Ballot form.

struct Tally
    data::Vector{Int}
end

Represent a tally for Ballot form obtained aftert counting multiple voter's Selection forms.

struct Vote
    proposal::Digest
    seed::Digest
    selection::Selection
    seq::Int
    approval::Union{Seal, Nothing} 
end

Represents a vote for a proposal issued by a member. The proposal is stored as hash digest ensuring that member have voted on an untampered proposal. seed contains a randon string issued by collector at the moment when a vote starts to eliminate early voting / shortening a time at which coercers could act uppon. selection contians voter's preference;

seq is a serquence number counting a number of votes at which vote have been approved for a given proposal. It starts at 1 and is increased by one for every single signature made on the proposal. This is an important measure which allows to detect possible leakage of a member's private key. Also provides means for revoting ensuring that latest vote get's counted.

The vote is considered valid when it is sealed by a member's private key at a relative generator stored in the proposal.

length(ledger::BallotBox)

Return a total length of the ledger including uncommited records in the queue.

push!(ledger::BallotBox, record::CastRecord)

Push a record to the ledger bypassing integrity checks. Used when loading the ledger from a trusted source such as local disk or an archive with a signed root cheksum.

leaf(ledger::BallotBox, N::Int)::Digest

Return a record digest used to form a history tree.

root(ledger::BallotBox[, N::Int])::Digest

Calculate a root for history tree at given index N. If index is not specified returns the current value.

root(state::BallotBoxState)

Return a history tree root for a current ballotbox ledger state.

ack_cast(ledger::BallotBox, index::Int)::CastAck

Compute an acknowledgment for record inclusion at index.

ack_cast(station::PollingStation, uuid::UUID, N::Int)::CastAck

Return inclusion proof with receipt and current tree commit for a leaf at index N and ballotbox with uuid.

ack_leaf(ledger::BallotBox, index::Int)::AckInclusion

Compute an inclusion proof ::AckInclusion for record element at given index.

ack_leaf(station::PollingStation, uuid::UUID, N::Int)::AckInclusion

Return history tree inclusion proof for a tree leaf at index N in ballotbox with uuid.

ack_root(ledger::BallotBox, index::Int)::AckConsistency

Compute a history tree consistency proof at index.

ack_root(station::PollingStation, uuid::UUID, N::Int)::AckConsistency

Return history tree consitency proof tree root at index N in ballotbox with uuid.

add!(station::PollingStation, proposal::Proposal, voters::Set{Pseudonym}[, collector::Pseudonym])

Creates a new ballotbox for given proposal with provided member pseudonyms at a relative generator anchored in the proposal. A collector is optional and provided only when it differs from one specified in the proposal.

ballotbox(station::PollingStation, uuid::UUID)::BallotBox

Return a ballotbox ledger with a provided UUID. If none is found throws an error.

ballotbox(station::PollingStation, proposal::Digest)::BallotBox

Return a ballotbox which has proposal with provided digest.

commit!(ledger::BallotBox[, timestamp::DataTime], signer::Signer; with_tally=nothing)

Flushes ballotbox ledger's queue and creates a commit for a current ballotbox ledger state with provided timestamp and signer. A keyword argument with_tally has three values true|false to include or exclude a tally from a commited state and nothing which uses a previous commit preference.

commit!(station::PollingStation, uuid::UUID, collector::Signer; with_tally = nothing)

Select a ballotbox with provided uuid and commit it's state with collector.

commit(ledger::BallotBox)

Return a commit for the ballotbox ledger.

commit(ack::CastAck)

Return a commit from a CastAck.

commit(station::PollingStation, uuid::UUID)::Commit

Return a ballotbox commit.

commit_index(ledger::BallotBox)::Union{Index, Nothing}

Index at which commit is issued. See also length and index

commit_state(ledger::BallotBox)

Return a committed state for a ballotbox ledger.

generator(ledger::BallotBox)

Return a relative generator which members use to sign votes anchored by the proposal.

generator(proposal::Proposal)

A relative generator for at which memebers sign votes for this proposal.

index(state::BallotBoxState)

Return an index for a current ballotbox ledger state.

index(ledger::BallotBox)

Return the current index of the ledger. See also length.

isbinding(chain::BraidChain, state::ChainState)::Bool

Check that chain state is consistent with braidchain ledger.

isbinding(ack::CastAck, proposal::Proposal, hasher::Hash)::Bool

Check that acknowledgment is legitimate meaning that it is issued by a collector listed in the proposal.

isbinding(receipt::CastReceipt, ack::AckInclusion, hasher::Hash)::Bool

Check that cast receipt is binding to received inclusion acknowledgment.

isbinding(receipt::CastReceipt, vote::Vote, hasher::Hash)::Bool

Check that the receipt is bidning to a vote.

isbinding(vote::Vote, ack::CastAck, hasher)

Check whether acknowledgment is bound to the provided vote.

isbinding(vote::Vote, proposal::Proposal, crypto::CryptoSpec)

Check that the vote is bound to a proposal..

isconsistent(selection::Selection, ballot::Ballot)

Verifies that voter's selection is consistent with ballot form. For instance, whether selection is withing the range of ballot options.

issuer(proposal::Proposal)

Issuer of approval for the proposal.

ledger(ballotbox::BallotBox)::Vector{CastRecord}

Return all records from a ballotbox ledger.

ledger(station::PollingStation, uuid::UUID)::Vector{CastRecord}

Return a vector of records from a ballotbox with uuid.

members(ledger::BallotBox)

Return a list of member pseudonyms with which members authetificate their votes.

pseudonym(vote::Vote)::Union{Pseudonym, Nothing}

Return a pseudonym with which vote is sealed.

receipt(ledger::BallotBox, index::Int)::CastReceipt

Return a receipt for a ledger element.

receipt(record::CastRecord, hasher::Hash)::CastReceipt

Construct a CastReceipt from a CastRecord with a provided hasher function.

receipt(station::PollingStation, uuid::UUID, N::Int)::CastReceipt

Return a receipt for a record with index N at ballotbox with uuid.

record!(ledger::BallotBox, record::CastRecord)

Check the vote in the record for validity and include that in the ledger directly bypassing queue. This method is useful for replaying and debugging ballotbox ledger state changes. See also record!

record!(ledger::BallotBox, vote::Vote)

Check the vote for validity and pushes it to the queue. Returns an index N at which the vote will be recorded in the ledger. See also push!

record!(station::PollingStation, uuid::UUID, vote::Vote)::Int

Records a vote in a ballotbox with provided proposal UUID. Throws an error if a ballotbox can't be found.

record!(station::PollingStation, uuid::UUID, vote::Vote)::Int

Record a vote in a ballotbox found by proposal diggest stored in the vote. Throws an error if a ballotbox can't be found.

record(ledger::BallotBox, index::Int)::CastRecord

Return a ledger record at provided index.

record(station::PollingStation, uuid::UUID, N::Int)::CastRecord

Return a record with an index N at ballotbox with uuid.

reset_tree!(ledger::BallotBox)

Recompute history tree root and cache from the elements in the ledger. This is a useful for loading the ledger all at once.

seed(ledger::BallotBox)::Union{Digest, Nothing}

Return a random selected seed used in the voting.

set_seed!(ledger::BallotBox, seed::Digest)

Set's a seed of the ballotbox.

set_seed!(station::PollingStation, uuid::UUID, seed::Digest)

Sets a seed for a ballotbox with provided uuid.

spine(ledger::BallotBox)::Vector{Digest}

Return a history tree leaf vector.

spine(station::PollingStation, uuid::UUID)::Vector{Digest}

Return a leaf vector for a ballotbox with proposal uuid.

state(ledger::BallotBox; with_tally::Union{Nothing, Bool} = nothing)::BallotBoxState

Return a state metadata for ballotbox ledger.

state(proposal::Proposal)::ChainState

A braidchain ledger state which is used to anchor a relative generator for members.

tally(ballot::Ballot, ballots::AbstractVector{Selection})::Tally

Count ballots, check that they are filled consistently and return a final tally.

tally(ledger::BallotBox)

Compute a tally for a ballotbox ledger.

tally(station::PollingStation, uuid::UUID)

Compute a tally from ledger records a ballotbox with uuid.

uuid(ledger::BallotBox)

Return a UUID of the proposal.

uuid(proposal::Proposal)::UUID

UUID for a proposal. Issued by proposer and it's purpose is to croslink to an external system durring the proposal dreafting stage.

validate(ledger::BallotBox, vote::Vote)

Check that vote can be included in the ballotbox. Is well formed, signed by a member pseudonym and cryptographic signature is valid. Raises error if either of checks fail.

verify(ack::CastAck, crypto::CryptoSpec)::Bool

Verify the cast acknowledgment cryptographic signature.

vote(proposal::Proposal, seed::Digest, selection::Selection, member::Signer; seq = 1)

Issue a vote on a proposal and provided collector seed for a member's selection.