Struct SingleUseClaim

pub struct SingleUseClaim<Context>
{ /* private fields */ }

Private right to perform an action.

A private state variable type that represents a right each user can exercise at most once.

Because it is owned, you must wrap a SingleUseClaim inside an crate::state_vars::owned::Owned state variable when using it in storage.

Example

The right to vote at most once can be implemented using SingleUseClaim as a primitive.

#[derive(Serialize, Deserialize)]
struct ElectionId { id: Field }

#[storage]
struct Storage<Context> {
    // election => candidate => number of votes
    tally: Map<ElectionId, Map<Field, PublicMutable<Field, Context>, Context>, Context>,
    // track right to vote at most once per election
    vote_claims: Map<ElectionId, Owned<SingleUseClaim<Context>, Context>, Context>,
}

#[external("private")]
fn cast_vote(election_id: ElectionId, candidate: Field) {
    let voter = self.msg_sender();

    // `claim` will only succeed if `voter` hasn't already claimed for this `election_id` before.
    self.storage.vote_claims.at(election_id).at(voter).claim();

    // Now that we checked that the voter is entitled to vote,
    // we can enqueue the corresponding public effect
    self.enqueue_self.add_to_tally_public(election_id, candidate);
}

For more details on what owned means, see the documentation for the OwnedStateVariable trait.

Cost

Exercising a claim (via the SingleUseClaim::claim function) emits one nullifier.

Privacy considerations

The SingleUseClaim::claim function emits a public nullifier per owner: it's fully private, hidden behind the owner's app-siloed nullifier hiding key (aka nhk).

Public effects you emit alongside a claim (e.g. a public function call to update a tally) may still let observers infer who likely exercised the claim, so consider that when designing flows.