cargo-tangle 0.5.0-alpha.4

A command-line tool to create and deploy blueprints on Tangle Network
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

use alloy_primitives::{Address, Bytes, U256};
use blueprint_client_tangle::{
    TangleClient, TransactionResult, contracts::ITangleTypes, services::ServiceRequestParams,
};
use color_eyre::eyre::Result;

/// Submit a service request.
pub async fn request_service(
    client: &TangleClient,
    params: ServiceRequestParams,
) -> Result<(TransactionResult, u64)> {
    client.request_service(params).await.map_err(Into::into)
}

/// Approve a pending service request without optional capabilities.
///
/// `_staking_percent` is accepted for CLI back-compat but is now derived on-chain
/// from `securityCommitments[0].exposureBps` (or defaults to 100% when commitments
/// are empty). Callers that need to pin a specific exposure should go through
/// `approve_service_with_commitments`.
pub async fn approve_service(
    client: &TangleClient,
    request_id: u64,
    _staking_percent: u8,
) -> Result<TransactionResult> {
    client.approve_service(request_id).await.map_err(Into::into)
}

/// Approve a pending request with explicit security commitments.
pub async fn approve_service_with_commitments(
    client: &TangleClient,
    request_id: u64,
    commitments: Vec<ITangleTypes::AssetSecurityCommitment>,
) -> Result<TransactionResult> {
    client
        .approve_service_with_commitments(request_id, commitments)
        .await
        .map_err(Into::into)
}

/// Reject a pending service request.
pub async fn reject_service(client: &TangleClient, request_id: u64) -> Result<TransactionResult> {
    client.reject_service(request_id).await.map_err(Into::into)
}

/// Join a dynamic service.
pub async fn join_service(
    client: &TangleClient,
    service_id: u64,
    exposure_bps: u16,
) -> Result<TransactionResult> {
    client
        .join_service(service_id, exposure_bps)
        .await
        .map_err(Into::into)
}

/// Leave a dynamic service (legacy immediate exit path).
pub async fn leave_service(client: &TangleClient, service_id: u64) -> Result<TransactionResult> {
    client.leave_service(service_id).await.map_err(Into::into)
}

/// Convenience helper to build request parameters.
pub fn build_request_params(
    blueprint_id: u64,
    operators: Vec<Address>,
    operator_exposures: Option<Vec<u16>>,
    permitted_callers: Vec<Address>,
    ttl: u64,
    payment_token: Address,
    payment_amount: U256,
    config: Bytes,
) -> ServiceRequestParams {
    let mut params = ServiceRequestParams::new(
        blueprint_id,
        operators,
        permitted_callers,
        config,
        ttl,
        payment_token,
        payment_amount,
    );
    params.operator_exposures = operator_exposures;
    params
}

/// Attach security requirements to a request parameter set.
pub fn with_security_requirements(
    mut params: ServiceRequestParams,
    requirements: Vec<ITangleTypes::AssetSecurityRequirement>,
) -> ServiceRequestParams {
    params.security_requirements = requirements;
    params
}