derec-library 0.0.1-alpha.8

Rust SDK for the DeRec protocol, including native and WebAssembly bindings.
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

// SPDX-License-Identifier: Apache-2.0
// Copyright (c) 2026 DeRec Alliance. All rights reserved.

use crate::{
    primitives::verification::request,
    wasm::{
        primitives::{
            helpers::{parse_optional_transport_protocol, parse_shared_key, to_js},
            pairing::TransportProtocol,
            types::Timestamp,
        },
        ts_bindings_utils::js_error_from_lib,
    },
};
use serde::{Deserialize, Serialize};
use wasm_bindgen::prelude::*;

#[derive(Serialize, Deserialize, Clone)]
pub struct VerifyShareRequestMessage {
    pub secret_id: u64,
    pub version: u32,
    pub nonce: u64,
    pub timestamp: Option<Timestamp>,
    /// Optional ephemeral response endpoint. See `replyTo` on the request
    /// proto for the routing semantics.
    pub reply_to: Option<TransportProtocol>,
}

impl From<derec_proto::VerifyShareRequestMessage> for VerifyShareRequestMessage {
    fn from(value: derec_proto::VerifyShareRequestMessage) -> Self {
        Self {
            secret_id: value.secret_id,
            version: value.version,
            nonce: value.nonce,
            timestamp: value.timestamp.map(Into::into),
            reply_to: value.reply_to.map(Into::into),
        }
    }
}

impl From<VerifyShareRequestMessage> for derec_proto::VerifyShareRequestMessage {
    fn from(value: VerifyShareRequestMessage) -> Self {
        Self {
            secret_id: value.secret_id,
            version: value.version,
            nonce: value.nonce,
            timestamp: value.timestamp.map(Into::into),
            reply_to: value.reply_to.map(Into::into),
        }
    }
}

#[derive(Serialize, Deserialize)]
pub struct ProduceResult {
    #[serde(with = "serde_bytes")]
    pub envelope: Vec<u8>,
}

#[derive(Serialize, Deserialize)]
pub struct ExtractResult {
    pub request: VerifyShareRequestMessage,
}

#[wasm_bindgen(js_name = "verification_request_produce")]
pub fn produce(
    channel_id: u64,
    secret_id: u64,
    version: u32,
    shared_key: &[u8],
    // Optional `TransportProtocol`. Pass null/undefined for no override.
    reply_to: JsValue,
) -> Result<JsValue, JsValue> {
    let shared_key = parse_shared_key(shared_key)?;
    let reply_to_proto = parse_optional_transport_protocol(reply_to)?;
    let result =
        request::produce(channel_id.into(), secret_id, version, &shared_key, reply_to_proto)
            .map_err(js_error_from_lib)?;
    to_js(&ProduceResult {
        envelope: result.envelope,
    })
}

#[wasm_bindgen(js_name = "verification_request_extract")]
pub fn extract(envelope_bytes: &[u8], shared_key: &[u8]) -> Result<JsValue, JsValue> {
    let shared_key = parse_shared_key(shared_key)?;
    let result = request::extract(envelope_bytes, &shared_key).map_err(js_error_from_lib)?;
    to_js(&ExtractResult {
        request: result.request.into(),
    })
}