stdtx 0.7.0

Extensible schema-driven Cosmos StdTx builder and Amino serializer
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

//! StdTx Amino types

use super::{Msg, TypeName};
use crate::Signature;
use prost_amino::{encode_length_delimiter, Message};
use prost_amino_derive::Message;
use serde::{de, ser, Deserialize, Serialize};

/// `StdTx` Amino type
#[derive(Clone, Message)]
pub struct StdTx {
    /// Messages in transaction
    #[prost_amino(bytes, repeated, tag = "1")]
    pub msg: Vec<Vec<u8>>,

    /// Feeds to be paid
    #[prost_amino(message)]
    pub fee: Option<StdFee>,

    /// Signatures
    #[prost_amino(message, repeated)]
    pub signatures: Vec<StdSignature>,

    /// Memo field
    #[prost_amino(string)]
    pub memo: String,
}

impl StdTx {
    /// Create a new `StdTx` transaction, serializing the provided messages as Amino
    pub fn new(
        messages: &[Msg],
        fee: StdFee,
        signatures: Vec<StdSignature>,
        memo: impl AsRef<str>,
    ) -> Self {
        Self {
            msg: messages.iter().map(|msg| msg.to_amino_bytes()).collect(),
            fee: Some(fee),
            signatures,
            memo: memo.as_ref().to_owned(),
        }
    }

    /// Encode this [`StdTx`] in Amino encoding identifying it with the given
    /// type name (e.g. `cosmos-sdk/StdTx`)
    pub fn to_amino_bytes(&self, type_name: &TypeName) -> Vec<u8> {
        let mut amino_tx = type_name.amino_prefix();
        self.encode(&mut amino_tx).expect("LEB128 encoding error");

        let mut amino_encoded = vec![];
        encode_length_delimiter(amino_tx.len(), &mut amino_encoded).expect("LEB128 encoding error");
        amino_encoded.append(&mut amino_tx);
        amino_encoded
    }
}

/// `StdFee` Amino type
#[derive(Clone, Message, Deserialize, Serialize)]
pub struct StdFee {
    /// Fee to be paid
    #[prost_amino(message, repeated, tag = "1")]
    pub amount: Vec<Coin>,

    /// Gas requested for transaction
    #[prost_amino(uint64)]
    #[serde(serialize_with = "serialize_gas", deserialize_with = "parse_gas")]
    pub gas: u64,
}

impl StdFee {
    /// Create a [`StdFee`] for a gas-only transaction
    pub fn for_gas(gas: u64) -> Self {
        StdFee {
            amount: vec![],
            gas,
        }
    }
}

/// `Coin` Amino type
#[derive(Clone, Message, Deserialize, Serialize)]
pub struct Coin {
    /// Denomination of coin
    #[prost_amino(string, tag = "1")]
    pub denom: String,

    /// Amount of the given denomination
    #[prost_amino(string)]
    pub amount: String,
}

/// `StdSignature` Amino type
#[derive(Clone, Message)]
pub struct StdSignature {
    /// Public key which can verify this signature
    #[prost_amino(bytes, tag = "1", amino_name = "tendermint/PubKeySecp256k1")]
    pub pub_key: Vec<u8>,

    /// Serialized signature
    #[prost_amino(bytes)]
    pub signature: Vec<u8>,
}

impl From<Signature> for StdSignature {
    fn from(signature: Signature) -> StdSignature {
        StdSignature {
            pub_key: vec![],
            signature: signature.as_ref().to_vec(),
        }
    }
}

fn parse_gas<'de, D>(deserializer: D) -> Result<u64, D::Error>
where
    D: de::Deserializer<'de>,
{
    String::deserialize(deserializer)?
        .parse()
        .map_err(serde::de::Error::custom)
}

fn serialize_gas<S>(value: &u64, serializer: S) -> Result<S::Ok, S::Error>
where
    S: ser::Serializer,
{
    serializer.serialize_str(&value.to_string())
}