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

use core::ops::{Add, Sub};
use ibc_relayer_types::applications::transfer::amount::Amount;
use ibc_relayer_types::applications::transfer::coin::{Coin, RawCoin};

use crate::error::Error;
use crate::ibc::denom::{derive_ibc_denom, Denom, TaggedDenom, TaggedDenomRef};
use crate::types::id::{TaggedChannelIdRef, TaggedPortIdRef};
use crate::types::tagged::MonoTagged;

pub type Token = Coin<Denom>;

pub type TaggedToken<Chain> = MonoTagged<Chain, Token>;
pub type TaggedTokenRef<'a, Chain> = MonoTagged<Chain, &'a Token>;

pub trait TaggedTokenExt<Chain> {
    fn denom(&self) -> TaggedDenomRef<Chain>;

    fn amount(&self) -> Amount;

    fn as_coin(&self) -> RawCoin;

    fn transfer<Counterparty>(
        &self,
        port_id: &TaggedPortIdRef<Counterparty, Chain>,
        channel_id: &TaggedChannelIdRef<Counterparty, Chain>,
    ) -> Result<TaggedToken<Counterparty>, Error>;
}

pub trait TaggedDenomExt<Chain> {
    fn with_amount(&self, amount: impl Into<Amount>) -> TaggedToken<Chain>;
}

impl<Chain> TaggedTokenExt<Chain> for TaggedToken<Chain> {
    fn denom(&self) -> TaggedDenomRef<Chain> {
        self.map_ref(|t| &t.denom)
    }

    fn amount(&self) -> Amount {
        self.value().amount
    }

    fn as_coin(&self) -> RawCoin {
        RawCoin::new(self.value().denom.to_string(), self.value().amount)
    }

    fn transfer<Counterparty>(
        &self,
        port_id: &TaggedPortIdRef<Counterparty, Chain>,
        channel_id: &TaggedChannelIdRef<Counterparty, Chain>,
    ) -> Result<TaggedToken<Counterparty>, Error> {
        let denom = derive_ibc_denom(port_id, channel_id, &self.denom())?;

        Ok(denom.with_amount(self.value().amount))
    }
}

impl<'a, Chain> TaggedTokenExt<Chain> for TaggedTokenRef<'a, Chain> {
    fn denom(&self) -> TaggedDenomRef<Chain> {
        self.map_ref(|t| &t.denom)
    }

    fn amount(&self) -> Amount {
        self.value().amount
    }

    fn as_coin(&self) -> RawCoin {
        RawCoin::new(self.value().denom.to_string(), self.value().amount)
    }

    fn transfer<Counterparty>(
        &self,
        port_id: &TaggedPortIdRef<Counterparty, Chain>,
        channel_id: &TaggedChannelIdRef<Counterparty, Chain>,
    ) -> Result<TaggedToken<Counterparty>, Error> {
        let denom = derive_ibc_denom(port_id, channel_id, &self.denom())?;

        Ok(denom.with_amount(self.value().amount))
    }
}

impl<Chain> TaggedDenomExt<Chain> for TaggedDenom<Chain> {
    fn with_amount(&self, amount: impl Into<Amount>) -> TaggedToken<Chain> {
        self.map(|denom| Token {
            denom: denom.clone(),
            amount: amount.into(),
        })
    }
}

impl<'a, Chain> TaggedDenomExt<Chain> for TaggedDenomRef<'a, Chain> {
    fn with_amount(&self, amount: impl Into<Amount>) -> TaggedToken<Chain> {
        self.map(|denom| Token {
            denom: (*denom).clone(),
            amount: amount.into(),
        })
    }
}

impl<Chain, I: Into<Amount>> Add<I> for MonoTagged<Chain, Token> {
    type Output = Self;

    fn add(self, amount: I) -> Self {
        self.map_into(|t| t.checked_add(amount))
            .transpose()
            .unwrap()
    }
}

impl<Chain, I: Into<Amount>> Sub<I> for MonoTagged<Chain, Token> {
    type Output = Self;

    fn sub(self, amount: I) -> Self {
        self.map_into(|t| t.checked_sub(amount))
            .transpose()
            .unwrap()
    }
}