diff --git a/tee-worker/omni-executor/Cargo.lock b/tee-worker/omni-executor/Cargo.lock index d2368f28f5..63b09a07f6 100644 --- a/tee-worker/omni-executor/Cargo.lock +++ b/tee-worker/omni-executor/Cargo.lock @@ -2396,6 +2396,7 @@ dependencies = [ "async-trait", "executor-core", "log", + "tokio", ] [[package]] diff --git a/tee-worker/omni-executor/Dockerfile b/tee-worker/omni-executor/Dockerfile index 63dc7198ce..4f98c37bdc 100644 --- a/tee-worker/omni-executor/Dockerfile +++ b/tee-worker/omni-executor/Dockerfile @@ -5,4 +5,10 @@ RUN cargo build --release FROM ubuntu:22.04 COPY --from=builder /usr/src/omni-executor/target/release/executor-worker /usr/local/bin/executor-worker + +RUN \ + apt-get update && \ + apt-get install -y ca-certificates && \ + apt-get clean + CMD ["executor-worker"] \ No newline at end of file diff --git a/tee-worker/omni-executor/ethereum/intent-executor/Cargo.toml b/tee-worker/omni-executor/ethereum/intent-executor/Cargo.toml index 3bb21d68ea..2eae9fd2a2 100644 --- a/tee-worker/omni-executor/ethereum/intent-executor/Cargo.toml +++ b/tee-worker/omni-executor/ethereum/intent-executor/Cargo.toml @@ -10,5 +10,8 @@ async-trait = { workspace = true } executor-core = { path = "../../executor-core" } log = { workspace = true } +[dev-dependencies] +tokio = { workspace = true } + [lints] workspace = true diff --git a/tee-worker/omni-executor/ethereum/intent-executor/src/lib.rs b/tee-worker/omni-executor/ethereum/intent-executor/src/lib.rs index e8b9efc162..5aef97909f 100644 --- a/tee-worker/omni-executor/ethereum/intent-executor/src/lib.rs +++ b/tee-worker/omni-executor/ethereum/intent-executor/src/lib.rs @@ -16,7 +16,7 @@ use std::str::FromStr; -use alloy::network::EthereumWallet; +use alloy::network::{EthereumWallet, TransactionBuilder}; use alloy::primitives::{Address, U256}; use alloy::providers::{Provider, ProviderBuilder, WalletProvider}; use alloy::rpc::types::{TransactionInput, TransactionRequest}; @@ -43,7 +43,7 @@ impl IntentExecutor for EthereumIntentExecutor { info!("Executin intent: {:?}", intent); // todo: this should be retrieved from key_store let signer = PrivateKeySigner::from_str( - "0x59c6995e998f97a5a0044966f0945389dc9e86dae88c7a8412f4603b6b78690d", + "0x59c6995e998f97a5a0044964f0945389dc9e86dae86c7a8412f4603b6b78690d", ) .unwrap(); let wallet = EthereumWallet::from(signer); @@ -51,14 +51,20 @@ impl IntentExecutor for EthereumIntentExecutor { .with_recommended_fillers() .wallet(wallet) .on_http(self.rpc_url.parse().map_err(|e| error!("Could not parse rpc url: {:?}", e))?); - let account = - provider.get_account(provider.signer_addresses().next().unwrap()).await.unwrap(); + let nonce = provider + .get_transaction_count(provider.signer_addresses().next().unwrap()) + .await + .unwrap(); + let gas_price = provider.get_gas_price().await.unwrap(); + match intent { Intent::TransferEthereum(to, value) => { - let tx = TransactionRequest::default() + let mut tx = TransactionRequest::default() .to(Address::from(to)) - .nonce(account.nonce) + .nonce(nonce) .value(U256::from_be_bytes(value)); + + tx.set_gas_price(gas_price); let pending_tx = provider.send_transaction(tx).await.map_err(|e| { error!("Could not send transaction: {:?}", e); })?; @@ -68,10 +74,12 @@ impl IntentExecutor for EthereumIntentExecutor { })?; }, Intent::CallEthereum(address, input) => { - let tx = TransactionRequest::default() + let mut tx = TransactionRequest::default() .to(Address::from(address)) - .nonce(account.nonce) + .nonce(nonce) .input(TransactionInput::from(input)); + + tx.set_gas_price(gas_price); let pending_tx = provider.send_transaction(tx).await.map_err(|e| { error!("Could not send transaction: {:?}", e); })?; @@ -84,3 +92,65 @@ impl IntentExecutor for EthereumIntentExecutor { Ok(()) } } + +#[cfg(test)] +pub mod test { + use alloy::hex; + use alloy::hex::FromHex; + use alloy::network::{EthereumWallet, NetworkWallet, TransactionBuilder}; + use alloy::primitives::Address; + use alloy::providers::{Provider, ProviderBuilder, WalletProvider}; + use alloy::rpc::types::{TransactionInput, TransactionRequest}; + use alloy::signers::local::PrivateKeySigner; + use log::error; + use std::str::FromStr; + + // #[tokio::test] + pub async fn test() { + // place url here: + let url = ""; + + let signer = PrivateKeySigner::from_str( + "0x59c6995e998f97a5a0044964f0945389dc9e86dae86c7a8412f4603b6b78690d", + ) + .unwrap(); + let wallet = EthereumWallet::from(signer); + + let provider = ProviderBuilder::new() + .with_recommended_fillers() + .wallet(wallet) + .on_http(url.parse().map_err(|e| error!("Could not parse rpc url: {:?}", e)).unwrap()); + let nonce = provider + .get_transaction_count(provider.signer_addresses().next().unwrap()) + .await + .unwrap(); + let gas_price = provider.get_gas_price().await.unwrap(); + + let mut tx = TransactionRequest::default() + .to(Address::from_hex("0x1f754692f0b0578d6af97faed6319542c9ffd468").unwrap()) + .nonce(nonce) + .input(TransactionInput::from(hex::decode("0x2166e8280000000000000000000000000000000000000000000000000000000000000020000000000000000000000000000000000000000000000000000000000000001e4c6974656e747279204f6d6e694163636f756e7420657865637574696f6e0000").unwrap())); + + tx.set_gas_price(gas_price); + + let pending_tx = provider + .send_transaction(tx) + .await + .map_err(|e| { + std::println!("Could not send transaction: {:?}", e); + }) + .map_err(|e| { + std::println!("Could not get transaction receipt: {:?}", e); + () + }) + .unwrap(); + + pending_tx + .get_receipt() + .await + .map_err(|e| { + error!("Could not get transaction receipt: {:?}", e); + }) + .unwrap(); + } +} diff --git a/tee-worker/omni-executor/parentchain/artifacts/rococo-omni-account.scale b/tee-worker/omni-executor/parentchain/artifacts/rococo-omni-account.scale index 5f18bed23f..66fa4feed9 100644 Binary files a/tee-worker/omni-executor/parentchain/artifacts/rococo-omni-account.scale and b/tee-worker/omni-executor/parentchain/artifacts/rococo-omni-account.scale differ diff --git a/tee-worker/omni-executor/parentchain/listener/src/event_handler.rs b/tee-worker/omni-executor/parentchain/listener/src/event_handler.rs index 230dee4a61..e9968023ab 100644 --- a/tee-worker/omni-executor/parentchain/listener/src/event_handler.rs +++ b/tee-worker/omni-executor/parentchain/listener/src/event_handler.rs @@ -172,68 +172,72 @@ impl< Error::NonRecoverableError })?; - let intent = match decoded.intent { + let maybe_intent = match decoded.intent { crate::litentry_rococo::runtime_types::core_primitives::intent::Intent::CallEthereum(call_ethereum) => { - Intent::CallEthereum(call_ethereum.address.to_fixed_bytes(), call_ethereum.input.0) + Some(Intent::CallEthereum(call_ethereum.address.to_fixed_bytes(), call_ethereum.input.0)) }, crate::litentry_rococo::runtime_types::core_primitives::intent::Intent::TransferEthereum(transfer) => { - Intent::TransferEthereum(transfer.to.to_fixed_bytes(), transfer.value) - } - }; - - //to explicitly handle all intent variants - match intent { - Intent::CallEthereum(_, _) => { - self.ethereum_intent_executor.execute(intent).await.map_err(|_| { - // assume for now we can easily recover - log::error!("Error executing intent"); - Error::RecoverableError - })?; - }, - Intent::TransferEthereum(_, _) => { - self.ethereum_intent_executor.execute(intent).await.map_err(|_| { - // assume for now we can easily recover - log::error!("Error executing intent"); - Error::RecoverableError - })?; + Some(Intent::TransferEthereum(transfer.to.to_fixed_bytes(), transfer.value)) }, - } + crate::litentry_rococo::runtime_types::core_primitives::intent::Intent::SystemRemark(_) => None, + crate::litentry_rococo::runtime_types::core_primitives::intent::Intent::TransferNative(_) => None, + }; - log::debug!("Intent executed, publishing result"); + if let Some(intent) = maybe_intent { + // to explicitly handle all intent variants + match intent { + Intent::CallEthereum(_, _) => { + self.ethereum_intent_executor.execute(intent).await.map_err(|_| { + // assume for now we can easily recover + log::error!("Error executing intent"); + Error::RecoverableError + })?; + }, + Intent::TransferEthereum(_, _) => { + self.ethereum_intent_executor.execute(intent).await.map_err(|_| { + // assume for now we can easily recover + log::error!("Error executing intent"); + Error::RecoverableError + })?; + }, + } - // todo: the whole signing part should be encapsulated in separate component like `TransactionSigner` - //we need to report back to parachain intent result - let decoded = - crate::litentry_rococo::omni_account::events::IntentRequested::decode_as_fields( - &mut event.field_bytes.as_slice(), - &mut fields, - metadata.types(), - ) - .map_err(|_| { - log::error!("Could not decode event {:?}", event.id); - Error::NonRecoverableError - })?; + log::debug!("Intent executed, publishing result"); + + // todo: the whole signing part should be encapsulated in separate component like `TransactionSigner` + //we need to report back to parachain intent result + let decoded = + crate::litentry_rococo::omni_account::events::IntentRequested::decode_as_fields( + &mut event.field_bytes.as_slice(), + &mut fields, + metadata.types(), + ) + .map_err(|_| { + log::error!("Could not decode event {:?}", event.id); + Error::NonRecoverableError + })?; - let execution_result = - crate::litentry_rococo::omni_account::calls::types::intent_executed::Result::Success; + let execution_result = + crate::litentry_rococo::omni_account::calls::types::intent_executed::Result::Success; - let call = crate::litentry_rococo::tx().omni_account().intent_executed( - decoded.who, - decoded.intent, - execution_result, - ); + let call = crate::litentry_rococo::tx().omni_account().intent_executed( + decoded.who, + decoded.intent, + execution_result, + ); - let mut client = self.rpc_client_factory.new_client().await.map_err(|e| { - error!("Could not create RPC client: {:?}", e); - RecoverableError - })?; + let mut client = self.rpc_client_factory.new_client().await.map_err(|e| { + error!("Could not create RPC client: {:?}", e); + RecoverableError + })?; - let signed_call = self.transaction_signer.sign(call).await; - client.submit_tx(&signed_call).await.map_err(|e| { - error!("Error while submitting tx: {:?}", e); - RecoverableError - })?; - log::debug!("Result published"); + let signed_call = self.transaction_signer.sign(call).await; + client.submit_tx(&signed_call).await.map_err(|e| { + error!("Error while submitting tx: {:?}", e); + RecoverableError + })?; + log::debug!("Result published"); + } Ok(()) } }