aspens 0.7.0

Aspens crosschain trading SDK
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

//! FCE action results, pinned against `tee-node@v0.0.22`
//! `pkg/types/actions.go`.
//!
//! `ActionResult.Data` is go-ethereum `hexutil.Bytes` — i.e. `0x`-hex, NOT
//! base64. Its decoded bytes are `json.Marshal(<arborter response>)`, so
//! decoding is: hex → bytes → JSON.

use serde::{Deserialize, Serialize};

use super::wire::{hex32, hexbytes};

/// Poll response wrapper: `GET /action/result/{id}` returns this.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ActionResponse {
    pub result: ActionResult,
    #[serde(with = "hexbytes", default)]
    pub signature: Vec<u8>,
    #[serde(rename = "proxySignature", with = "hexbytes", default)]
    pub proxy_signature: Vec<u8>,
}

/// The extension's result for one action.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ActionResult {
    #[serde(with = "hex32")]
    pub id: [u8; 32],
    #[serde(rename = "submissionTag")]
    pub submission_tag: String,
    /// 1 = ok, 0 = error.
    pub status: u8,
    pub log: String,
    #[serde(rename = "opType", with = "hex32")]
    pub op_type: [u8; 32],
    #[serde(rename = "opCommand", with = "hex32")]
    pub op_command: [u8; 32],
    pub version: String,
    /// `0x`-hex of `json.Marshal(<arborter response>)` (present on status=1).
    #[serde(with = "hexbytes", default)]
    pub data: Vec<u8>,
}

impl ActionResult {
    /// True when the action succeeded (`status == 1`).
    pub fn ok(&self) -> bool {
        self.status == 1
    }

    /// Decode `data` (already hex-decoded to raw bytes) as a typed response.
    /// Errors if `data` is empty or not the expected JSON.
    pub fn decode<T: serde::de::DeserializeOwned>(&self) -> eyre::Result<T> {
        if self.data.is_empty() {
            eyre::bail!(
                "action result has no data (status={}, log={})",
                self.status,
                self.log
            );
        }
        Ok(serde_json::from_slice(&self.data)?)
    }

    /// `data` as raw JSON bytes (the `json.Marshal` of the arborter response).
    pub fn data_bytes(&self) -> &[u8] {
        &self.data
    }
}

#[cfg(test)]
mod tests {
    use super::*;

    // A result envelope as the proxy returns it — data is 0x-hex of the JSON.
    #[test]
    fn decodes_hex_data_to_json() {
        // json = {"orderId":7,"orderInBook":true,"fills":0}
        let json = br#"{"orderId":7,"orderInBook":true,"fills":0}"#;
        let envelope = serde_json::json!({
            "result": {
                "id": "0x".to_string() + &"00".repeat(32),
                "submissionTag": "submit",
                "status": 1u8,
                "log": "ok",
                "opType": "0x".to_string() + &"00".repeat(32),
                "opCommand": "0x".to_string() + &"00".repeat(32),
                "version": "0.1.0",
                "data": format!("0x{}", hex::encode(json)),
            },
            "signature": "0x",
            "proxySignature": "0x",
        });
        let resp: ActionResponse = serde_json::from_value(envelope).unwrap();
        assert!(resp.result.ok());
        let po: super::super::payloads::PlaceOrderResponse = resp.result.decode().unwrap();
        assert_eq!(po.order_id, 7);
        assert!(po.order_in_book);
    }

    #[test]
    fn failed_status_surfaces_log() {
        let envelope = serde_json::json!({
            "result": {
                "id": "0x".to_string() + &"00".repeat(32),
                "submissionTag": "submit",
                "status": 0u8,
                "log": "error: unsupported direct command",
                "opType": "0x".to_string() + &"00".repeat(32),
                "opCommand": "0x".to_string() + &"00".repeat(32),
                "version": "0.1.0",
                "data": "0x",
            }
        });
        let resp: ActionResponse = serde_json::from_value(envelope).unwrap();
        assert!(!resp.result.ok());
        assert!(resp.result.decode::<serde_json::Value>().is_err());
    }
}