lightcone 0.5.2

Rust SDK for the Lightcone Protocol — unified native + WASM client
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
143
144
145
146
147

//! Privy sub-client — sign transactions, sign orders, export wallets.

use crate::client::LightconeClient;
use crate::error::SdkError;
use crate::http::RetryPolicy;

use super::{
    CancelTarget, ExportWalletRequest, ExportWalletResponse, PrivyOrderEnvelope,
    SignAndCancelAllRequest, SignAndCancelOrderRequest, SignAndSendOrderRequest,
    SignAndSendTxRequest, SignAndSendTxResponse,
};

/// Sub-client for Privy embedded wallet operations.
///
/// Embedded wallets are provisioned during login by passing
/// `use_embedded_wallet: true` to `login_with_message()`. This works on any
/// platform. All methods require an active authenticated session.
pub struct Privy<'a> {
    pub(crate) client: &'a LightconeClient,
}

impl<'a> Privy<'a> {
    /// Sign and send a Solana transaction via the user's Privy embedded wallet.
    pub async fn sign_and_send_tx(
        &self,
        wallet_id: &str,
        base64_tx: &str,
    ) -> Result<SignAndSendTxResponse, SdkError> {
        let url = format!("{}/api/privy/sign_and_send_tx", self.client.http.base_url());
        let req = SignAndSendTxRequest {
            wallet_id: wallet_id.to_string(),
            base64_tx: base64_tx.to_string(),
        };
        self.client.http.post(&url, &req, RetryPolicy::None).await
    }

    /// Sign an order hash via Privy and submit it to the exchange engine.
    ///
    /// The backend computes the order hash, signs via Privy, and submits
    /// the signed order internally -- no round-trip back to the client.
    pub async fn sign_and_send_order(
        &self,
        wallet_id: &str,
        order: PrivyOrderEnvelope,
    ) -> Result<serde_json::Value, SdkError> {
        let url = format!(
            "{}/api/privy/sign_and_send_order",
            self.client.http.base_url()
        );
        let req = SignAndSendOrderRequest {
            wallet_id: wallet_id.to_string(),
            order,
        };
        self.client.http.post(&url, &req, RetryPolicy::None).await
    }

    /// Cancel a limit order via Privy signing.
    ///
    /// The backend signs the cancel message using the embedded wallet
    /// and submits the cancellation to the exchange engine.
    pub async fn sign_and_cancel_order(
        &self,
        wallet_id: &str,
        order_hash: &str,
        maker: &str,
    ) -> Result<serde_json::Value, SdkError> {
        let url = format!(
            "{}/api/privy/sign_and_cancel_order",
            self.client.http.base_url()
        );
        let req = SignAndCancelOrderRequest {
            wallet_id: wallet_id.to_string(),
            maker: maker.to_string(),
            cancel: CancelTarget::Limit {
                order_hash: order_hash.to_string(),
            },
        };
        self.client.http.post(&url, &req, RetryPolicy::None).await
    }

    /// Cancel a trigger order via Privy signing.
    ///
    /// The backend signs the trigger order ID using the embedded wallet
    /// and submits the cancellation to the exchange engine.
    pub async fn sign_and_cancel_trigger_order(
        &self,
        wallet_id: &str,
        trigger_order_id: &str,
        maker: &str,
    ) -> Result<serde_json::Value, SdkError> {
        let url = format!(
            "{}/api/privy/sign_and_cancel_order",
            self.client.http.base_url()
        );
        let req = SignAndCancelOrderRequest {
            wallet_id: wallet_id.to_string(),
            maker: maker.to_string(),
            cancel: CancelTarget::Trigger {
                trigger_order_id: trigger_order_id.to_string(),
            },
        };
        self.client.http.post(&url, &req, RetryPolicy::None).await
    }

    /// Cancel all orders for a user via Privy signing.
    ///
    /// The backend signs the cancel-all message using the embedded wallet
    /// and submits the cancellation to the exchange engine.
    pub async fn sign_and_cancel_all_orders(
        &self,
        wallet_id: &str,
        user_pubkey: &str,
        orderbook_id: &str,
        timestamp: i64,
        salt: &str,
    ) -> Result<serde_json::Value, SdkError> {
        let url = format!(
            "{}/api/privy/sign_and_cancel_all_orders",
            self.client.http.base_url()
        );
        let req = SignAndCancelAllRequest {
            wallet_id: wallet_id.to_string(),
            user_pubkey: user_pubkey.to_string(),
            orderbook_id: orderbook_id.to_string(),
            timestamp,
            salt: salt.to_string(),
        };
        self.client.http.post(&url, &req, RetryPolicy::None).await
    }

    /// Export an embedded wallet's private key (HPKE encrypted).
    ///
    /// The response contains the encrypted private key that only the
    /// user's client can decrypt using their HPKE keypair.
    pub async fn export_wallet(
        &self,
        wallet_id: &str,
        decode_pubkey_base64: &str,
    ) -> Result<ExportWalletResponse, SdkError> {
        let url = format!("{}/api/privy/wallet/export", self.client.http.base_url());
        let req = ExportWalletRequest {
            wallet_id: wallet_id.to_string(),
            decode_pubkey_base64: decode_pubkey_base64.to_string(),
        };
        self.client.http.post(&url, &req, RetryPolicy::None).await
    }
}