dusk-cdf 0.5.0

PLONK debugger CDF implementation
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142

use std::io;

use crate::{
    Config, DecodableElement, DecodedSource, DecoderContext, Element, EncodableElement,
    EncodableSource, EncoderContext, Polynomial, Preamble,
};

/// Constraint representation that can be encoded into a CDF file
#[derive(Debug, Default, Clone, PartialEq, Eq, PartialOrd, Ord, Hash)]
pub struct EncodableConstraint {
    id: usize,
    polynomial: Polynomial,
    source: EncodableSource,
}

impl EncodableConstraint {
    /// Create a new encodable constraint instance
    pub const fn new(id: usize, polynomial: Polynomial, source: EncodableSource) -> Self {
        Self {
            id,
            polynomial,
            source,
        }
    }

    /// Id of the constraint in the constraint system
    pub const fn id(&self) -> usize {
        self.id
    }

    /// Polynomial representation
    pub const fn polynomial(&self) -> &Polynomial {
        &self.polynomial
    }

    /// Source reference to be encoded
    pub const fn source(&self) -> &EncodableSource {
        &self.source
    }
}

impl Element for EncodableConstraint {
    fn len(ctx: &Config) -> usize {
        usize::len(ctx) + Polynomial::len(ctx) + EncodableSource::len(ctx)
    }

    fn validate(&self, preamble: &Preamble) -> io::Result<()> {
        self.id.validate(preamble)?;
        self.polynomial.validate(preamble)?;
        self.source.validate(preamble)?;

        Ok(())
    }
}

impl EncodableElement for EncodableConstraint {
    fn to_buffer(&self, ctx: &mut EncoderContext, buf: &mut [u8]) {
        let buf = self.id.encode(ctx, buf);
        let buf = self.polynomial.encode(ctx, buf);
        let _ = self.source.encode(ctx, buf);
    }
}

/// Decoded constraint from a CDF file
#[derive(Debug, Default, Clone, PartialEq, Eq, Hash)]
pub struct Constraint<'a> {
    id: usize,
    polynomial: Polynomial,
    source: DecodedSource<'a>,
}

impl<'a> Constraint<'a> {
    /// Constructor private to the crate because constraint is suposed to be created from the cdf
    /// file
    pub(crate) const fn _new(id: usize, polynomial: Polynomial, source: DecodedSource<'a>) -> Self {
        Self {
            id,
            polynomial,
            source,
        }
    }

    /// Id of the constraint in the constraint system
    pub const fn id(&self) -> usize {
        self.id
    }

    /// Polynomial representation
    pub const fn polynomial(&self) -> &Polynomial {
        &self.polynomial
    }

    /// Line of the source code
    pub const fn line(&self) -> u64 {
        self.source.line
    }

    /// Column of the source code
    pub const fn col(&self) -> u64 {
        self.source.col
    }

    /// Source file name
    pub const fn name(&self) -> &str {
        self.source.name
    }

    /// Source code contents
    pub const fn contents(&self) -> &str {
        self.source.contents
    }
}

impl<'a> Element for Constraint<'a> {
    fn len(ctx: &Config) -> usize {
        usize::len(ctx) + Polynomial::len(ctx) + DecodedSource::len(ctx)
    }

    fn validate(&self, preamble: &Preamble) -> io::Result<()> {
        self.id.validate(preamble)?;
        self.polynomial.validate(preamble)?;
        self.source.validate(preamble)?;

        Ok(())
    }
}

impl<'a> DecodableElement for Constraint<'a> {
    fn try_from_buffer_in_place<'x, 'b>(
        &'x mut self,
        ctx: &DecoderContext<'x>,
        buf: &'b [u8],
    ) -> io::Result<()> {
        Self::validate_buffer(ctx.config(), buf)?;

        let buf = self.id.try_decode_in_place(ctx, buf)?;
        let buf = self.polynomial.try_decode_in_place(ctx, buf)?;
        let _ = self.source.try_decode_in_place(ctx, buf)?;

        Ok(())
    }
}