arcium-anchor 0.4.0

A helper crate for integrating Arcium into Solana programs.
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

enum ComputationMatchingError {
    AccountLenNotMultipleOf32(usize),
    AccountLenTooBig(usize),
    ArgumentMismatch(usize, Parameter),
    NotEnoughParams(usize),
    NotEnoughArguments,
}

impl ComputationMatchingError {
    #[allow(dead_code)]
    fn emit_solana_msg(&self, arguments: &[Argument]) {
        match self {
            ComputationMatchingError::AccountLenNotMultipleOf32(arg_id) => {
                msg!(
                    "Invalid argument : account {:?} len is not a multiple of 32",
                    &arguments[*arg_id],
                );
            }
            ComputationMatchingError::AccountLenTooBig(arg_id) => {
                msg!(
                    "Invalid argument : account {:?} is bigger than the circuit size",
                    &arguments[*arg_id],
                );
            }
            ComputationMatchingError::ArgumentMismatch(arg_id, param) => {
                msg!("Invalid argument {:?} for parameter {:?}", &arguments[*arg_id], param);
            }
            ComputationMatchingError::NotEnoughParams(arg_id) => {
                msg!("Invalid argument : no parameter matching for {:?}", &arguments[*arg_id]);
            }
            ComputationMatchingError::NotEnoughArguments => {
                msg!("Invalid arguments : not enough arguments");
            }
        }
    }
    #[allow(dead_code)]
    const fn const_panic(&self) {
        match self {
            ComputationMatchingError::AccountLenNotMultipleOf32(_) => {
                panic!("Invalid argument : account len is not a multiple of 32");
            }
            ComputationMatchingError::AccountLenTooBig(_) => {
                panic!("Invalid argument : account is bigger than the circuit size");
            }
            ComputationMatchingError::ArgumentMismatch(_, _) => {
                panic!("Invalid argument, mismatch with parameter");
            }
            ComputationMatchingError::NotEnoughParams(_) => {
                panic!("Invalid argument : not enough params");
            }
            ComputationMatchingError::NotEnoughArguments => {
                panic!("Invalid arguments : not enough arguments");
            }
        }
    }
}
const fn arg_match_param(arg: &Argument, param: &Parameter) -> bool {
    match arg {
        Argument::ManticoreAlgo(_) => matches!(param, Parameter::ManticoreAlgo),
        Argument::InputDataset(_) => matches!(param, Parameter::InputDataset),
        Argument::PlaintextBool(_) => matches!(param, Parameter::PlaintextBool),
        Argument::PlaintextU8(_) => matches!(param, Parameter::PlaintextU8),
        Argument::PlaintextU16(_) => matches!(param, Parameter::PlaintextU16),
        Argument::PlaintextU32(_) => matches!(param, Parameter::PlaintextU32),
        Argument::PlaintextU64(_) => matches!(param, Parameter::PlaintextU64),
        Argument::PlaintextU128(_) => matches!(param, Parameter::PlaintextU128),
        Argument::PlaintextFloat(_) => matches!(param, Parameter::PlaintextFloat),
        Argument::EncryptedBool(_) => matches!(param, Parameter::Ciphertext),
        Argument::EncryptedU8(_) => matches!(param, Parameter::Ciphertext),
        Argument::EncryptedU16(_) => matches!(param, Parameter::Ciphertext),
        Argument::EncryptedU32(_) => matches!(param, Parameter::Ciphertext),
        Argument::EncryptedU64(_) => matches!(param, Parameter::Ciphertext),
        Argument::EncryptedU128(_) => matches!(param, Parameter::Ciphertext),
        Argument::EncryptedFloat(_) => matches!(param, Parameter::Ciphertext),
        Argument::ArcisPubkey(_) => matches!(param, Parameter::ArcisPubkey),
        Argument::ArcisSignature(_) => {
            panic!("ArcisSignature are not supposed to reach this function.")
        }
        Argument::Account(_, _, _) => {
            panic!("Accounts are not supposed to reach this function.")
        }
    }
}
const fn args_match_params(arguments: &[Argument], parameters: &[Parameter]) -> core::result::Result<(), ComputationMatchingError> {
    // Validate the arguments match the parameters
    let mut param_idx = 0;
    let mut arg_idx = 0;
    while arg_idx < arguments.len() {
        let arg = &arguments[arg_idx];
        if let Argument::Account(_, _, arg_len) = arg {
            if arg_len.rem_euclid(32) != 0 {
                return Err(ComputationMatchingError::AccountLenNotMultipleOf32(arg_idx));
            }
            param_idx += (*arg_len as usize) / 32;
            // >= is ok, the account finishes right at the end
            if param_idx > parameters.len() {
                return Err(ComputationMatchingError::AccountLenTooBig(arg_idx));
            }
        } else if let Argument::ArcisSignature(..) = arg {
            let mut sig_to_64 = 0u8;
            while sig_to_64 < 64 {
                sig_to_64 += 1;
                if param_idx >= parameters.len() {
                    return Err(ComputationMatchingError::NotEnoughParams(arg_idx));
                }
                let param = &parameters[param_idx];
                if !matches!(param, Parameter::PlaintextU8) {
                    return Err(ComputationMatchingError::ArgumentMismatch(arg_idx, *param));
                }
                param_idx += 1;
            }
        } else {
            if param_idx >= parameters.len() {
                return Err(ComputationMatchingError::NotEnoughParams(arg_idx));
            }
            let param = &parameters[param_idx];
            if !arg_match_param(arg, param) {
                return Err(ComputationMatchingError::ArgumentMismatch(arg_idx, *param));
            }
            param_idx += 1;
        }
        arg_idx += 1;
    }
    if param_idx < parameters.len() {
        return Err(ComputationMatchingError::NotEnoughArguments)
    }

    Ok(())
}