borderless 0.1.2

SDK for borderless packages
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

use std::fmt::Display;

use borderless_hash::Hash256;
use borderless_id_types::{BlockIdentifier, TxIdentifier};
use serde::{Deserialize, Serialize};

use crate::{events::Sink, BorderlessId, ContractId};

/// Contract Environment
pub mod env;

pub mod ledger;

/// Maps a `BorderlessId` to a role in a smart-contract
#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
pub struct Role {
    /// Borderless-ID of the contract-participant that we assign the role to
    pub participant_id: BorderlessId,

    /// Alias of the role that is assigned
    ///
    /// Roles are defined as enums and usually represented as strings to the outside world.
    pub role: String,
}

/// Contract-Info
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct Info {
    pub contract_id: ContractId,
    pub participants: Vec<BorderlessId>,
    pub roles: Vec<Role>,
    pub sinks: Vec<Sink>,
}

/// Transaction-Context
///
/// Combines the [`TxIdentifier`] with the index of the transaction inside the block.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct TxCtx {
    pub tx_id: TxIdentifier,
    pub index: u64,
}

impl TxCtx {
    /// Creates a dummy `TxCtx` without meaning.
    ///
    /// Useful for testing.
    pub fn dummy() -> Self {
        Self {
            tx_id: TxIdentifier::new(999, 999, Hash256::empty()),
            index: 0,
        }
    }

    /// Use postcard to encode the `TxCtx`
    pub fn to_bytes(&self) -> Result<Vec<u8>, postcard::Error> {
        postcard::to_allocvec(&self)
    }

    /// Use postcard to decode the `TxCtx`
    pub fn from_bytes(bytes: &[u8]) -> Result<Self, postcard::Error> {
        postcard::from_bytes(bytes)
    }
}

impl Display for TxCtx {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(f, "Tx-ID: {}, index: {}", self.tx_id, self.index)
    }
}

/// Block-Context
///
/// Combines the [`BlockIdentifier`] with the timestamp of the block.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct BlockCtx {
    pub block_id: BlockIdentifier,
    pub timestamp: u64,
}

impl BlockCtx {
    /// Use postcard to encode the `BlockCtx`
    pub fn to_bytes(&self) -> Result<Vec<u8>, postcard::Error> {
        postcard::to_allocvec(&self)
    }

    /// Use postcard to decode the `BlockCtx`
    pub fn from_bytes(bytes: &[u8]) -> Result<Self, postcard::Error> {
        postcard::from_bytes(bytes)
    }
}

impl Display for BlockCtx {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        write!(
            f,
            "Block-ID: {}, timestamp: {}",
            self.block_id, self.timestamp
        )
    }
}