daml-grpc 0.3.0

Daml Ledger GRPC API
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

use std::io;
use tonic::codegen::http;

/// A Daml ledger error.
#[derive(Debug, thiserror::Error)]
pub enum DamlError {
    #[error("timeout error: {0}")]
    TimeoutError(#[source] Box<DamlError>),
    #[error(transparent)]
    GrpcTransportError(#[from] tonic::transport::Error),
    #[error(transparent)]
    GrpcStatusError(tonic::Status),
    #[error(transparent)]
    GrpcPermissionError(tonic::Status),
    #[error(transparent)]
    InvalidUriError(#[from] http::uri::InvalidUri),
    #[error(transparent)]
    StdError(#[from] io::Error),
    #[error("unexpected type, expected {0} but found {1}")]
    UnexpectedType(String, String),
    #[error("unknown field {0}")]
    UnknownField(String),
    #[error("list index {0} out of range")]
    ListIndexOutOfRange(usize),
    #[error("expected optional value is None")]
    MissingRequiredField,
    #[error("unexpected variant constructor, expected {0} but found {1}")]
    UnexpectedVariant(String, String),
    #[error("{0}")]
    Other(String),
    #[error("failed conversion: {0}")]
    FailedConversion(String),
    #[error("insufficient parties")]
    InsufficientParties,
}

impl DamlError {
    pub fn new_failed_conversion(msg: impl Into<String>) -> Self {
        DamlError::FailedConversion(msg.into())
    }

    pub fn new_timeout_error(inner: DamlError) -> Self {
        DamlError::TimeoutError(Box::new(inner))
    }
}

/// `tonic::Status` maps to one of two variants depending on its code —
/// permission-vs-authn errors get their own bucket so downstream code
/// can pattern-match on it without inspecting the status code.
impl From<tonic::Status> for DamlError {
    fn from(e: tonic::Status) -> Self {
        match e.code() {
            tonic::Code::PermissionDenied | tonic::Code::Unauthenticated => DamlError::GrpcPermissionError(e),
            _ => DamlError::GrpcStatusError(e),
        }
    }
}

impl From<&str> for DamlError {
    fn from(e: &str) -> Self {
        DamlError::Other(e.to_owned())
    }
}

impl From<bigdecimal::ParseBigDecimalError> for DamlError {
    fn from(e: bigdecimal::ParseBigDecimalError) -> Self {
        DamlError::FailedConversion(e.to_string())
    }
}

/// A Daml ledger result.
pub type DamlResult<T> = ::std::result::Result<T, DamlError>;