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
/*
*
* Hedera Rust SDK
*
* Copyright (C) 2022 - 2023 Hedera Hashgraph, LLC
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
use async_trait::async_trait;
use hedera_proto::services;
use hedera_proto::services::smart_contract_service_client::SmartContractServiceClient;
use tonic::transport::Channel;
use crate::entity_id::AutoValidateChecksum;
use crate::transaction::{
AnyTransactionData,
ToTransactionDataProtobuf,
TransactionExecute,
};
use crate::{
Error,
FileId,
LedgerId,
ToProtobuf,
Transaction,
};
/// Submit an Ethereum transaction.
pub type EthereumTransaction = Transaction<EthereumTransactionData>;
#[derive(Debug, Default, Clone)]
#[cfg_attr(feature = "ffi", derive(serde::Serialize, serde::Deserialize))]
#[cfg_attr(feature = "ffi", serde(rename_all = "camelCase"))]
pub struct EthereumTransactionData {
/// The raw Ethereum transaction (RLP encoded type 0, 1, and 2).
#[cfg_attr(feature = "ffi", serde(with = "serde_with::As::<serde_with::base64::Base64>"))]
pub ethereum_data: Vec<u8>,
/// For large transactions (for example contract create) this should be used to
/// set the FileId of an HFS file containing the callData
/// of the ethereumData. The data in the ethereumData will be re-written with
/// the callData element as a zero length string with the original contents in
/// the referenced file at time of execution. The ethereumData will need to be
/// "rehydrated" with the callData for signature validation to pass.
pub call_data_file_id: Option<FileId>,
/// The maximum amount that the payer of the hedera transaction
/// is willing to pay to complete the transaction.
pub max_gas_allowance_hbar: u64,
}
impl EthereumTransaction {
/// Sets the raw Ethereum transaction (RLP encoded type 0, 1, and 2).
pub fn ethereum_data(&mut self, data: Vec<u8>) -> &mut Self {
self.body.data.ethereum_data = data;
self
}
/// Sets a file ID to find the raw Ethereum transaction (RLP encoded type 0, 1, and 2).
///
/// For large transactions (for example contract create) this should be used to
/// set the [`FileId`] of an HFS file containing the callData
/// of the ethereumData. The data in the ethereumData will be re-written with
/// the callData element as a zero length string with the original contents in
/// the referenced file at time of execution. The ethereumData will need to be
/// "rehydrated" with the callData for signature validation to pass.
///
pub fn call_data_file_id(&mut self, id: FileId) -> &mut Self {
self.body.data.call_data_file_id = Some(id);
self
}
/// Sets the maximum amount that the payer of the hedera transaction
/// is willing to pay to complete the transaction.
pub fn max_gas_allowance_hbar(&mut self, allowance: u64) -> &mut Self {
self.body.data.max_gas_allowance_hbar = allowance;
self
}
}
#[async_trait]
impl TransactionExecute for EthereumTransactionData {
fn validate_checksums_for_ledger_id(&self, ledger_id: &LedgerId) -> Result<(), Error> {
self.call_data_file_id.validate_checksum_for_ledger_id(ledger_id)
}
// noinspection DuplicatedCode
async fn execute(
&self,
channel: Channel,
request: services::Transaction,
) -> Result<tonic::Response<services::TransactionResponse>, tonic::Status> {
SmartContractServiceClient::new(channel).call_ethereum(request).await
}
}
impl ToTransactionDataProtobuf for EthereumTransactionData {
fn to_transaction_data_protobuf(
&self,
_node_account_id: crate::AccountId,
_transaction_id: &crate::TransactionId,
) -> services::transaction_body::Data {
let call_data = self.call_data_file_id.to_protobuf();
services::transaction_body::Data::EthereumTransaction(services::EthereumTransactionBody {
ethereum_data: self.ethereum_data.clone(),
call_data,
max_gas_allowance: self.max_gas_allowance_hbar as i64,
})
}
}
impl From<EthereumTransactionData> for AnyTransactionData {
fn from(transaction: EthereumTransactionData) -> Self {
Self::Ethereum(transaction)
}
}