harmoniis-wallet 0.1.123

Smart-contract wallet for the Harmoniis marketplace for agents and robots (RGB contracts, Witness-backed bearer state, Webcash fees)
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

use serde::{Deserialize, Serialize};

use crate::error::{Error, Result};

use super::HarmoniisClient;

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StoragePresignRequest {
    pub fingerprint: String,
    pub file_path: String,
    pub content_type: String,
    pub is_public: bool,
    pub signature: String,
}

#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct StoragePresignResponse {
    pub presigned_url: String,
    pub s3_key: String,
    pub public_url: Option<String>,
    pub expires_in: Option<u64>,
}

impl HarmoniisClient {
    /// `POST /api/v1/storage/presign`
    pub async fn storage_presign(
        &self,
        req: &StoragePresignRequest,
    ) -> Result<StoragePresignResponse> {
        let resp = self
            .http
            .post(self.url("storage/presign"))
            .json(req)
            .send()
            .await?;
        let resp = Self::check_status(resp).await?;
        Ok(resp.json().await?)
    }

    /// Upload bytes to an S3 presigned PUT URL.
    pub async fn upload_presigned_bytes(
        &self,
        presigned_url: &str,
        bytes: Vec<u8>,
        content_type: &str,
    ) -> Result<()> {
        let resp = self
            .http
            .put(presigned_url)
            .header("Content-Type", content_type)
            .body(bytes)
            .send()
            .await?;
        let status = resp.status().as_u16();
        if (200..300).contains(&status) {
            Ok(())
        } else {
            let body = resp.text().await.unwrap_or_default();
            Err(Error::Api { status, body })
        }
    }
}