allsource-core 0.19.1

High-performance event store core built in Rust
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
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164

use crate::domain::entities::{Blockchain, Transaction, TransactionStatus};
use chrono::{DateTime, Utc};
use serde::{Deserialize, Serialize};
use uuid::Uuid;

/// DTO for initiating a payment transaction
#[derive(Debug, Deserialize)]
pub struct InitiatePaymentRequest {
    pub tenant_id: String,
    pub article_id: String,
    pub reader_wallet: String,
    pub tx_signature: String,
    pub blockchain: Option<BlockchainDto>,
}

/// DTO for payment initiation response
#[derive(Debug, Serialize)]
pub struct InitiatePaymentResponse {
    pub transaction: TransactionDto,
}

/// DTO for confirming a transaction
#[derive(Debug, Deserialize)]
pub struct ConfirmTransactionRequest {
    pub transaction_id: String,
}

/// DTO for transaction confirmation response
#[derive(Debug, Serialize)]
pub struct ConfirmTransactionResponse {
    pub transaction: TransactionDto,
    pub access_token: Option<String>,
}

/// DTO for refunding a transaction
#[derive(Debug, Deserialize)]
pub struct RefundTransactionRequest {
    pub transaction_id: String,
    pub refund_tx_signature: String,
    pub reason: Option<String>,
}

/// DTO for refund response
#[derive(Debug, Serialize)]
pub struct RefundTransactionResponse {
    pub transaction: TransactionDto,
}

/// DTO for listing transactions response
#[derive(Debug, Serialize)]
pub struct ListTransactionsResponse {
    pub transactions: Vec<TransactionDto>,
    pub count: usize,
}

/// DTO for blockchain type
#[derive(Debug, Clone, Copy, Default, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum BlockchainDto {
    #[default]
    Solana,
    Base,
    Polygon,
}

impl From<Blockchain> for BlockchainDto {
    fn from(blockchain: Blockchain) -> Self {
        match blockchain {
            Blockchain::Solana => BlockchainDto::Solana,
            Blockchain::Base => BlockchainDto::Base,
            Blockchain::Polygon => BlockchainDto::Polygon,
        }
    }
}

impl From<BlockchainDto> for Blockchain {
    fn from(dto: BlockchainDto) -> Self {
        match dto {
            BlockchainDto::Solana => Blockchain::Solana,
            BlockchainDto::Base => Blockchain::Base,
            BlockchainDto::Polygon => Blockchain::Polygon,
        }
    }
}

/// DTO for transaction status
#[derive(Debug, Clone, Copy, Serialize, Deserialize, PartialEq, Eq)]
#[serde(rename_all = "snake_case")]
pub enum TransactionStatusDto {
    Pending,
    Confirmed,
    Failed,
    Refunded,
    Disputed,
}

impl From<TransactionStatus> for TransactionStatusDto {
    fn from(status: TransactionStatus) -> Self {
        match status {
            TransactionStatus::Pending => TransactionStatusDto::Pending,
            TransactionStatus::Confirmed => TransactionStatusDto::Confirmed,
            TransactionStatus::Failed => TransactionStatusDto::Failed,
            TransactionStatus::Refunded => TransactionStatusDto::Refunded,
            TransactionStatus::Disputed => TransactionStatusDto::Disputed,
        }
    }
}

/// DTO for a transaction in responses
#[derive(Debug, Clone, Serialize)]
pub struct TransactionDto {
    pub id: Uuid,
    pub tenant_id: String,
    pub article_id: String,
    pub creator_id: String,
    pub reader_wallet: String,
    pub amount_cents: u64,
    pub platform_fee_cents: u64,
    pub creator_amount_cents: u64,
    pub blockchain: BlockchainDto,
    pub tx_signature: String,
    pub status: TransactionStatusDto,
    pub explorer_url: String,
    pub created_at: DateTime<Utc>,
    pub confirmed_at: Option<DateTime<Utc>>,
    pub refunded_at: Option<DateTime<Utc>>,
}

impl From<&Transaction> for TransactionDto {
    fn from(tx: &Transaction) -> Self {
        Self {
            id: tx.id().as_uuid(),
            tenant_id: tx.tenant_id().to_string(),
            article_id: tx.article_id().to_string(),
            creator_id: tx.creator_id().as_uuid().to_string(),
            reader_wallet: tx.reader_wallet().to_string(),
            amount_cents: tx.amount_cents(),
            platform_fee_cents: tx.platform_fee_cents(),
            creator_amount_cents: tx.creator_amount_cents(),
            blockchain: tx.blockchain().into(),
            tx_signature: tx.tx_signature().to_string(),
            status: tx.status().into(),
            explorer_url: tx.explorer_url(),
            created_at: tx.created_at(),
            confirmed_at: tx.confirmed_at(),
            refunded_at: tx.refunded_at(),
        }
    }
}

impl From<Transaction> for TransactionDto {
    fn from(tx: Transaction) -> Self {
        TransactionDto::from(&tx)
    }
}

/// DTO for revenue summary
#[derive(Debug, Serialize)]
pub struct RevenueSummaryDto {
    pub total_revenue_cents: u64,
    pub total_transactions: u64,
    pub total_platform_fees_cents: u64,
    pub total_creator_earnings_cents: u64,
}