Method sign

wasm/src/programs/request.rs:234–293

(
        private_key: PrivateKey,
        program_id: String,
        function_name: String,
        inputs: Array,
        input_types: Array,
        root_tvk: Option<Field>,
        program_checks

    /// @param {boolean} is_dynamic Flag to indicate if this is a dynamic call.
    #[allow(clippy::too_many_arguments)]
    pub fn sign(
        private_key: PrivateKey,
        program_id: String,
        function_name: String,
        inputs: Array,
        input_types: Array,
        root_tvk: Option<Field>,
        program_checksum: Option<Field>,
        is_root: bool,
        is_dynamic: bool,
    ) -> Result<ExecutionRequest, String> {
        // Convert the ProgramID and function name to their native objects.
        let program_id = ProgramIDNative::from_str(&program_id).map_err(|e| e.to_string())?;
        let function_name = IdentifierNative::from_str(&function_name).map_err(|e| e.to_string())?;

        // Ensure the inputs are valid Aleo types.
        let inputs = inputs
            .iter()
            .enumerate()
            .map(|(i, input)| {
                let s = input.as_string().ok_or_else(|| format!("Input {i} is not a string"))?;
                ValueNative::from_str(&s).map_err(|e| format!("Failed to deserialize input {i} as value '{s}' - please check the input at position {i} and try again: {e}"))
            })
            .collect::<Result<Vec<ValueNative>, String>>()?;

        // Ensure the input types specified match the types of the specified inputs.
        let input_types = input_types
            .iter()
            .enumerate()
            .map(|(i, input_type)| {
                let s = input_type.as_string().ok_or_else(|| format!("Input type {i} is not a string"))?;
                ValueTypeNative::from_str(&s).map_err(|e| format!("Failed to deserialize input {i} as input type '{s}' - please check the input at position {i} and try again: {e}"))
            })
            .collect::<Result<Vec<ValueTypeNative>, String>>()?;

        // Get the root tvk if it was specified.
        let root_tvk = root_tvk.map(FieldNative::from);
        let program_checksum = program_checksum.map(FieldNative::from);

        // Generate an RNG for the function from system entropy.
        let mut rng = rand::rng();

        // Generate the signature over the (program_id, function, input, and private_key) tuple.
        let request = RequestNative::sign(
            &private_key,
            program_id,
            function_name,
            inputs.into_iter(),
            &input_types,
            root_tvk,
            is_root,
            program_checksum,
            is_dynamic,
            &mut rng,
        )
        .map_err(|e| e.to_string())?;

        // Return the execution request.