mirror of
https://github.com/logos-co/nomos-specs.git
synced 2025-02-13 07:46:35 +00:00
115 lines
3.0 KiB
Python
115 lines
3.0 KiB
Python
from dataclasses import dataclass
|
|
|
|
from crypto import Field, Point, prf
|
|
|
|
from constraints import Constraint
|
|
|
|
|
|
@dataclass
|
|
class NoteCommitment:
|
|
cm: Field
|
|
blinding: Field
|
|
zero: Field
|
|
|
|
|
|
@dataclass
|
|
class Nullifier:
|
|
nf: bytes
|
|
|
|
|
|
def nf_pk(nf_sk) -> Field:
|
|
return prf("CL_NOTE_NF", nf_sk)
|
|
|
|
|
|
@dataclass(unsafe_hash=True)
|
|
class InnerNote:
|
|
value: Field
|
|
unit: str
|
|
birth_constraint: Constraint
|
|
death_constraints: list[Constraint]
|
|
state: Field
|
|
nonce: Field
|
|
rand: Field # source of randomness for note commitment
|
|
|
|
def r(self, index: int):
|
|
prf("CL_NOTE_COMM_RAND", self.rand, index)
|
|
|
|
def verify_value(self) -> bool:
|
|
return 0 <= self.value and value <= 2**64
|
|
|
|
@property
|
|
def fungibility_domain(self) -> Field:
|
|
"""The fungibility domain of this note"""
|
|
return crypto.prf(
|
|
"CL_NOTE_NULL", self.birth_constraint.hash(), *crypto.str_to_vec(unit)
|
|
)
|
|
|
|
def death_constraints_root(self) -> Field:
|
|
"""
|
|
Returns the merkle root over the set of death constraints
|
|
"""
|
|
return crypto.merkle_root(self.death_constraints)
|
|
|
|
|
|
@dataclass(unsafe_hash=True)
|
|
class PublicNote:
|
|
note: InnerNote
|
|
nf_pk: Field
|
|
|
|
def blinding(self, rand: Field) -> Field:
|
|
"""Blinding factor used in balance commitments"""
|
|
return prf("CL_NOTE_BAL_BLIND", rand, self.nonce, self.nf_pk)
|
|
|
|
def commit(self) -> Field:
|
|
# blinding factors between data elems ensure no information is leaked in merkle paths
|
|
return crypto.merkle_root(
|
|
self.note.r(0),
|
|
self.note.birth_constraint.hash(),
|
|
self.note.r(1),
|
|
self.note.death_constraints_root(),
|
|
self.note.r(2),
|
|
self.note.value,
|
|
self.note.r(3),
|
|
self.note.unit,
|
|
self.note.r(4),
|
|
self.note.state,
|
|
self.note.r(5),
|
|
self.note.nonce,
|
|
self.note.r(6),
|
|
self.nf_pk,
|
|
)
|
|
|
|
|
|
@dataclass(unsafe_hash=True)
|
|
class SecretNote:
|
|
note: InnerNote
|
|
nf_sk: Field
|
|
|
|
def to_public_note(self) -> PublicNote:
|
|
return PublicNote(note=self.note, nf_pk=nf_pk(self.nf_sk))
|
|
|
|
def nullifier(self):
|
|
"""
|
|
The nullifier that must be provided when spending this note along
|
|
with a proof that the nf_sk used to compute the nullifier corresponds
|
|
to the nf_pk in the public note commitment.
|
|
"""
|
|
return prf("NULLIFIER", self.nonce, self.nf_sk)
|
|
|
|
def balance(self, rand):
|
|
"""
|
|
Returns the pederson commitment to the notes value.
|
|
"""
|
|
return crypto.pederson_commit(
|
|
self.note.value, self.blinding(rand), self.note.fungibility_domain
|
|
)
|
|
|
|
def zero(self, rand):
|
|
"""
|
|
Returns the pederson commitment to zero using the same blinding as the balance
|
|
commitment.
|
|
"""
|
|
return crypto.pederson_commit(
|
|
0, self.blinding(rand), self.note.fungibility_domain
|
|
)
|