diff --git a/crates/autopilot/src/database/onchain_order_events/mod.rs b/crates/autopilot/src/database/onchain_order_events/mod.rs index b460768d80..6d7a3b7208 100644 --- a/crates/autopilot/src/database/onchain_order_events/mod.rs +++ b/crates/autopilot/src/database/onchain_order_events/mod.rs @@ -600,9 +600,9 @@ fn convert_onchain_order_placement( // executed fast (we don't want to reserve the user's ETH for too long) if quote.as_ref().is_ok_and(|quote| { !order_data.within_market(QuoteAmounts { - sell: quote.sell_amount.into_legacy(), - buy: quote.buy_amount.into_legacy(), - fee: quote.fee_amount.into_legacy(), + sell: quote.sell_amount, + buy: quote.buy_amount, + fee: quote.fee_amount, }) }) { tracing::debug!(%order_uid, ?owner, "order is outside market price"); diff --git a/crates/autopilot/src/run_loop.rs b/crates/autopilot/src/run_loop.rs index 5cfaa28a0b..9a71cb53d1 100644 --- a/crates/autopilot/src/run_loop.rs +++ b/crates/autopilot/src/run_loop.rs @@ -472,7 +472,9 @@ impl RunLoop { .map(|(index, participant)| SolverSettlement { solver: participant.driver().name.clone(), solver_address: participant.solution().solver().0.into_alloy(), - score: Some(Score::Solver(participant.solution().score().get().0)), + score: Some(Score::Solver( + participant.solution().score().get().0.into_alloy(), + )), ranking: index + 1, orders: participant .solution() diff --git a/crates/driver/src/util/math.rs b/crates/driver/src/util/math.rs index 582926d875..bb0210e605 100644 --- a/crates/driver/src/util/math.rs +++ b/crates/driver/src/util/math.rs @@ -28,14 +28,14 @@ pub fn mul_ratio_ceil(x: U256, q: U256, d: U256) -> Option { // fast path when math in U256 doesn't overflow if let Some(p) = x.checked_mul(q) { - let (div, rem) = (p / d, p % d); + let (div, rem) = p.div_rem(d); return div.checked_add(U256::from(!rem.is_zero())); } let p = x.widening_mul(q); let d = U512::from(d); // SAFETY: at this point !d.is_zero() upholds - let (div, rem) = (p / d, p % d); + let (div, rem) = p.div_rem(d); let result = U256::uint_try_from(div).ok()?; result.checked_add(U256::from(!rem.is_zero())) diff --git a/crates/e2e/src/api/zeroex.rs b/crates/e2e/src/api/zeroex.rs index 21fbf61376..bb176ba7a8 100644 --- a/crates/e2e/src/api/zeroex.rs +++ b/crates/e2e/src/api/zeroex.rs @@ -1,15 +1,12 @@ use { crate::setup::TestAccount, - autopilot::domain::eth::U256, + alloy::primitives::{Address, B256, U256}, chrono::{DateTime, NaiveDateTime, Utc}, - driver::domain::eth::H256, ethcontract::common::abi::{Token, encode}, + ethrpc::alloy::conversions::IntoLegacy, hex_literal::hex, model::DomainSeparator, - shared::{ - zeroex_api, - zeroex_api::{Order, OrderMetadata, OrderRecord, ZeroExSignature}, - }, + shared::zeroex_api::{self, Order, OrderMetadata, OrderRecord, ZeroExSignature}, std::{net::SocketAddr, sync::LazyLock}, warp::{Filter, Reply}, web3::{signing, types::H160}, @@ -55,17 +52,17 @@ impl ZeroExApi { } pub struct Eip712TypedZeroExOrder { - pub maker_token: H160, - pub taker_token: H160, + pub maker_token: Address, + pub taker_token: Address, pub maker_amount: u128, pub taker_amount: u128, pub remaining_fillable_taker_amount: u128, pub taker_token_fee_amount: u128, - pub maker: H160, - pub taker: H160, - pub sender: H160, - pub fee_recipient: H160, - pub pool: H256, + pub maker: Address, + pub taker: Address, + pub sender: Address, + pub fee_recipient: Address, + pub pool: B256, pub expiry: u64, pub salt: U256, } @@ -85,15 +82,15 @@ impl Eip712TypedZeroExOrder { Order { chain_id, expiry: NaiveDateTime::MAX.and_utc().timestamp() as u64, - fee_recipient: self.fee_recipient, - maker: self.maker, - maker_token: self.maker_token, + fee_recipient: self.fee_recipient.into_legacy(), + maker: self.maker.into_legacy(), + maker_token: self.maker_token.into_legacy(), maker_amount: self.maker_amount, - pool: self.pool, - salt: self.salt, - sender: self.sender, - taker: self.taker, - taker_token: self.taker_token, + pool: self.pool.into_legacy(), + salt: self.salt.into_legacy(), + sender: self.sender.into_legacy(), + taker: self.taker.into_legacy(), + taker_token: self.taker_token.into_legacy(), taker_amount: self.taker_amount, taker_token_fee_amount: self.taker_token_fee_amount, verifying_contract, @@ -131,18 +128,18 @@ impl Eip712TypedZeroExOrder { fn hash_struct(&self) -> [u8; 32] { let mut hash_data = [0u8; 416]; hash_data[0..32].copy_from_slice(&Self::ZEROEX_LIMIT_ORDER_TYPEHASH); - hash_data[44..64].copy_from_slice(self.maker_token.as_fixed_bytes()); - hash_data[76..96].copy_from_slice(self.taker_token.as_fixed_bytes()); + hash_data[44..64].copy_from_slice(self.maker_token.as_slice()); + hash_data[76..96].copy_from_slice(self.taker_token.as_slice()); hash_data[112..128].copy_from_slice(&self.maker_amount.to_be_bytes()); hash_data[144..160].copy_from_slice(&self.taker_amount.to_be_bytes()); hash_data[176..192].copy_from_slice(&self.taker_token_fee_amount.to_be_bytes()); - hash_data[204..224].copy_from_slice(self.maker.as_fixed_bytes()); - hash_data[236..256].copy_from_slice(self.taker.as_fixed_bytes()); - hash_data[268..288].copy_from_slice(self.sender.as_fixed_bytes()); - hash_data[300..320].copy_from_slice(self.fee_recipient.as_fixed_bytes()); - hash_data[320..352].copy_from_slice(self.pool.as_fixed_bytes()); + hash_data[204..224].copy_from_slice(self.maker.as_slice()); + hash_data[236..256].copy_from_slice(self.taker.as_slice()); + hash_data[268..288].copy_from_slice(self.sender.as_slice()); + hash_data[300..320].copy_from_slice(self.fee_recipient.as_slice()); + hash_data[320..352].copy_from_slice(self.pool.as_slice()); hash_data[376..384].copy_from_slice(&self.expiry.to_be_bytes()); - self.salt.to_big_endian(&mut hash_data[384..416]); + hash_data[384..416].copy_from_slice(&self.salt.to_be_bytes::<32>()); signing::keccak256(&hash_data) } } diff --git a/crates/e2e/src/setup/onchain_components/mod.rs b/crates/e2e/src/setup/onchain_components/mod.rs index 9eac7591fa..ed6fb4936f 100644 --- a/crates/e2e/src/setup/onchain_components/mod.rs +++ b/crates/e2e/src/setup/onchain_components/mod.rs @@ -4,7 +4,10 @@ use { setup::{DeployedContracts, deploy::Contracts}, }, ::alloy::{ - network::{Ethereum, NetworkWallet}, + network::{Ethereum, NetworkWallet, TransactionBuilder}, + primitives::Address, + providers::Provider, + rpc::types::TransactionRequest, signers::local::PrivateKeySigner, }, app_data::Hook, @@ -13,14 +16,7 @@ use { GPv2AllowListAuthentication::GPv2AllowListAuthentication, test::CowProtocolToken, }, - core::panic, - ethcontract::{ - Account, - H160, - PrivateKey, - U256, - transaction::{TransactionBuilder, TransactionResult}, - }, + ethcontract::{Account, H160, PrivateKey, U256}, ethrpc::alloy::{ CallBuilderExt, ProviderSignerExt, @@ -93,23 +89,6 @@ pub fn eth(amount: u32) -> ::alloy::primitives::U256 { ::alloy::primitives::U256::from(amount) * ::alloy::primitives::utils::Unit::ETHER.wei() } -pub async fn hook_for_transaction(tx: TransactionBuilder) -> Hook -where - T: web3::Transport, -{ - let gas_limit = tx - .clone() - .estimate_gas() - .await - .expect("transaction reverted when estimating gas") - .as_u64(); - Hook { - target: tx.to.map(IntoAlloy::into_alloy).unwrap(), - call_data: tx.data.unwrap().0, - gas_limit, - } -} - #[derive(Clone, Debug)] pub struct TestAccount { account: Account, @@ -121,8 +100,8 @@ impl TestAccount { &self.account } - pub fn address(&self) -> H160 { - self.account.address() + pub fn address(&self) -> Address { + self.account.address().into_alloy() } pub fn private_key(&self) -> &[u8; 32] { @@ -142,9 +121,9 @@ impl TestAccount { ) } - pub async fn nonce(&self, web3: &Web3) -> U256 { - web3.eth() - .transaction_count(self.address(), None) + pub async fn nonce(&self, web3: &Web3) -> u64 { + web3.alloy + .get_transaction_count(self.address()) .await .unwrap() } @@ -192,9 +171,9 @@ pub struct MintableToken { } impl MintableToken { - pub async fn mint(&self, to: H160, amount: U256) { + pub async fn mint(&self, to: Address, amount: ::alloy::primitives::U256) { self.contract - .mint(to.into_alloy(), amount.into_alloy()) + .mint(to, amount) .from(self.minter.address().into_alloy()) .send_and_watch() .await @@ -217,9 +196,9 @@ pub struct CowToken { } impl CowToken { - pub async fn fund(&self, to: H160, amount: U256) { + pub async fn fund(&self, to: Address, amount: ::alloy::primitives::U256) { self.contract - .transfer(to.into_alloy(), amount.into_alloy()) + .transfer(to, amount) .from(self.holder.address().into_alloy()) .send_and_watch() .await @@ -230,7 +209,7 @@ impl CowToken { let domain = self.contract.DOMAIN_SEPARATOR().call().await.unwrap(); let nonce = self .contract - .nonces(owner.address().into_alloy()) + .nonces(owner.address()) .call() .await .unwrap() @@ -242,7 +221,7 @@ impl CowToken { buffer[0..32].copy_from_slice(&hex!( "6e71edae12b1b97f4d1f60370fef10105fa2faae0126114a169c64845d6126c9" )); - buffer[44..64].copy_from_slice(owner.address().as_bytes()); + buffer[44..64].copy_from_slice(owner.address().as_slice()); buffer[76..96].copy_from_slice(spender.as_bytes()); value.to_big_endian(&mut buffer[96..128]); nonce.to_big_endian(&mut buffer[128..160]); @@ -254,7 +233,7 @@ impl CowToken { let signature = owner.sign_typed_data(&DomainSeparator(domain.0), &struct_hash); let permit = self.contract.permit( - owner.address().into_alloy(), + owner.address(), spender.into_alloy(), value.into_alloy(), deadline.into_alloy(), @@ -320,7 +299,10 @@ impl OnchainComponents { } /// Generate next `N` accounts with the given initial balance. - pub async fn make_accounts(&mut self, with_wei: U256) -> [TestAccount; N] { + pub async fn make_accounts( + &mut self, + with_wei: ::alloy::primitives::U256, + ) -> [TestAccount; N] { let res = self.accounts.borrow_mut().take(N).collect::>(); assert_eq!(res.len(), N); @@ -336,7 +318,10 @@ impl OnchainComponents { /// Generate next `N` accounts with the given initial balance and /// authenticate them as solvers. - pub async fn make_solvers(&mut self, with_wei: U256) -> [TestAccount; N] { + pub async fn make_solvers( + &mut self, + with_wei: ::alloy::primitives::U256, + ) -> [TestAccount; N] { let solvers = self.make_accounts::(with_wei).await; for solver in &solvers { @@ -346,7 +331,7 @@ impl OnchainComponents { self.contracts .gp_authenticator - .addSolver(solver.address().into_alloy()) + .addSolver(solver.address()) .send_and_watch() .await .expect("failed to add solver"); @@ -355,18 +340,18 @@ impl OnchainComponents { solvers } - pub async fn set_solver_allowed(&self, solver: H160, allowed: bool) { + pub async fn set_solver_allowed(&self, solver: Address, allowed: bool) { if allowed { self.contracts .gp_authenticator - .addSolver(solver.into_alloy()) + .addSolver(solver) .send_and_watch() .await .expect("failed to add solver"); } else { self.contracts .gp_authenticator - .removeSolver(solver.into_alloy()) + .removeSolver(solver) .send_and_watch() .await .expect("failed to remove solver"); @@ -377,7 +362,7 @@ impl OnchainComponents { /// authenticate them as solvers on a forked network. pub async fn make_solvers_forked( &mut self, - with_wei: U256, + with_wei: ::alloy::primitives::U256, ) -> [TestAccount; N] { let authenticator = &self.contracts.gp_authenticator; @@ -408,7 +393,7 @@ impl OnchainComponents { for solver in &solvers { impersonated_authenticator - .addSolver(solver.address().into_alloy()) + .addSolver(solver.address()) .from(auth_manager.into_alloy()) .send_and_watch() .await @@ -542,12 +527,12 @@ impl OnchainComponents { pub async fn seed_uni_v2_pool( &self, - asset_a: (&MintableToken, U256), - asset_b: (&MintableToken, U256), + asset_a: (&MintableToken, ::alloy::primitives::U256), + asset_b: (&MintableToken, ::alloy::primitives::U256), ) { let lp = &asset_a.0.minter; - asset_a.0.mint(lp.address(), asset_a.1).await; - asset_b.0.mint(lp.address(), asset_b.1).await; + asset_a.0.mint(lp.address().into_alloy(), asset_a.1).await; + asset_b.0.mint(lp.address().into_alloy(), asset_b.1).await; self.contracts .uniswap_v2_factory @@ -559,10 +544,7 @@ impl OnchainComponents { asset_a .0 - .approve( - *self.contracts.uniswap_v2_router.address(), - asset_a.1.into_alloy(), - ) + .approve(*self.contracts.uniswap_v2_router.address(), asset_a.1) .from(lp.address().into_alloy()) .send_and_watch() .await @@ -570,10 +552,7 @@ impl OnchainComponents { asset_b .0 - .approve( - *self.contracts.uniswap_v2_router.address(), - asset_b.1.into_alloy(), - ) + .approve(*self.contracts.uniswap_v2_router.address(), asset_b.1) .from(lp.address().into_alloy()) .send_and_watch() .await @@ -583,8 +562,8 @@ impl OnchainComponents { .addLiquidity( *asset_a.0.address(), *asset_b.0.address(), - asset_a.1.into_alloy(), - asset_b.1.into_alloy(), + asset_a.1, + asset_b.1, ::alloy::primitives::U256::ZERO, ::alloy::primitives::U256::ZERO, lp.address().into_alloy(), @@ -599,7 +578,11 @@ impl OnchainComponents { /// Mints `amount` tokens to its `token`-WETH Uniswap V2 pool. /// /// This can be used to modify the pool reserves during a test. - pub async fn mint_token_to_weth_uni_v2_pool(&self, token: &MintableToken, amount: U256) { + pub async fn mint_token_to_weth_uni_v2_pool( + &self, + token: &MintableToken, + amount: ::alloy::primitives::U256, + ) { let pair = contracts::alloy::IUniswapLikePair::Instance::new( self.contracts .uniswap_v2_factory @@ -613,7 +596,9 @@ impl OnchainComponents { // Mint amount + 1 to the pool, and then swap out 1 of the minted token // in order to force it to update its K-value. - token.mint(pair.address().into_legacy(), amount + 1).await; + token + .mint(*pair.address(), amount + ::alloy::primitives::U256::ONE) + .await; let (out0, out1) = if self.contracts.weth.address() < token.address() { (1, 0) } else { @@ -707,25 +692,23 @@ impl OnchainComponents { cow } - pub async fn send_wei(&self, to: H160, amount: U256) { - let balance_before = self.web3.eth().balance(to, None).await.unwrap(); - let receipt = TransactionBuilder::new(self.web3.legacy.clone()) - .value(amount) - .to(to) - .send() + pub async fn send_wei(&self, to: Address, amount: ::alloy::primitives::U256) { + let balance_before = self.web3.alloy.get_balance(to).await.unwrap(); + self.web3 + .alloy + .send_transaction(TransactionRequest::default().with_to(to).with_value(amount)) + .await + .unwrap() + .watch() .await .unwrap(); - let TransactionResult::Receipt(receipt) = receipt else { - panic!("expected to get a transaction receipt"); - }; - assert_eq!(receipt.status, Some(1.into())); // There seems to be a bug in anvil where sending ETH does not work // reliably with a forked node. On some block numbers the transaction // supposedly succeeds but the balances still don't get changed. // If you hit this assert try using a different block number for your // forked test. - let balance_after = self.web3.eth().balance(to, None).await.unwrap(); + let balance_after = self.web3.alloy.get_balance(to).await.unwrap(); assert_eq!(balance_after, balance_before + amount); } diff --git a/crates/e2e/src/setup/onchain_components/safe.rs b/crates/e2e/src/setup/onchain_components/safe.rs index 5ac9f76343..bc063965fd 100644 --- a/crates/e2e/src/setup/onchain_components/safe.rs +++ b/crates/e2e/src/setup/onchain_components/safe.rs @@ -69,10 +69,7 @@ impl Infrastructure { let safe = GnosisSafe::Instance::new(safe_proxy, self.provider.clone()); safe.setup( - owners - .into_iter() - .map(|owner| owner.address().into_alloy()) - .collect(), + owners.into_iter().map(|owner| owner.address()).collect(), U256::from(threshold), Address::default(), // delegate call Bytes::default(), // delegate call bytes @@ -134,11 +131,9 @@ impl Safe { Default::default(), Default::default(), Default::default(), - crate::setup::safe::gnosis_safe_prevalidated_signature( - self.owner.address().into_alloy(), - ), + crate::setup::safe::gnosis_safe_prevalidated_signature(self.owner.address()), ) - .from(self.owner.address().into_alloy()) + .from(self.owner.address()) .send_and_watch() .await .unwrap(); diff --git a/crates/e2e/tests/e2e/app_data.rs b/crates/e2e/tests/e2e/app_data.rs index 6f7cec3148..2a8ad76747 100644 --- a/crates/e2e/tests/e2e/app_data.rs +++ b/crates/e2e/tests/e2e/app_data.rs @@ -32,17 +32,17 @@ async fn local_node_app_data_full_format() { // Test that orders can be placed with the new app data format. async fn app_data(web3: Web3) { let mut onchain = OnchainComponents::deploy(web3).await; - let [solver] = onchain.make_solvers(to_wei(1)).await; - let [trader] = onchain.make_accounts(to_wei(1)).await; + let [solver] = onchain.make_solvers(eth(1)).await; + let [trader] = onchain.make_accounts(eth(1)).await; let [token_a, token_b] = onchain .deploy_tokens_with_weth_uni_v2_pools(to_wei(1_000), to_wei(1_000)) .await; - token_a.mint(trader.address(), to_wei(10)).await; + token_a.mint(trader.address(), eth(10)).await; token_a .approve(onchain.contracts().allowance.into_alloy(), eth(10)) - .from(trader.address().into_alloy()) + .from(trader.address()) .send_and_watch() .await .unwrap(); @@ -194,17 +194,17 @@ async fn app_data(web3: Web3) { /// all supported features. async fn app_data_full_format(web3: Web3) { let mut onchain = OnchainComponents::deploy(web3).await; - let [solver] = onchain.make_solvers(to_wei(1)).await; - let [trader] = onchain.make_accounts(to_wei(1)).await; + let [solver] = onchain.make_solvers(eth(1)).await; + let [trader] = onchain.make_accounts(eth(1)).await; let [token_a, token_b] = onchain .deploy_tokens_with_weth_uni_v2_pools(to_wei(1_000), to_wei(1_000)) .await; - token_a.mint(trader.address(), to_wei(10)).await; + token_a.mint(trader.address(), eth(10)).await; token_a .approve(onchain.contracts().allowance.into_alloy(), eth(10)) - .from(trader.address().into_alloy()) + .from(trader.address()) .send_and_watch() .await .unwrap(); diff --git a/crates/e2e/tests/e2e/app_data_signer.rs b/crates/e2e/tests/e2e/app_data_signer.rs index 43a28a7f30..2a34354536 100644 --- a/crates/e2e/tests/e2e/app_data_signer.rs +++ b/crates/e2e/tests/e2e/app_data_signer.rs @@ -22,25 +22,25 @@ async fn local_node_order_creation_checks_metadata_signer() { async fn order_creation_checks_metadata_signer(web3: Web3) { let mut onchain = OnchainComponents::deploy(web3.clone()).await; - let [solver] = onchain.make_solvers(to_wei(1)).await; - let [trader, adversary, safe_owner] = onchain.make_accounts(to_wei(1)).await; + let [solver] = onchain.make_solvers(eth(1)).await; + let [trader, adversary, safe_owner] = onchain.make_accounts(eth(1)).await; let [token_a, token_b] = onchain .deploy_tokens_with_weth_uni_v2_pools(to_wei(1_000), to_wei(1_000)) .await; - token_a.mint(trader.address(), to_wei(10)).await; + token_a.mint(trader.address(), eth(10)).await; token_a .approve(onchain.contracts().allowance.into_alloy(), eth(10)) - .from(trader.address().into_alloy()) + .from(trader.address()) .send_and_watch() .await .unwrap(); - token_a.mint(adversary.address(), to_wei(10)).await; + token_a.mint(adversary.address(), eth(10)).await; token_a .approve(onchain.contracts().allowance.into_alloy(), eth(10)) - .from(adversary.address().into_alloy()) + .from(adversary.address()) .send_and_watch() .await .unwrap(); @@ -73,13 +73,13 @@ async fn order_creation_checks_metadata_signer(web3: Web3) { services.start_protocol(solver).await; // Rejected: app data with different signer. - let full_app_data = full_app_data_with_signer(adversary.address().into_alloy()); + let full_app_data = full_app_data_with_signer(adversary.address()); let order1 = sign(create_order(full_app_data), &trader); let err = services.create_order(&order1).await.unwrap_err(); assert!(dbg!(err).1.contains("WrongOwner")); // Accepted: app data with correct signer. - let full_app_data = full_app_data_with_signer(trader.address().into_alloy()); + let full_app_data = full_app_data_with_signer(trader.address()); let order2 = sign(create_order(full_app_data.clone()), &trader); let uid = services.create_order(&order2).await.unwrap(); assert!(matches!(services.get_order(&uid).await, Ok(..))); @@ -99,7 +99,7 @@ async fn order_creation_checks_metadata_signer(web3: Web3) { // EIP-1271 let safe = Safe::deploy(safe_owner.clone(), web3.alloy.clone()).await; - token_a.mint(safe.address().into_legacy(), to_wei(10)).await; + token_a.mint(safe.address(), eth(10)).await; safe.exec_alloy_call( token_a .approve(onchain.contracts().allowance.into_alloy(), eth(10)) @@ -114,7 +114,7 @@ async fn order_creation_checks_metadata_signer(web3: Web3) { assert!(matches!(services.create_order(&order4).await, Ok(..))); // Rejected: from and signer are inconsistent. - let full_app_data = full_app_data_with_signer(adversary.address().into_alloy()); + let full_app_data = full_app_data_with_signer(adversary.address()); let mut order5 = create_order(full_app_data); order5.from = Some(safe.address().into_legacy()); safe.sign_order(&mut order5, &onchain); diff --git a/crates/e2e/tests/e2e/autopilot_leader.rs b/crates/e2e/tests/e2e/autopilot_leader.rs index 5eece8c177..d9e53c6bc8 100644 --- a/crates/e2e/tests/e2e/autopilot_leader.rs +++ b/crates/e2e/tests/e2e/autopilot_leader.rs @@ -33,22 +33,22 @@ async fn dual_autopilot_only_leader_produces_auctions(web3: Web3) { // TODO: Implement test that checks auction creation frequency against db // to see that only one autopilot produces auctions let mut onchain = OnchainComponents::deploy(web3).await; - let [trader] = onchain.make_accounts(to_wei(1)).await; - let [solver1, solver2] = onchain.make_solvers(to_wei(1)).await; + let [trader] = onchain.make_accounts(eth(1)).await; + let [solver1, solver2] = onchain.make_solvers(eth(1)).await; let [token_a] = onchain .deploy_tokens_with_weth_uni_v2_pools(to_wei(1_000), to_wei(1_000)) .await; // Fund trader, settlement accounts, and pool creation - token_a.mint(solver1.address(), to_wei(1000)).await; - token_a.mint(solver2.address(), to_wei(1000)).await; + token_a.mint(solver1.address(), eth(1000)).await; + token_a.mint(solver2.address(), eth(1000)).await; - token_a.mint(trader.address(), to_wei(200)).await; + token_a.mint(trader.address(), eth(200)).await; // Approve GPv2 for trading token_a .approve(onchain.contracts().allowance.into_alloy(), eth(1000)) - .from(trader.address().into_alloy()) + .from(trader.address()) .send_and_watch() .await .unwrap(); @@ -145,8 +145,7 @@ async fn dual_autopilot_only_leader_produces_auctions(web3: Web3) { .as_ref() .and_then(|competition| competition.solutions.first()) .map(|solution| { - solution.is_winner - && solution.solver_address == solver1.address().into_alloy() + solution.is_winner && solution.solver_address == solver1.address() }) } else { None @@ -182,8 +181,7 @@ async fn dual_autopilot_only_leader_produces_auctions(web3: Web3) { .as_ref() .and_then(|competition| competition.solutions.first()) .map(|solution| { - solution.is_winner - && solution.solver_address == solver2.address().into_alloy() + solution.is_winner && solution.solver_address == solver2.address() }) } else { None diff --git a/crates/e2e/tests/e2e/banned_users.rs b/crates/e2e/tests/e2e/banned_users.rs index 8b4e80351c..21027604d9 100644 --- a/crates/e2e/tests/e2e/banned_users.rs +++ b/crates/e2e/tests/e2e/banned_users.rs @@ -9,7 +9,6 @@ use { Services, eth, run_forked_test_with_block_number, - to_wei, to_wei_with_exp, }, ethrpc::{Web3, alloy::conversions::IntoAlloy}, @@ -37,7 +36,7 @@ const BANNED_USER: Address = address!("7F367cC41522cE07553e823bf3be79A889DEbe1B" async fn forked_mainnet_onchain_banned_user_test(web3: Web3) { let mut onchain = OnchainComponents::deployed(web3.clone()).await; - let [solver] = onchain.make_solvers_forked(to_wei(1)).await; + let [solver] = onchain.make_solvers_forked(eth(1)).await; let token_dai = ERC20::Instance::new( address!("6b175474e89094c44da98b954eedeac495271d0f"), diff --git a/crates/e2e/tests/e2e/buffers.rs b/crates/e2e/tests/e2e/buffers.rs index 688378b39e..6a5d31535c 100644 --- a/crates/e2e/tests/e2e/buffers.rs +++ b/crates/e2e/tests/e2e/buffers.rs @@ -23,28 +23,25 @@ async fn local_node_buffers() { async fn onchain_settlement_without_liquidity(web3: Web3) { let mut onchain = OnchainComponents::deploy(web3).await; - let [solver] = onchain.make_solvers(to_wei(1)).await; - let [trader] = onchain.make_accounts(to_wei(1)).await; + let [solver] = onchain.make_solvers(eth(1)).await; + let [trader] = onchain.make_accounts(eth(1)).await; let [token_a, token_b] = onchain .deploy_tokens_with_weth_uni_v2_pools(to_wei(1_000), to_wei(1_000)) .await; // Fund trader, settlement accounts, and pool creation - token_a.mint(trader.address(), to_wei(100)).await; + token_a.mint(trader.address(), eth(100)).await; token_b - .mint( - onchain.contracts().gp_settlement.address().into_legacy(), - to_wei(5), - ) + .mint(*onchain.contracts().gp_settlement.address(), eth(5)) .await; - token_a.mint(solver.address(), to_wei(1000)).await; - token_b.mint(solver.address(), to_wei(1000)).await; + token_a.mint(solver.address(), eth(1000)).await; + token_b.mint(solver.address(), eth(1000)).await; // Approve GPv2 for trading token_a .approve(onchain.contracts().allowance.into_alloy(), eth(100)) - .from(trader.address().into_alloy()) + .from(trader.address()) .send_and_watch() .await .unwrap(); @@ -112,12 +109,7 @@ async fn onchain_settlement_without_liquidity(web3: Web3) { tracing::info!("waiting for first trade"); onchain.mint_block().await; let trade_happened = || async { - token_b - .balanceOf(trader.address().into_alloy()) - .call() - .await - .unwrap() - == order.buy_amount.into_alloy() + token_b.balanceOf(trader.address()).call().await.unwrap() == order.buy_amount.into_alloy() }; wait_for_condition(TIMEOUT, trade_happened).await.unwrap(); @@ -145,11 +137,7 @@ async fn onchain_settlement_without_liquidity(web3: Web3) { tracing::info!("waiting for second trade"); let trade_happened = || async { onchain.mint_block().await; - token_b - .balanceOf(trader.address().into_alloy()) - .call() - .await - .unwrap() + token_b.balanceOf(trader.address()).call().await.unwrap() == (order.buy_amount.into_alloy() * U256::from(2)) }; wait_for_condition(TIMEOUT, trade_happened).await.unwrap(); diff --git a/crates/e2e/tests/e2e/cow_amm.rs b/crates/e2e/tests/e2e/cow_amm.rs index 459c6a91b0..3eeff7f5cc 100644 --- a/crates/e2e/tests/e2e/cow_amm.rs +++ b/crates/e2e/tests/e2e/cow_amm.rs @@ -57,8 +57,8 @@ async fn local_node_cow_amm_jit() { async fn cow_amm_jit(web3: Web3) { let mut onchain = OnchainComponents::deploy(web3.clone()).await; - let [solver] = onchain.make_solvers(to_wei(100)).await; - let [bob, cow_amm_owner] = onchain.make_accounts(to_wei(1000)).await; + let [solver] = onchain.make_solvers(eth(100)).await; + let [bob, cow_amm_owner] = onchain.make_accounts(eth(1000)).await; let [dai] = onchain .deploy_tokens_with_weth_uni_v2_pools(to_wei(300_000), to_wei(100)) @@ -67,11 +67,8 @@ async fn cow_amm_jit(web3: Web3) { // Fund the buffers with a lot of buy tokens so we can pay out the required // tokens for 2 orders in the same direction without having to worry about // getting the liquidity on-chain. - dai.mint( - onchain.contracts().gp_settlement.address().into_legacy(), - to_wei(100_000), - ) - .await; + dai.mint(*onchain.contracts().gp_settlement.address(), eth(100_000)) + .await; // set up cow_amm let oracle = @@ -88,10 +85,10 @@ async fn cow_amm_jit(web3: Web3) { .unwrap(); // Fund cow amm owner with 2_000 dai and allow factory take them - dai.mint(cow_amm_owner.address(), to_wei(2_000)).await; + dai.mint(cow_amm_owner.address(), eth(2_000)).await; dai.approve(*cow_amm_factory.address(), eth(2_000)) - .from(cow_amm_owner.address().into_alloy()) + .from(cow_amm_owner.address()) .send_and_watch() .await .unwrap(); @@ -101,7 +98,7 @@ async fn cow_amm_jit(web3: Web3) { .weth .deposit() .value(eth(1)) - .from(cow_amm_owner.address().into_alloy()) + .from(cow_amm_owner.address()) .send_and_watch() .await .unwrap(); @@ -109,7 +106,7 @@ async fn cow_amm_jit(web3: Web3) { .contracts() .weth .approve(*cow_amm_factory.address(), eth(1)) - .from(cow_amm_owner.address().into_alloy()) + .from(cow_amm_owner.address()) .send_and_watch() .await .unwrap(); @@ -124,7 +121,7 @@ async fn cow_amm_jit(web3: Web3) { let cow_amm = cow_amm_factory .ammDeterministicAddress( - cow_amm_owner.address().into_alloy(), + cow_amm_owner.address(), *dai.address(), *onchain.contracts().weth.address(), ) @@ -139,9 +136,9 @@ async fn cow_amm_jit(web3: Web3) { cow_amm_factory .create( *dai.address(), - to_wei(2_000).into_alloy(), + eth(2_000), *onchain.contracts().weth.address(), - to_wei(1).into_alloy(), + eth(1), U256::ZERO, // min traded token *oracle.address(), Bytes::copy_from_slice(&oracle_data), @@ -223,7 +220,7 @@ async fn cow_amm_jit(web3: Web3) { buyToken: *dai.address(), receiver: Default::default(), sellAmount: U256::from(10).pow(U256::from(17)), - buyAmount: to_wei(230).into_alloy(), + buyAmount: eth(230), validTo: valid_to, appData: FixedBytes(APP_DATA), feeAmount: U256::ZERO, @@ -272,7 +269,7 @@ async fn cow_amm_jit(web3: Web3) { .contracts() .weth .deposit() - .from(bob.address().into_alloy()) + .from(bob.address()) .value(alloy::primitives::U256::from(10u64.pow(17))) .send_and_watch() .await @@ -284,7 +281,7 @@ async fn cow_amm_jit(web3: Web3) { onchain.contracts().allowance.into_alloy(), alloy::primitives::U256::MAX, ) - .from(bob.address().into_alloy()) + .from(bob.address()) .send_and_watch() .await .unwrap(); @@ -307,11 +304,7 @@ async fn cow_amm_jit(web3: Web3) { let user_order_id = services.create_order(&user_order).await.unwrap(); let amm_balance_before = dai.balanceOf(*cow_amm.address()).call().await.unwrap(); - let bob_balance_before = dai - .balanceOf(bob.address().into_alloy()) - .call() - .await - .unwrap(); + let bob_balance_before = dai.balanceOf(bob.address()).call().await.unwrap(); let fee = ethcontract::U256::exp10(16); // 0.01 WETH @@ -364,11 +357,7 @@ async fn cow_amm_jit(web3: Web3) { onchain.mint_block().await; wait_for_condition(TIMEOUT, || async { let amm_balance = dai.balanceOf(*cow_amm.address()).call().await.unwrap(); - let bob_balance = dai - .balanceOf(bob.address().into_alloy()) - .call() - .await - .unwrap(); + let bob_balance = dai.balanceOf(bob.address()).call().await.unwrap(); let amm_received = amm_balance - amm_balance_before; let bob_received = bob_balance - bob_balance_before; @@ -413,8 +402,8 @@ async fn cow_amm_driver_support(web3: Web3) { }; let mut onchain = OnchainComponents::deployed_with(web3.clone(), deployed_contracts).await; - let [solver] = onchain.make_solvers_forked(to_wei(11)).await; - let [trader] = onchain.make_accounts(to_wei(1)).await; + let [solver] = onchain.make_solvers_forked(eth(11)).await; + let [trader] = onchain.make_accounts(eth(1)).await; // find some USDC available onchain const USDC_WHALE_MAINNET: Address = address!("28c6c06298d514db089934071355e5743bf21d60"); @@ -453,7 +442,7 @@ async fn cow_amm_driver_support(web3: Web3) { .contracts() .weth .deposit() - .from(solver.address().into_alloy()) + .from(solver.address()) .value(weth_to_send) .send_and_watch() .await @@ -462,7 +451,7 @@ async fn cow_amm_driver_support(web3: Web3) { .contracts() .weth .transfer(USDC_WETH_COW_AMM.into_alloy(), weth_to_send) - .from(solver.address().into_alloy()) + .from(solver.address()) .send_and_watch() .await .unwrap(); @@ -480,12 +469,9 @@ async fn cow_amm_driver_support(web3: Web3) { // Give trader some USDC web3.alloy .anvil_send_impersonated_transaction_with_config( - usdc.transfer( - trader.address().into_alloy(), - to_wei_with_exp(1000, 6).into_alloy(), - ) - .from(USDC_WHALE_MAINNET) - .into_transaction_request(), + usdc.transfer(trader.address(), to_wei_with_exp(1000, 6).into_alloy()) + .from(USDC_WHALE_MAINNET) + .into_transaction_request(), ImpersonateConfig { fund_amount: None, stop_impersonate: true, @@ -502,7 +488,7 @@ async fn cow_amm_driver_support(web3: Web3) { onchain.contracts().allowance.into_alloy(), to_wei_with_exp(1000, 6).into_alloy(), ) - .from(trader.address().into_alloy()) + .from(trader.address()) .send_and_watch() .await .unwrap(); @@ -714,8 +700,8 @@ async fn local_node_cow_amm_opposite_direction() { async fn cow_amm_opposite_direction(web3: Web3) { let mut onchain = OnchainComponents::deploy(web3.clone()).await; - let [solver] = onchain.make_solvers(to_wei(100)).await; - let [bob, cow_amm_owner] = onchain.make_accounts(to_wei(1000)).await; + let [solver] = onchain.make_solvers(eth(100)).await; + let [bob, cow_amm_owner] = onchain.make_accounts(eth(1000)).await; let [dai] = onchain .deploy_tokens_with_weth_uni_v2_pools(to_wei(300_000), to_wei(100)) @@ -740,10 +726,10 @@ async fn cow_amm_opposite_direction(web3: Web3) { // Fund the CoW AMM owner with DAI and WETH and approve the factory to transfer // them - dai.mint(cow_amm_owner.address(), to_wei(2_000)).await; + dai.mint(cow_amm_owner.address(), eth(2_000)).await; dai.approve(*cow_amm_factory.address(), eth(2_000)) - .from(cow_amm_owner.address().into_alloy()) + .from(cow_amm_owner.address()) .send_and_watch() .await .unwrap(); @@ -752,7 +738,7 @@ async fn cow_amm_opposite_direction(web3: Web3) { .contracts() .weth .deposit() - .from(cow_amm_owner.address().into_alloy()) + .from(cow_amm_owner.address()) .value(eth(1)) .send_and_watch() .await @@ -761,7 +747,7 @@ async fn cow_amm_opposite_direction(web3: Web3) { .contracts() .weth .approve(*cow_amm_factory.address(), eth(1)) - .from(cow_amm_owner.address().into_alloy()) + .from(cow_amm_owner.address()) .send_and_watch() .await .unwrap(); @@ -770,7 +756,7 @@ async fn cow_amm_opposite_direction(web3: Web3) { .contracts() .weth .deposit() - .from(solver.address().into_alloy()) + .from(solver.address()) .value(eth(1)) .send_and_watch() .await @@ -786,7 +772,7 @@ async fn cow_amm_opposite_direction(web3: Web3) { let cow_amm_address = cow_amm_factory .ammDeterministicAddress( - cow_amm_owner.address().into_alloy(), + cow_amm_owner.address(), *dai.address(), *onchain.contracts().weth.address(), ) @@ -802,9 +788,9 @@ async fn cow_amm_opposite_direction(web3: Web3) { cow_amm_factory .create( *dai.address(), - to_wei(2_000).into_alloy(), + eth(2_000), *onchain.contracts().weth.address(), - to_wei(1).into_alloy(), + eth(1), U256::ZERO, // min traded token *oracle.address(), Bytes::copy_from_slice(&oracle_data), @@ -923,13 +909,13 @@ async fn cow_amm_opposite_direction(web3: Web3) { }; // Fund trader "bob" with DAI and approve allowance - dai.mint(bob.address(), to_wei(250)).await; + dai.mint(bob.address(), eth(250)).await; dai.approve( onchain.contracts().allowance.into_alloy(), alloy::primitives::U256::MAX, ) - .from(bob.address().into_alloy()) + .from(bob.address()) .send_and_watch() .await .unwrap(); @@ -945,7 +931,7 @@ async fn cow_amm_opposite_direction(web3: Web3) { let bob_weth_balance_before = onchain .contracts() .weth - .balanceOf(bob.address().into_alloy()) + .balanceOf(bob.address()) .call() .await .unwrap(); @@ -1008,7 +994,7 @@ async fn cow_amm_opposite_direction(web3: Web3) { mock_solver.configure_solution(Some(mocked_quote_solution)); let quote_request = OrderQuoteRequest { - from: bob.address().into_alloy(), + from: bob.address(), sell_token: *dai.address(), buy_token: *onchain.contracts().weth.address(), side: OrderQuoteSide::Sell { @@ -1022,16 +1008,19 @@ async fn cow_amm_opposite_direction(web3: Web3) { // Must align with the mocked_solutions. let quote_response = services.submit_quote("e_request).await.unwrap(); assert!(quote_response.verified); - assert_eq!(quote_response.quote.sell_token, dai.address().into_legacy()); + assert_eq!(quote_response.quote.sell_token, *dai.address()); assert_eq!( quote_response.quote.buy_token, - onchain.contracts().weth.address().into_legacy() + *onchain.contracts().weth.address() ); // Ensure the amounts are the same as the solution proposes. - assert_eq!(quote_response.quote.sell_amount, executed_amount); + assert_eq!( + quote_response.quote.sell_amount, + executed_amount.into_alloy() + ); assert_eq!( quote_response.quote.buy_amount, - ethcontract::U256::exp10(17) + U256::from(10).pow(U256::from(17)) ); // Place user order where bob sells DAI to buy WETH (opposite direction) @@ -1070,7 +1059,7 @@ async fn cow_amm_opposite_direction(web3: Web3) { let bob_weth_balance_after = onchain .contracts() .weth - .balanceOf(bob.address().into_alloy()) + .balanceOf(bob.address()) .call() .await .unwrap(); diff --git a/crates/e2e/tests/e2e/eth_integration.rs b/crates/e2e/tests/e2e/eth_integration.rs index b9e97b2ee6..23b2cdd7f4 100644 --- a/crates/e2e/tests/e2e/eth_integration.rs +++ b/crates/e2e/tests/e2e/eth_integration.rs @@ -25,33 +25,37 @@ async fn local_node_eth_integration() { async fn eth_integration(web3: Web3) { let mut onchain = OnchainComponents::deploy(web3.clone()).await; - let [solver] = onchain.make_solvers(to_wei(1)).await; - let [trader_a, trader_b] = onchain.make_accounts(to_wei(1)).await; + let [solver] = onchain.make_solvers(eth(1)).await; + let [trader_a, trader_b] = onchain.make_accounts(eth(1)).await; // Create & mint tokens to trade, pools for fee connections let [token] = onchain .deploy_tokens_with_weth_uni_v2_pools(to_wei(100_000), to_wei(100_000)) .await; - token.mint(trader_a.address(), to_wei(51)).await; - token.mint(trader_b.address(), to_wei(51)).await; + token.mint(trader_a.address(), eth(51)).await; + token.mint(trader_b.address(), eth(51)).await; // Approve GPv2 for trading token .approve(onchain.contracts().allowance.into_alloy(), eth(51)) - .from(trader_a.address().into_alloy()) + .from(trader_a.address()) .send_and_watch() .await .unwrap(); token .approve(onchain.contracts().allowance.into_alloy(), eth(51)) - .from(trader_b.address().into_alloy()) + .from(trader_b.address()) .send_and_watch() .await .unwrap(); - let trader_a_eth_balance_before = web3.eth().balance(trader_a.address(), None).await.unwrap(); + let trader_a_eth_balance_before = web3 + .eth() + .balance(trader_a.address().into_legacy(), None) + .await + .unwrap(); let services = Services::new(&onchain).await; services.start_protocol(solver).await; @@ -121,8 +125,16 @@ async fn eth_integration(web3: Web3) { tracing::info!("Waiting for trade."); onchain.mint_block().await; let trade_happened = || async { - let balance_a = web3.eth().balance(trader_a.address(), None).await.unwrap(); - let balance_b = web3.eth().balance(trader_b.address(), None).await.unwrap(); + let balance_a = web3 + .eth() + .balance(trader_a.address().into_legacy(), None) + .await + .unwrap(); + let balance_b = web3 + .eth() + .balance(trader_b.address().into_legacy(), None) + .await + .unwrap(); let trader_a_eth_decreased = (balance_a - trader_a_eth_balance_before) == to_wei(49); let trader_b_eth_increased = balance_b >= to_wei(49); diff --git a/crates/e2e/tests/e2e/eth_safe.rs b/crates/e2e/tests/e2e/eth_safe.rs index c23ae7eacd..b3569ce341 100644 --- a/crates/e2e/tests/e2e/eth_safe.rs +++ b/crates/e2e/tests/e2e/eth_safe.rs @@ -31,25 +31,25 @@ async fn test(web3: Web3) { tracing::info!("Setting up chain state."); let mut onchain = OnchainComponents::deploy(web3.clone()).await; - let [solver] = onchain.make_solvers(to_wei(10)).await; - let [trader] = onchain.make_accounts(to_wei(10)).await; + let [solver] = onchain.make_solvers(eth(10)).await; + let [trader] = onchain.make_accounts(eth(10)).await; let safe = Safe::deploy(trader.clone(), web3.alloy.clone()).await; let [token] = onchain .deploy_tokens_with_weth_uni_v2_pools(to_wei(1000), to_wei(1000)) .await; - token.mint(trader.address(), to_wei(4)).await; + token.mint(trader.address(), eth(4)).await; safe.exec_alloy_call( token .approve(onchain.contracts().allowance.into_alloy(), eth(4)) .into_transaction_request(), ) .await; - token.mint(safe.address().into_legacy(), to_wei(4)).await; + token.mint(safe.address(), eth(4)).await; token .approve(onchain.contracts().allowance.into_alloy(), eth(4)) - .from(trader.address().into_alloy()) + .from(trader.address()) .send_and_watch() .await .unwrap(); diff --git a/crates/e2e/tests/e2e/ethflow.rs b/crates/e2e/tests/e2e/ethflow.rs index 5b961461c4..726f2ab758 100644 --- a/crates/e2e/tests/e2e/ethflow.rs +++ b/crates/e2e/tests/e2e/ethflow.rs @@ -1,6 +1,6 @@ use { alloy::{ - primitives::{Address, Bytes}, + primitives::{Address, Bytes, U256 as AlloyU256}, rpc::types::TransactionReceipt, }, anyhow::bail, @@ -93,8 +93,8 @@ async fn local_node_eth_flow_zero_buy_amount() { async fn eth_flow_tx(web3: Web3) { let mut onchain = OnchainComponents::deploy(web3.clone()).await; - let [solver] = onchain.make_solvers(to_wei(2)).await; - let [trader] = onchain.make_accounts(to_wei(2)).await; + let [solver] = onchain.make_solvers(eth(2)).await; + let [trader] = onchain.make_accounts(eth(2)).await; // Create token with Uniswap pool for price estimation let [dai] = onchain @@ -115,7 +115,7 @@ async fn eth_flow_tx(web3: Web3) { services.start_protocol(solver).await; let approve_call_data = { - let call_builder = dai.approve(trader.address().into_alloy(), eth(10)); + let call_builder = dai.approve(trader.address(), eth(10)); let calldata = call_builder.calldata(); const_hex::encode_prefixed(calldata) }; @@ -185,7 +185,7 @@ async fn eth_flow_tx(web3: Web3) { test_order_availability_in_api( &services, ðflow_order, - &trader.address().into_alloy(), + &trader.address(), onchain.contracts(), ethflow_contract, ) @@ -213,7 +213,7 @@ async fn eth_flow_tx(web3: Web3) { test_trade_availability_in_api( services.client(), ðflow_order, - &trader.address(), + &trader.address().into_legacy(), onchain.contracts(), ethflow_contract, ) @@ -224,7 +224,7 @@ async fn eth_flow_tx(web3: Web3) { // which proofs that the interactions were correctly sandboxed. let trampoline = *onchain.contracts().hooks.address(); let allowance = dai - .allowance(trampoline, trader.address().into_alloy()) + .allowance(trampoline, trader.address()) .call() .await .unwrap(); @@ -233,7 +233,7 @@ async fn eth_flow_tx(web3: Web3) { let allowance = onchain .contracts() .weth - .allowance(trampoline, trader.address().into_alloy()) + .allowance(trampoline, trader.address()) .call() .await .unwrap(); @@ -243,7 +243,7 @@ async fn eth_flow_tx(web3: Web3) { // able to set an allowance on behalf of the settlement contract. let settlement = onchain.contracts().gp_settlement.address(); let allowance = dai - .allowance(*settlement, trader.address().into_alloy()) + .allowance(*settlement, trader.address()) .call() .await .unwrap(); @@ -252,7 +252,7 @@ async fn eth_flow_tx(web3: Web3) { let allowance = onchain .contracts() .weth - .allowance(*settlement, trader.address().into_alloy()) + .allowance(*settlement, trader.address()) .call() .await .unwrap(); @@ -262,8 +262,8 @@ async fn eth_flow_tx(web3: Web3) { async fn eth_flow_without_quote(web3: Web3) { let mut onchain = OnchainComponents::deploy(web3.clone()).await; - let [solver] = onchain.make_solvers(to_wei(2)).await; - let [trader] = onchain.make_accounts(to_wei(2)).await; + let [solver] = onchain.make_solvers(eth(2)).await; + let [trader] = onchain.make_accounts(eth(2)).await; // Create token with Uniswap pool for price estimation let [dai] = onchain @@ -302,7 +302,7 @@ async fn eth_flow_without_quote(web3: Web3) { test_order_availability_in_api( &services, ðflow_order, - &trader.address().into_alloy(), + &trader.address(), onchain.contracts(), ethflow_contract, ) @@ -315,8 +315,8 @@ async fn eth_flow_without_quote(web3: Web3) { async fn eth_flow_indexing_after_refund(web3: Web3) { let mut onchain = OnchainComponents::deploy(web3.clone()).await; - let [solver] = onchain.make_solvers(to_wei(2)).await; - let [trader, dummy_trader] = onchain.make_accounts(to_wei(2)).await; + let [solver] = onchain.make_solvers(eth(2)).await; + let [trader, dummy_trader] = onchain.make_accounts(eth(2)).await; let [dai] = onchain .deploy_tokens_with_weth_uni_v2_pools(to_wei(DAI_PER_ETH * 1000), to_wei(1000)) .await; @@ -357,7 +357,7 @@ async fn eth_flow_indexing_after_refund(web3: Web3) { onchain.mint_block().await; dummy_order - .mine_order_invalidation(dummy_trader.address().into_alloy(), ethflow_contract) + .mine_order_invalidation(dummy_trader.address(), ethflow_contract) .await; // Create the actual order that should be picked up by the services and matched. @@ -417,9 +417,13 @@ async fn test_submit_quote( // Ideally the fee would be nonzero, but this is not the case in the test // environment assert_ne!(response.quote.fee_amount, 0.into()); // Amount is reasonable (±10% from real price) - let approx_output: U256 = response.quote.sell_amount * DAI_PER_ETH; - assert!(response.quote.buy_amount.gt(&(approx_output * 9u64 / 10))); - assert!(response.quote.buy_amount.lt(&(approx_output * 11u64 / 10))); + let approx_output: AlloyU256 = response.quote.sell_amount * AlloyU256::from(DAI_PER_ETH); + assert!( + response.quote.buy_amount > (approx_output * AlloyU256::from(9u64) / AlloyU256::from(10)) + ); + assert!( + response.quote.buy_amount < (approx_output * AlloyU256::from(11u64) / AlloyU256::from(10)) + ); let OrderQuoteSide::Sell { sell_amount: @@ -431,7 +435,10 @@ async fn test_submit_quote( panic!("untested!"); }; - assert_eq!(response.quote.sell_amount, sell_amount_after_fees.get()); + assert_eq!( + response.quote.sell_amount, + sell_amount_after_fees.get().into_alloy() + ); response } @@ -656,13 +663,10 @@ impl ExtendedEthFlowOrder { pub fn from_quote(quote_response: &OrderQuoteResponse, valid_to: u32) -> Self { let quote = "e_response.quote; ExtendedEthFlowOrder(CoWSwapEthFlow::EthFlowOrder::Data { - buyToken: quote.buy_token.into_alloy(), - receiver: quote - .receiver - .expect("eth-flow order without receiver") - .into_alloy(), - sellAmount: quote.sell_amount.into_alloy(), - buyAmount: quote.buy_amount.into_alloy(), + buyToken: quote.buy_token, + receiver: quote.receiver.expect("eth-flow order without receiver"), + sellAmount: quote.sell_amount, + buyAmount: quote.buy_amount, appData: quote.app_data.hash().0.into(), feeAmount: alloy::primitives::U256::ZERO, validTo: valid_to, // note: valid to in the quote is always unlimited @@ -876,8 +880,8 @@ impl EthFlowTradeIntent { async fn eth_flow_zero_buy_amount(web3: Web3) { let mut onchain = OnchainComponents::deploy(web3.clone()).await; - let [solver] = onchain.make_solvers(to_wei(2)).await; - let [trader_a, trader_b] = onchain.make_accounts(to_wei(2)).await; + let [solver] = onchain.make_solvers(eth(2)).await; + let [trader_a, trader_b] = onchain.make_accounts(eth(2)).await; // Create token with Uniswap pool for price estimation let [dai] = onchain @@ -917,7 +921,7 @@ async fn eth_flow_zero_buy_amount(web3: Web3) { test_order_availability_in_api( &services, ðflow_order, - &trader.address().into_alloy(), + &trader.address(), onchain.contracts(), ethflow_contract, ) diff --git a/crates/e2e/tests/e2e/hooks.rs b/crates/e2e/tests/e2e/hooks.rs index 29a406ac74..36868d0fa5 100644 --- a/crates/e2e/tests/e2e/hooks.rs +++ b/crates/e2e/tests/e2e/hooks.rs @@ -62,16 +62,16 @@ async fn local_node_quote_verification() { async fn gas_limit(web3: Web3) { let mut onchain = OnchainComponents::deploy(web3).await; - let [solver] = onchain.make_solvers(to_wei(1)).await; - let [trader] = onchain.make_accounts(to_wei(1)).await; + let [solver] = onchain.make_solvers(eth(1)).await; + let [trader] = onchain.make_accounts(eth(1)).await; let cow = onchain .deploy_cow_weth_pool(to_wei(1_000_000), to_wei(1_000), to_wei(1_000)) .await; // Fund trader accounts and approve relayer - cow.fund(trader.address(), to_wei(5)).await; + cow.fund(trader.address(), eth(5)).await; cow.approve(onchain.contracts().allowance.into_alloy(), eth(5)) - .from(trader.address().into_alloy()) + .from(trader.address()) .send_and_watch() .await .unwrap(); @@ -91,7 +91,7 @@ async fn gas_limit(web3: Web3) { "metadata": { "hooks": { "pre": [Hook { - target: trader.address().into_alloy(), + target: trader.address(), call_data: Default::default(), gas_limit: 8_000_000, }], @@ -116,14 +116,14 @@ async fn gas_limit(web3: Web3) { async fn allowance(web3: Web3) { let mut onchain = OnchainComponents::deploy(web3).await; - let [solver] = onchain.make_solvers(to_wei(1)).await; - let [trader] = onchain.make_accounts(to_wei(1)).await; + let [solver] = onchain.make_solvers(eth(1)).await; + let [trader] = onchain.make_accounts(eth(1)).await; let cow = onchain .deploy_cow_weth_pool(to_wei(1_000_000), to_wei(1_000), to_wei(1_000)) .await; // Fund trader accounts - cow.fund(trader.address(), to_wei(5)).await; + cow.fund(trader.address(), eth(5)).await; // Sign a permit pre-interaction for trading. let permit = cow @@ -133,8 +133,8 @@ async fn allowance(web3: Web3) { // the settlement contract. let steal_cow = { let tx = cow - .approve(trader.address().into_alloy(), alloy::primitives::U256::MAX) - .from(solver.address().into_alloy()); + .approve(trader.address(), alloy::primitives::U256::MAX) + .from(solver.address()); Hook { target: *cow.address(), call_data: tx.calldata().to_vec(), @@ -142,10 +142,10 @@ async fn allowance(web3: Web3) { } }; let steal_weth = { - let approve = onchain.contracts().weth.approve( - trader.address().into_alloy(), - ::alloy::primitives::U256::MAX, - ); + let approve = onchain + .contracts() + .weth + .approve(trader.address(), ::alloy::primitives::U256::MAX); Hook { target: *onchain.contracts().weth.address(), call_data: approve.calldata().to_vec(), @@ -184,16 +184,12 @@ async fn allowance(web3: Web3) { services.create_order(&order).await.unwrap(); onchain.mint_block().await; - let balance = cow - .balanceOf(trader.address().into_alloy()) - .call() - .await - .unwrap(); + let balance = cow.balanceOf(trader.address()).call().await.unwrap(); assert_eq!(balance, eth(5)); tracing::info!("Waiting for trade."); let trade_happened = || async { - cow.balanceOf(trader.address().into_alloy()) + cow.balanceOf(trader.address()) .call() .await .unwrap() @@ -205,7 +201,7 @@ async fn allowance(web3: Web3) { let balance = onchain .contracts() .weth - .balanceOf(trader.address().into_alloy()) + .balanceOf(trader.address()) .call() .await .unwrap(); @@ -219,7 +215,7 @@ async fn allowance(web3: Web3) { let allowance = cow .allowance( *onchain.contracts().gp_settlement.address(), - trader.address().into_alloy(), + trader.address(), ) .call() .await @@ -230,7 +226,7 @@ async fn allowance(web3: Web3) { .weth .allowance( *onchain.contracts().gp_settlement.address(), - trader.address().into_alloy(), + trader.address(), ) .call() .await @@ -241,10 +237,7 @@ async fn allowance(web3: Web3) { // This is OK since the `HooksTrampoline` contract is not used for holding // any funds. let allowance = cow - .allowance( - *onchain.contracts().hooks.address(), - trader.address().into_alloy(), - ) + .allowance(*onchain.contracts().hooks.address(), trader.address()) .call() .await .unwrap(); @@ -252,10 +245,7 @@ async fn allowance(web3: Web3) { let allowance = onchain .contracts() .weth - .allowance( - *onchain.contracts().hooks.address(), - trader.address().into_alloy(), - ) + .allowance(*onchain.contracts().hooks.address(), trader.address()) .call() .await .unwrap(); @@ -267,8 +257,8 @@ async fn signature(web3: Web3) { let chain_id = alloy::primitives::U256::from(web3.alloy.get_chain_id().await.unwrap()); - let [solver] = onchain.make_solvers(to_wei(1)).await; - let [trader] = onchain.make_accounts(to_wei(1)).await; + let [solver] = onchain.make_solvers(eth(1)).await; + let [trader] = onchain.make_accounts(eth(1)).await; let safe_infra = onchain_components::safe::Infrastructure::new(web3.alloy.clone()).await; @@ -279,7 +269,7 @@ async fn signature(web3: Web3) { safe_infra .singleton .setup( - vec![trader.address().into_alloy()], // owners + vec![trader.address()], // owners alloy::primitives::U256::ONE, // threshold alloy::primitives::Address::default(), // delegate call alloy::primitives::Bytes::default(), // delegate call bytes @@ -308,7 +298,7 @@ async fn signature(web3: Web3) { let [token] = onchain .deploy_tokens_with_weth_uni_v2_pools(to_wei(100_000), to_wei(100_000)) .await; - token.mint(safe.address().into_legacy(), to_wei(5)).await; + token.mint(safe.address(), eth(5)).await; // Sign an approval transaction for trading. This will be at nonce 0 because // it is the first transaction evah! @@ -429,8 +419,8 @@ async fn signature(web3: Web3) { async fn partial_fills(web3: Web3) { let mut onchain = OnchainComponents::deploy(web3.clone()).await; - let [solver] = onchain.make_solvers(to_wei(1)).await; - let [trader] = onchain.make_accounts(to_wei(3)).await; + let [solver] = onchain.make_solvers(eth(1)).await; + let [trader] = onchain.make_accounts(eth(3)).await; let counter = contracts::alloy::test::Counter::Instance::deploy(web3.alloy.clone()) .await @@ -443,44 +433,34 @@ async fn partial_fills(web3: Web3) { let sell_token = onchain.contracts().weth.clone(); sell_token .approve(onchain.contracts().allowance.into_alloy(), eth(2)) - .from(trader.address().into_alloy()) + .from(trader.address()) .send_and_watch() .await .unwrap(); sell_token .deposit() - .from(trader.address().into_alloy()) + .from(trader.address()) .value(eth(1)) .send_and_watch() .await .unwrap(); - let balance_before_first_trade = sell_token - .balanceOf(trader.address().into_alloy()) - .call() - .await - .unwrap(); + let balance_before_first_trade = sell_token.balanceOf(trader.address()).call().await.unwrap(); tracing::info!("Starting services."); let services = Services::new(&onchain).await; services.start_protocol(solver).await; - let pre_inc = counter.setCounterToBalance( - "pre".to_string(), - *sell_token.address(), - trader.address().into_alloy(), - ); + let pre_inc = + counter.setCounterToBalance("pre".to_string(), *sell_token.address(), trader.address()); let pre_hook = Hook { target: *counter.address(), call_data: pre_inc.calldata().to_vec(), gas_limit: pre_inc.estimate_gas().await.unwrap(), }; - let post_inc = counter.setCounterToBalance( - "post".to_string(), - *sell_token.address(), - trader.address().into_alloy(), - ); + let post_inc = + counter.setCounterToBalance("post".to_string(), *sell_token.address(), trader.address()); let post_hook = Hook { target: *counter.address(), call_data: post_inc.calldata().to_vec(), @@ -520,7 +500,7 @@ async fn partial_fills(web3: Web3) { tracing::info!("Waiting for first trade."); let trade_happened = || async { sell_token - .balanceOf(trader.address().into_alloy()) + .balanceOf(trader.address()) .call() .await .unwrap() @@ -531,11 +511,8 @@ async fn partial_fills(web3: Web3) { counter.counters("pre".to_string()).call().await.unwrap(), balance_before_first_trade ); - let post_balance_after_first_trade = sell_token - .balanceOf(trader.address().into_alloy()) - .call() - .await - .unwrap(); + let post_balance_after_first_trade = + sell_token.balanceOf(trader.address()).call().await.unwrap(); assert_eq!( counter.counters("post".to_string()).call().await.unwrap(), post_balance_after_first_trade @@ -544,7 +521,7 @@ async fn partial_fills(web3: Web3) { tracing::info!("Fund remaining sell balance."); sell_token .deposit() - .from(trader.address().into_alloy()) + .from(trader.address()) .value(eth(1)) .send_and_watch() .await @@ -558,11 +535,7 @@ async fn partial_fills(web3: Web3) { ); assert_eq!( counter.counters("post".to_string()).call().await.unwrap(), - sell_token - .balanceOf(trader.address().into_alloy()) - .call() - .await - .unwrap() + sell_token.balanceOf(trader.address()).call().await.unwrap() ); } @@ -573,8 +546,8 @@ async fn quote_verification(web3: Web3) { let chain_id = alloy::primitives::U256::from(web3.alloy.get_chain_id().await.unwrap()); - let [trader] = onchain.make_accounts(to_wei(1)).await; - let [solver] = onchain.make_solvers(to_wei(1)).await; + let [trader] = onchain.make_accounts(eth(1)).await; + let [solver] = onchain.make_solvers(eth(1)).await; let safe_infra = onchain_components::safe::Infrastructure::new(web3.alloy.clone()).await; @@ -585,7 +558,7 @@ async fn quote_verification(web3: Web3) { safe_infra .singleton .setup( - vec![trader.address().into_alloy()], // owners + vec![trader.address()], // owners alloy::primitives::U256::ONE, // threshold alloy::primitives::Address::default(), // delegate call alloy::primitives::Bytes::default(), // delegate call bytes @@ -609,11 +582,11 @@ async fn quote_verification(web3: Web3) { let [token] = onchain .deploy_tokens_with_weth_uni_v2_pools(to_wei(100_000), to_wei(100_000)) .await; - token.mint(safe.address().into_legacy(), to_wei(5)).await; + token.mint(safe.address(), eth(5)).await; token .approve(onchain.contracts().allowance.into_alloy(), eth(5)) - .from(trader.address().into_alloy()) + .from(trader.address()) .send_and_watch() .await .unwrap(); @@ -622,10 +595,7 @@ async fn quote_verification(web3: Web3) { // to fund the trade in a pre-hook. let transfer_builder = safe.sign_transaction( *token.address(), - token - .transfer(trader.address().into_alloy(), eth(5)) - .calldata() - .to_vec(), + token.transfer(trader.address(), eth(5)).calldata().to_vec(), alloy::primitives::U256::ZERO, ); let call_data = transfer_builder.calldata().to_vec(); @@ -647,7 +617,7 @@ async fn quote_verification(web3: Web3) { let quote = services .submit_quote(&OrderQuoteRequest { - from: trader.address().into_alloy(), + from: trader.address(), sell_token: *token.address(), buy_token: *onchain.contracts().weth.address(), side: OrderQuoteSide::Sell { diff --git a/crates/e2e/tests/e2e/jit_orders.rs b/crates/e2e/tests/e2e/jit_orders.rs index 52555d75d0..bfca8853e6 100644 --- a/crates/e2e/tests/e2e/jit_orders.rs +++ b/crates/e2e/tests/e2e/jit_orders.rs @@ -25,19 +25,19 @@ async fn local_node_single_limit_order() { async fn single_limit_order_test(web3: Web3) { let mut onchain = OnchainComponents::deploy(web3.clone()).await; - let [solver] = onchain.make_solvers(to_wei(100)).await; - let [trader] = onchain.make_accounts(to_wei(100)).await; + let [solver] = onchain.make_solvers(eth(100)).await; + let [trader] = onchain.make_accounts(eth(100)).await; let [token] = onchain .deploy_tokens_with_weth_uni_v2_pools(to_wei(300_000), to_wei(1_000)) .await; - token.mint(solver.address(), to_wei(100)).await; + token.mint(solver.address(), eth(100)).await; onchain .contracts() .weth .deposit() - .from(trader.address().into_alloy()) + .from(trader.address()) .value(eth(20)) .send_and_watch() .await @@ -47,14 +47,14 @@ async fn single_limit_order_test(web3: Web3) { .contracts() .weth .approve(onchain.contracts().allowance.into_alloy(), U256::MAX) - .from(trader.address().into_alloy()) + .from(trader.address()) .send_and_watch() .await .unwrap(); token .approve(onchain.contracts().allowance.into_alloy(), U256::MAX) - .from(solver.address().into_alloy()) + .from(solver.address()) .send_and_watch() .await .unwrap(); @@ -125,23 +125,15 @@ async fn single_limit_order_test(web3: Web3) { SecretKeyRef::from(&SecretKey::from_slice(trader.private_key()).unwrap()), ); - let trader_balance_before = token - .balanceOf(trader.address().into_alloy()) - .call() - .await - .unwrap(); - let solver_balance_before = token - .balanceOf(solver.address().into_alloy()) - .call() - .await - .unwrap(); + let trader_balance_before = token.balanceOf(trader.address()).call().await.unwrap(); + let solver_balance_before = token.balanceOf(solver.address()).call().await.unwrap(); let order_id = services.create_order(&order).await.unwrap(); let limit_order = services.get_order(&order_id).await.unwrap(); onchain.mint_block().await; assert_eq!(limit_order.metadata.class, OrderClass::Limit); let (jit_order, jit_order_uid) = JitOrder { - owner: trader.address(), + owner: trader.address().into_legacy(), sell: Asset { amount: to_wei(10), token: token.address().into_legacy(), @@ -154,7 +146,7 @@ async fn single_limit_order_test(web3: Web3) { partially_fillable: false, valid_to: model::time::now_in_epoch_seconds() + 300, app_data: Default::default(), - receiver: solver.address(), + receiver: solver.address().into_legacy(), } .sign( EcdsaSigningScheme::Eip712, @@ -194,16 +186,8 @@ async fn single_limit_order_test(web3: Web3) { tracing::info!("Waiting for trade."); onchain.mint_block().await; wait_for_condition(TIMEOUT, || async { - let trader_balance_after = token - .balanceOf(trader.address().into_alloy()) - .call() - .await - .unwrap(); - let solver_balance_after = token - .balanceOf(solver.address().into_alloy()) - .call() - .await - .unwrap(); + let trader_balance_after = token.balanceOf(trader.address()).call().await.unwrap(); + let solver_balance_after = token.balanceOf(solver.address()).call().await.unwrap(); let trader_balance_increased = trader_balance_after.saturating_sub(trader_balance_before) >= eth(5); diff --git a/crates/e2e/tests/e2e/limit_orders.rs b/crates/e2e/tests/e2e/limit_orders.rs index 7dfe8716cd..c3162d13d8 100644 --- a/crates/e2e/tests/e2e/limit_orders.rs +++ b/crates/e2e/tests/e2e/limit_orders.rs @@ -97,37 +97,37 @@ async fn forked_node_gnosis_single_limit_order() { async fn single_limit_order_test(web3: Web3) { let mut onchain = OnchainComponents::deploy(web3.clone()).await; - let [solver] = onchain.make_solvers(to_wei(1)).await; - let [trader_a] = onchain.make_accounts(to_wei(1)).await; + let [solver] = onchain.make_solvers(eth(1)).await; + let [trader_a] = onchain.make_accounts(eth(1)).await; let [token_a, token_b] = onchain .deploy_tokens_with_weth_uni_v2_pools(to_wei(1_000), to_wei(1_000)) .await; // Fund trader accounts - token_a.mint(trader_a.address(), to_wei(10)).await; + token_a.mint(trader_a.address(), eth(10)).await; // Create and fund Uniswap pool - token_a.mint(solver.address(), to_wei(1000)).await; - token_b.mint(solver.address(), to_wei(1000)).await; + token_a.mint(solver.address(), eth(1000)).await; + token_b.mint(solver.address(), eth(1000)).await; onchain .contracts() .uniswap_v2_factory .createPair(*token_a.address(), *token_b.address()) - .from(solver.address().into_alloy()) + .from(solver.address()) .send_and_watch() .await .unwrap(); token_a .approve(*onchain.contracts().uniswap_v2_router.address(), eth(1000)) - .from(solver.address().into_alloy()) + .from(solver.address()) .send_and_watch() .await .unwrap(); token_b .approve(*onchain.contracts().uniswap_v2_router.address(), eth(1000)) - .from(solver.address().into_alloy()) + .from(solver.address()) .send_and_watch() .await .unwrap(); @@ -141,10 +141,10 @@ async fn single_limit_order_test(web3: Web3) { eth(1000), U256::ZERO, U256::ZERO, - solver.address().into_alloy(), + solver.address(), U256::MAX, ) - .from(solver.address().into_alloy()) + .from(solver.address()) .send_and_watch() .await .unwrap(); @@ -153,7 +153,7 @@ async fn single_limit_order_test(web3: Web3) { token_a .approve(onchain.contracts().allowance.into_alloy(), eth(10)) - .from(trader_a.address().into_alloy()) + .from(trader_a.address()) .send_and_watch() .await .unwrap(); @@ -176,11 +176,7 @@ async fn single_limit_order_test(web3: Web3) { &onchain.contracts().domain_separator, SecretKeyRef::from(&SecretKey::from_slice(trader_a.private_key()).unwrap()), ); - let balance_before = token_b - .balanceOf(trader_a.address().into_alloy()) - .call() - .await - .unwrap(); + let balance_before = token_b.balanceOf(trader_a.address()).call().await.unwrap(); let order_id = services.create_order(&order).await.unwrap(); // we hide the quote's execution plan while the order is still fillable @@ -197,11 +193,7 @@ async fn single_limit_order_test(web3: Web3) { // Drive solution tracing::info!("Waiting for trade."); wait_for_condition(TIMEOUT, || async { - let balance_after = token_b - .balanceOf(trader_a.address().into_alloy()) - .call() - .await - .unwrap(); + let balance_after = token_b.balanceOf(trader_a.address()).call().await.unwrap(); balance_after.checked_sub(balance_before).unwrap() >= eth(5) }) .await @@ -220,38 +212,38 @@ async fn single_limit_order_test(web3: Web3) { async fn two_limit_orders_test(web3: Web3) { let mut onchain = OnchainComponents::deploy(web3.clone()).await; - let [solver] = onchain.make_solvers(to_wei(1)).await; - let [trader_a, trader_b] = onchain.make_accounts(to_wei(1)).await; + let [solver] = onchain.make_solvers(eth(1)).await; + let [trader_a, trader_b] = onchain.make_accounts(eth(1)).await; let [token_a, token_b] = onchain .deploy_tokens_with_weth_uni_v2_pools(to_wei(1_000), to_wei(1_000)) .await; // Fund trader accounts and prepare funding Uniswap pool - token_a.mint(trader_a.address(), to_wei(10)).await; - token_b.mint(trader_b.address(), to_wei(10)).await; - token_a.mint(solver.address(), to_wei(1_000)).await; - token_b.mint(solver.address(), to_wei(1_000)).await; + token_a.mint(trader_a.address(), eth(10)).await; + token_b.mint(trader_b.address(), eth(10)).await; + token_a.mint(solver.address(), eth(1_000)).await; + token_b.mint(solver.address(), eth(1_000)).await; // Create and fund Uniswap pool onchain .contracts() .uniswap_v2_factory .createPair(*token_a.address(), *token_b.address()) - .from(solver.address().into_alloy()) + .from(solver.address()) .send_and_watch() .await .unwrap(); token_a .approve(*onchain.contracts().uniswap_v2_router.address(), eth(1000)) - .from(solver.address().into_alloy()) + .from(solver.address()) .send_and_watch() .await .unwrap(); token_b .approve(*onchain.contracts().uniswap_v2_router.address(), eth(1000)) - .from(solver.address().into_alloy()) + .from(solver.address()) .send_and_watch() .await .unwrap(); @@ -265,10 +257,10 @@ async fn two_limit_orders_test(web3: Web3) { eth(1000), U256::ZERO, U256::ZERO, - solver.address().into_alloy(), + solver.address(), U256::MAX, ) - .from(solver.address().into_alloy()) + .from(solver.address()) .send_and_watch() .await .unwrap(); @@ -277,14 +269,14 @@ async fn two_limit_orders_test(web3: Web3) { token_a .approve(onchain.contracts().allowance.into_alloy(), eth(10)) - .from(trader_a.address().into_alloy()) + .from(trader_a.address()) .send_and_watch() .await .unwrap(); token_b .approve(onchain.contracts().allowance.into_alloy(), eth(10)) - .from(trader_b.address().into_alloy()) + .from(trader_b.address()) .send_and_watch() .await .unwrap(); @@ -308,16 +300,8 @@ async fn two_limit_orders_test(web3: Web3) { SecretKeyRef::from(&SecretKey::from_slice(trader_a.private_key()).unwrap()), ); - let balance_before_a = token_b - .balanceOf(trader_a.address().into_alloy()) - .call() - .await - .unwrap(); - let balance_before_b = token_a - .balanceOf(trader_b.address().into_alloy()) - .call() - .await - .unwrap(); + let balance_before_a = token_b.balanceOf(trader_a.address()).call().await.unwrap(); + let balance_before_b = token_a.balanceOf(trader_b.address()).call().await.unwrap(); let order_id = services.create_order(&order_a).await.unwrap(); onchain.mint_block().await; @@ -347,16 +331,8 @@ async fn two_limit_orders_test(web3: Web3) { // Drive solution tracing::info!("Waiting for trade."); wait_for_condition(TIMEOUT, || async { - let balance_after_a = token_b - .balanceOf(trader_a.address().into_alloy()) - .call() - .await - .unwrap(); - let balance_after_b = token_a - .balanceOf(trader_b.address().into_alloy()) - .call() - .await - .unwrap(); + let balance_after_a = token_b.balanceOf(trader_a.address()).call().await.unwrap(); + let balance_after_b = token_a.balanceOf(trader_b.address()).call().await.unwrap(); let order_a_settled = balance_after_a.saturating_sub(balance_before_a) >= eth(5); let order_b_settled = balance_after_b.saturating_sub(balance_before_b) >= eth(2); order_a_settled && order_b_settled @@ -368,15 +344,15 @@ async fn two_limit_orders_test(web3: Web3) { async fn two_limit_orders_multiple_winners_test(web3: Web3) { let mut onchain = OnchainComponents::deploy(web3).await; - let [solver_a, solver_b] = onchain.make_solvers(to_wei(1)).await; - let [trader_a, trader_b] = onchain.make_accounts(to_wei(1)).await; + let [solver_a, solver_b] = onchain.make_solvers(eth(1)).await; + let [trader_a, trader_b] = onchain.make_accounts(eth(1)).await; let [token_a, token_b, token_c, token_d] = onchain .deploy_tokens_with_weth_uni_v2_pools(to_wei(1_000), to_wei(1_000)) .await; // Fund traders - token_a.mint(trader_a.address(), to_wei(10)).await; - token_b.mint(trader_b.address(), to_wei(10)).await; + token_a.mint(trader_a.address(), eth(10)).await; + token_b.mint(trader_b.address(), eth(10)).await; // Create more liquid routes between token_a (token_b) and weth via base_a // (base_b). base_a has more liquidity than base_b, leading to the solver that @@ -385,24 +361,24 @@ async fn two_limit_orders_multiple_winners_test(web3: Web3) { .deploy_tokens_with_weth_uni_v2_pools(to_wei(10_000), to_wei(10_000)) .await; onchain - .seed_uni_v2_pool((&token_a, to_wei(100_000)), (&base_a, to_wei(100_000))) + .seed_uni_v2_pool((&token_a, eth(100_000)), (&base_a, eth(100_000))) .await; onchain - .seed_uni_v2_pool((&token_b, to_wei(10_000)), (&base_b, to_wei(10_000))) + .seed_uni_v2_pool((&token_b, eth(10_000)), (&base_b, eth(10_000))) .await; // Approve GPv2 for trading token_a .approve(onchain.contracts().allowance.into_alloy(), eth(100)) - .from(trader_a.address().into_alloy()) + .from(trader_a.address()) .send_and_watch() .await .unwrap(); token_b .approve(onchain.contracts().allowance.into_alloy(), eth(100)) - .from(trader_b.address().into_alloy()) + .from(trader_b.address()) .send_and_watch() .await .unwrap(); @@ -528,7 +504,7 @@ async fn two_limit_orders_multiple_winners_test(web3: Web3) { database::solver_competition_v2::fetch_solver_winning_solutions( &mut ex, competition.auction_id, - ByteArray(solver_a.address().0), + ByteArray(solver_a.address().into_legacy().0), ) .await .unwrap(); @@ -536,7 +512,7 @@ async fn two_limit_orders_multiple_winners_test(web3: Web3) { database::solver_competition_v2::fetch_solver_winning_solutions( &mut ex, competition.auction_id, - ByteArray(solver_b.address().0), + ByteArray(solver_b.address().into_legacy().0), ) .await .unwrap(); @@ -573,10 +549,10 @@ async fn two_limit_orders_multiple_winners_test(web3: Web3) { .unwrap(); assert_eq!(settlements.len(), 2); assert!(settlements.iter().any(|settlement| settlement.solver - == ByteArray(solver_a.address().0) + == ByteArray(solver_a.address().into_legacy().0) && settlement.solution_uid == solver_a_winning_solutions[0].uid)); assert!(settlements.iter().any(|settlement| settlement.solver - == ByteArray(solver_b.address().0) + == ByteArray(solver_b.address().into_legacy().0) && settlement.solution_uid == solver_b_winning_solutions[0].uid)); // Ensure all the reference scores are indexed @@ -591,11 +567,11 @@ async fn two_limit_orders_multiple_winners_test(web3: Web3) { // fetch the reference scores of both winners let solver_a_reference_score = reference_scores - .get(&ByteArray(solver_a.address().0)) + .get(&ByteArray(solver_a.address().into_legacy().0)) .unwrap() .clone(); let solver_b_reference_score = reference_scores - .get(&ByteArray(solver_b.address().0)) + .get(&ByteArray(solver_b.address().into_legacy().0)) .unwrap() .clone(); @@ -610,18 +586,18 @@ async fn two_limit_orders_multiple_winners_test(web3: Web3) { async fn too_many_limit_orders_test(web3: Web3) { let mut onchain = OnchainComponents::deploy(web3.clone()).await; - let [solver] = onchain.make_solvers(to_wei(1)).await; - let [trader] = onchain.make_accounts(to_wei(1)).await; + let [solver] = onchain.make_solvers(eth(1)).await; + let [trader] = onchain.make_accounts(eth(1)).await; let [token_a] = onchain .deploy_tokens_with_weth_uni_v2_pools(to_wei(1_000), to_wei(1_000)) .await; - token_a.mint(trader.address(), to_wei(1)).await; + token_a.mint(trader.address(), eth(1)).await; // Approve GPv2 for trading token_a .approve(onchain.contracts().allowance.into_alloy(), eth(101)) - .from(trader.address().into_alloy()) + .from(trader.address()) .send_and_watch() .await .unwrap(); @@ -692,18 +668,18 @@ async fn too_many_limit_orders_test(web3: Web3) { async fn limit_does_not_apply_to_in_market_orders_test(web3: Web3) { let mut onchain = OnchainComponents::deploy(web3.clone()).await; - let [solver] = onchain.make_solvers(to_wei(1)).await; - let [trader] = onchain.make_accounts(to_wei(1)).await; + let [solver] = onchain.make_solvers(eth(1)).await; + let [trader] = onchain.make_accounts(eth(1)).await; let [token] = onchain .deploy_tokens_with_weth_uni_v2_pools(to_wei(1_000), to_wei(1_000)) .await; - token.mint(trader.address(), to_wei(100)).await; + token.mint(trader.address(), eth(100)).await; // Approve GPv2 for trading token .approve(onchain.contracts().allowance.into_alloy(), eth(101)) - .from(trader.address().into_alloy()) + .from(trader.address()) .send_and_watch() .await .unwrap(); @@ -734,7 +710,7 @@ async fn limit_does_not_apply_to_in_market_orders_test(web3: Web3) { .await; let quote_request = OrderQuoteRequest { - from: trader.address().into_alloy(), + from: trader.address(), sell_token: *token.address(), buy_token: *onchain.contracts().weth.address(), side: OrderQuoteSide::Sell { @@ -749,9 +725,9 @@ async fn limit_does_not_apply_to_in_market_orders_test(web3: Web3) { // Place "in-market" order let order = OrderCreation { sell_token: token.address().into_legacy(), - sell_amount: quote.quote.sell_amount, + sell_amount: quote.quote.sell_amount.into_legacy(), buy_token: onchain.contracts().weth.address().into_legacy(), - buy_amount: quote.quote.buy_amount.saturating_sub(to_wei(4)), + buy_amount: quote.quote.buy_amount.saturating_sub(eth(4)).into_legacy(), valid_to: model::time::now_in_epoch_seconds() + 300, kind: OrderKind::Sell, ..Default::default() @@ -785,9 +761,9 @@ async fn limit_does_not_apply_to_in_market_orders_test(web3: Web3) { // Place another "in-market" order in order to check it is not limited let order = OrderCreation { sell_token: token.address().into_legacy(), - sell_amount: quote.quote.sell_amount, + sell_amount: quote.quote.sell_amount.into_legacy(), buy_token: onchain.contracts().weth.address().into_legacy(), - buy_amount: quote.quote.buy_amount.saturating_sub(to_wei(2)), + buy_amount: quote.quote.buy_amount.saturating_sub(eth(2)).into_legacy(), valid_to: model::time::now_in_epoch_seconds() + 300, kind: OrderKind::Sell, ..Default::default() @@ -823,9 +799,9 @@ async fn limit_does_not_apply_to_in_market_orders_test(web3: Web3) { async fn forked_mainnet_single_limit_order_test(web3: Web3) { let mut onchain = OnchainComponents::deployed(web3.clone()).await; - let [solver] = onchain.make_solvers_forked(to_wei(1)).await; + let [solver] = onchain.make_solvers_forked(eth(1)).await; - let [trader] = onchain.make_accounts(to_wei(1)).await; + let [trader] = onchain.make_accounts(eth(1)).await; let token_usdc = ERC20::Instance::new( address!("a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"), @@ -841,10 +817,7 @@ async fn forked_mainnet_single_limit_order_test(web3: Web3) { web3.alloy .anvil_send_impersonated_transaction_with_config( token_usdc - .transfer( - trader.address().into_alloy(), - to_wei_with_exp(1000, 6).into_alloy(), - ) + .transfer(trader.address(), to_wei_with_exp(1000, 6).into_alloy()) .from(USDC_WHALE_MAINNET) .into_transaction_request(), ImpersonateConfig { @@ -864,7 +837,7 @@ async fn forked_mainnet_single_limit_order_test(web3: Web3) { onchain.contracts().allowance.into_alloy(), to_wei_with_exp(1000, 6).into_alloy(), ) - .from(trader.address().into_alloy()) + .from(trader.address()) .send_and_watch() .await .unwrap(); @@ -905,16 +878,8 @@ async fn forked_mainnet_single_limit_order_test(web3: Web3) { }) .await; - let sell_token_balance_before = token_usdc - .balanceOf(trader.address().into_alloy()) - .call() - .await - .unwrap(); - let buy_token_balance_before = token_usdt - .balanceOf(trader.address().into_alloy()) - .call() - .await - .unwrap(); + let sell_token_balance_before = token_usdc.balanceOf(trader.address()).call().await.unwrap(); + let buy_token_balance_before = token_usdt.balanceOf(trader.address()).call().await.unwrap(); let order_id = services.create_order(&order).await.unwrap(); let limit_order = services.get_order(&order_id).await.unwrap(); assert_eq!(limit_order.metadata.class, OrderClass::Limit); @@ -924,16 +889,8 @@ async fn forked_mainnet_single_limit_order_test(web3: Web3) { wait_for_condition(TIMEOUT, || async { onchain.mint_block().await; - let sell_token_balance_after = token_usdc - .balanceOf(trader.address().into_alloy()) - .call() - .await - .unwrap(); - let buy_token_balance_after = token_usdt - .balanceOf(trader.address().into_alloy()) - .call() - .await - .unwrap(); + let sell_token_balance_after = token_usdc.balanceOf(trader.address()).call().await.unwrap(); + let buy_token_balance_after = token_usdt.balanceOf(trader.address()).call().await.unwrap(); (sell_token_balance_before > sell_token_balance_after) && (buy_token_balance_after @@ -946,9 +903,9 @@ async fn forked_mainnet_single_limit_order_test(web3: Web3) { async fn forked_gnosis_single_limit_order_test(web3: Web3) { let mut onchain = OnchainComponents::deployed(web3.clone()).await; - let [solver] = onchain.make_solvers_forked(to_wei(1)).await; + let [solver] = onchain.make_solvers_forked(eth(1)).await; - let [trader] = onchain.make_accounts(to_wei(1)).await; + let [trader] = onchain.make_accounts(eth(1)).await; let token_usdc = ERC20::Instance::new( address!("ddafbb505ad214d7b80b1f830fccc89b60fb7a83"), @@ -964,10 +921,7 @@ async fn forked_gnosis_single_limit_order_test(web3: Web3) { web3.alloy .anvil_send_impersonated_transaction_with_config( token_usdc - .transfer( - trader.address().into_alloy(), - to_wei_with_exp(1000, 6).into_alloy(), - ) + .transfer(trader.address(), to_wei_with_exp(1000, 6).into_alloy()) .from(USDC_WHALE_GNOSIS) .into_transaction_request(), ImpersonateConfig { @@ -987,7 +941,7 @@ async fn forked_gnosis_single_limit_order_test(web3: Web3) { onchain.contracts().allowance.into_alloy(), to_wei_with_exp(1000, 6).into_alloy(), ) - .from(trader.address().into_alloy()) + .from(trader.address()) .send_and_watch() .await .unwrap(); @@ -1010,13 +964,9 @@ async fn forked_gnosis_single_limit_order_test(web3: Web3) { &onchain.contracts().domain_separator, SecretKeyRef::from(&SecretKey::from_slice(trader.private_key()).unwrap()), ); - let sell_token_balance_before = token_usdc - .balanceOf(trader.address().into_alloy()) - .call() - .await - .unwrap(); + let sell_token_balance_before = token_usdc.balanceOf(trader.address()).call().await.unwrap(); let buy_token_balance_before = token_wxdai - .balanceOf(trader.address().into_alloy()) + .balanceOf(trader.address()) .call() .await .unwrap(); @@ -1028,13 +978,9 @@ async fn forked_gnosis_single_limit_order_test(web3: Web3) { // Drive solution tracing::info!("Waiting for trade."); wait_for_condition(TIMEOUT, || async { - let sell_token_balance_after = token_usdc - .balanceOf(trader.address().into_alloy()) - .call() - .await - .unwrap(); + let sell_token_balance_after = token_usdc.balanceOf(trader.address()).call().await.unwrap(); let buy_token_balance_after = token_wxdai - .balanceOf(trader.address().into_alloy()) + .balanceOf(trader.address()) .call() .await .unwrap(); @@ -1049,18 +995,18 @@ async fn forked_gnosis_single_limit_order_test(web3: Web3) { async fn no_liquidity_limit_order(web3: Web3) { let mut onchain = OnchainComponents::deploy(web3.clone()).await; - let [solver] = onchain.make_solvers(to_wei(10_000)).await; - let [trader_a] = onchain.make_accounts(to_wei(1)).await; + let [solver] = onchain.make_solvers(eth(10_000)).await; + let [trader_a] = onchain.make_accounts(eth(1)).await; let [token_a, unsupported] = onchain.deploy_tokens(solver.account()).await; // Fund trader accounts - token_a.mint(trader_a.address(), to_wei(10)).await; + token_a.mint(trader_a.address(), eth(10)).await; // Approve GPv2 for trading token_a .approve(onchain.contracts().allowance.into_alloy(), eth(10)) - .from(trader_a.address().into_alloy()) + .from(trader_a.address()) .send_and_watch() .await .unwrap(); @@ -1136,7 +1082,7 @@ async fn no_liquidity_limit_order(web3: Web3) { let balance_before = onchain .contracts() .weth - .balanceOf(trader_a.address().into_alloy()) + .balanceOf(trader_a.address()) .call() .await .unwrap(); @@ -1180,7 +1126,7 @@ async fn no_liquidity_limit_order(web3: Web3) { let balance_after = onchain .contracts() .weth - .balanceOf(trader_a.address().into_alloy()) + .balanceOf(trader_a.address()) .call() .await .unwrap(); diff --git a/crates/e2e/tests/e2e/liquidity.rs b/crates/e2e/tests/e2e/liquidity.rs index 31942b586d..98f3b775dd 100644 --- a/crates/e2e/tests/e2e/liquidity.rs +++ b/crates/e2e/tests/e2e/liquidity.rs @@ -15,13 +15,13 @@ use { TIMEOUT, TestAccount, colocation, + eth, run_forked_test_with_block_number, - to_wei, to_wei_with_exp, wait_for_condition, }, }, - ethcontract::{Account, H256, prelude::U256}, + ethcontract::{Account, H256}, ethrpc::{ Web3, alloy::{ @@ -58,8 +58,8 @@ async fn forked_node_zero_ex_liquidity_mainnet() { async fn zero_ex_liquidity(web3: Web3) { let mut onchain = OnchainComponents::deployed(web3.clone()).await; - let [solver] = onchain.make_solvers_forked(to_wei(1)).await; - let [trader, zeroex_maker] = onchain.make_accounts(to_wei(1)).await; + let [solver] = onchain.make_solvers_forked(eth(1)).await; + let [trader, zeroex_maker] = onchain.make_accounts(eth(1)).await; let token_usdc = ERC20::Instance::new( address!("a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"), @@ -83,7 +83,7 @@ async fn zero_ex_liquidity(web3: Web3) { web3.alloy .anvil_send_impersonated_transaction_with_config( token_usdc - .transfer(trader.address().into_alloy(), amount) + .transfer(trader.address(), amount) .from(USDC_WHALE) .into_transaction_request(), ImpersonateConfig { @@ -103,7 +103,7 @@ async fn zero_ex_liquidity(web3: Web3) { .anvil_send_impersonated_transaction_with_config( token_usdt .transfer( - zeroex_maker.address().into_alloy(), + zeroex_maker.address(), amount * alloy::primitives::U256::from(4), ) .from(USDT_WHALE) @@ -122,7 +122,7 @@ async fn zero_ex_liquidity(web3: Web3) { web3.alloy .anvil_send_impersonated_transaction_with_config( token_usdc - .transfer(solver.address().into_alloy(), amount) + .transfer(solver.address(), amount) .from(USDC_WHALE) .into_transaction_request(), ImpersonateConfig { @@ -138,20 +138,20 @@ async fn zero_ex_liquidity(web3: Web3) { token_usdc .approve(onchain.contracts().allowance.into_alloy(), amount) - .from(trader.address().into_alloy()) + .from(trader.address()) .send_and_watch() .await .unwrap(); // With a lower amount 0x contract shows much lower fillable amount token_usdt .approve(*zeroex.address(), amount * alloy::primitives::U256::from(4)) - .from(zeroex_maker.address().into_alloy()) + .from(zeroex_maker.address()) .send_and_watch() .await .unwrap(); token_usdc .approve(*zeroex.address(), amount) - .from(solver.address().into_alloy()) + .from(solver.address()) .send_and_watch() .await .unwrap(); @@ -221,16 +221,8 @@ async fn zero_ex_liquidity(web3: Web3) { .await; // Drive solution - let sell_token_balance_before = token_usdc - .balanceOf(trader.address().into_alloy()) - .call() - .await - .unwrap(); - let buy_token_balance_before = token_usdt - .balanceOf(trader.address().into_alloy()) - .call() - .await - .unwrap(); + let sell_token_balance_before = token_usdc.balanceOf(trader.address()).call().await.unwrap(); + let buy_token_balance_before = token_usdt.balanceOf(trader.address()).call().await.unwrap(); services.create_order(&order).await.unwrap(); onchain.mint_block().await; @@ -238,7 +230,7 @@ async fn zero_ex_liquidity(web3: Web3) { tracing::info!("Waiting for trade."); wait_for_condition(TIMEOUT, || async { token_usdc - .balanceOf(trader.address().into_alloy()) + .balanceOf(trader.address()) .call() .await .is_ok_and(|balance| balance < sell_token_balance_before) @@ -247,7 +239,7 @@ async fn zero_ex_liquidity(web3: Web3) { .unwrap(); wait_for_condition(TIMEOUT, || async { token_usdt - .balanceOf(trader.address().into_alloy()) + .balanceOf(trader.address()) .call() .await .is_ok_and(|balance| balance >= buy_token_balance_before + amount) @@ -274,8 +266,8 @@ async fn zero_ex_liquidity(web3: Web3) { // Fill the remaining part of the 0x order let zeroex_order = Eip712TypedZeroExOrder { - maker_token: token_usdt.address().into_legacy(), - taker_token: token_usdc.address().into_legacy(), + maker_token: *token_usdt.address(), + taker_token: *token_usdc.address(), maker_amount: zeroex_order_amounts.fillable, taker_amount: zeroex_order_amounts.fillable, // doesn't participate in the hash calculation @@ -284,10 +276,10 @@ async fn zero_ex_liquidity(web3: Web3) { maker: zeroex_maker.address(), taker: Default::default(), sender: Default::default(), - fee_recipient: zeroex.address().into_legacy(), - pool: H256::default(), + fee_recipient: *zeroex.address(), + pool: Default::default(), expiry: NaiveDateTime::MAX.and_utc().timestamp() as u64, - salt: U256::from(Utc::now().timestamp()), + salt: alloy::primitives::U256::from(Utc::now().timestamp()), } .to_order_record(chain_id, zeroex.address().into_legacy(), zeroex_maker); fill_or_kill_zeroex_limit_order(&zeroex, &zeroex_order, solver.account().clone()) @@ -314,8 +306,8 @@ fn create_zeroex_liquidity_orders( weth_address: H160, ) -> [shared::zeroex_api::OrderRecord; 3] { let typed_order = Eip712TypedZeroExOrder { - maker_token: order_creation.buy_token, - taker_token: order_creation.sell_token, + maker_token: order_creation.buy_token.into_alloy(), + taker_token: order_creation.sell_token.into_alloy(), // fully covers execution costs maker_amount: order_creation.buy_amount.as_u128() * 3, taker_amount: order_creation.sell_amount.as_u128() * 2, @@ -327,14 +319,14 @@ fn create_zeroex_liquidity_orders( // Makes it possible for anyone to fill the order taker: Default::default(), sender: Default::default(), - fee_recipient: zeroex_addr, - pool: H256::default(), + fee_recipient: zeroex_addr.into_alloy(), + pool: Default::default(), expiry: NaiveDateTime::MAX.and_utc().timestamp() as u64, - salt: U256::from(Utc::now().timestamp()), + salt: alloy::primitives::U256::from(Utc::now().timestamp()), }; let usdt_weth_order = Eip712TypedZeroExOrder { - maker_token: weth_address, - taker_token: order_creation.buy_token, + maker_token: weth_address.into_alloy(), + taker_token: order_creation.buy_token.into_alloy(), // the value comes from the `--amount-to-estimate-prices-with` config to provide // sufficient liquidity maker_amount: 1_000_000_000_000_000_000u128, @@ -344,14 +336,14 @@ fn create_zeroex_liquidity_orders( maker: zeroex_maker.address(), taker: Default::default(), sender: Default::default(), - fee_recipient: zeroex_addr, - pool: H256::default(), + fee_recipient: zeroex_addr.into_alloy(), + pool: Default::default(), expiry: NaiveDateTime::MAX.and_utc().timestamp() as u64, - salt: U256::from(Utc::now().timestamp()), + salt: alloy::primitives::U256::from(Utc::now().timestamp()), }; let usdc_weth_order = Eip712TypedZeroExOrder { - maker_token: weth_address, - taker_token: order_creation.sell_token, + maker_token: weth_address.into_alloy(), + taker_token: order_creation.sell_token.into_alloy(), // the value comes from the `--amount-to-estimate-prices-with` config to provide // sufficient liquidity maker_amount: 1_000_000_000_000_000_000u128, @@ -361,10 +353,10 @@ fn create_zeroex_liquidity_orders( maker: zeroex_maker.address(), taker: Default::default(), sender: Default::default(), - fee_recipient: zeroex_addr, - pool: H256::default(), + fee_recipient: zeroex_addr.into_alloy(), + pool: Default::default(), expiry: NaiveDateTime::MAX.and_utc().timestamp() as u64, - salt: U256::from(Utc::now().timestamp()), + salt: alloy::primitives::U256::from(Utc::now().timestamp()), }; [typed_order, usdt_weth_order, usdc_weth_order] .map(|order| order.to_order_record(chain_id, zeroex_addr, zeroex_maker.clone())) diff --git a/crates/e2e/tests/e2e/liquidity_source_notification.rs b/crates/e2e/tests/e2e/liquidity_source_notification.rs index 5575a180b4..6fa29f60a6 100644 --- a/crates/e2e/tests/e2e/liquidity_source_notification.rs +++ b/crates/e2e/tests/e2e/liquidity_source_notification.rs @@ -14,6 +14,7 @@ use { Services, TIMEOUT, colocation::{self, SolverEngine}, + eth, mock::Mock, run_forked_test_with_block_number, to_wei, @@ -65,11 +66,11 @@ async fn liquidity_source_notification(web3: Web3) { // Create parties accounts // solver - represents both baseline solver engine for quoting and liquorice // solver engine for solving - let [solver] = onchain.make_solvers_forked(to_wei(1)).await; + let [solver] = onchain.make_solvers_forked(eth(1)).await; // trader - the account that will place CoW order // liquorice_maker - the account that will place Liquorice order to fill CoW // order with - let [trader, liquorice_maker] = onchain.make_accounts(to_wei(1)).await; + let [trader, liquorice_maker] = onchain.make_accounts(eth(1)).await; // Access trade tokens contracts let token_usdc = ERC20::Instance::new( @@ -87,7 +88,7 @@ async fn liquidity_source_notification(web3: Web3) { web3.alloy .anvil_send_impersonated_transaction_with_config( token_usdc - .transfer(trader.address().into_alloy(), trade_amount.into_alloy()) + .transfer(trader.address(), trade_amount.into_alloy()) .from(USDC_WHALE) .into_transaction_request(), ImpersonateConfig { @@ -105,7 +106,7 @@ async fn liquidity_source_notification(web3: Web3) { web3.alloy .anvil_send_impersonated_transaction_with_config( token_usdc - .transfer(solver.address().into_alloy(), trade_amount.into_alloy()) + .transfer(solver.address(), trade_amount.into_alloy()) .from(USDC_WHALE) .into_transaction_request(), ImpersonateConfig { @@ -125,7 +126,7 @@ async fn liquidity_source_notification(web3: Web3) { onchain.contracts().allowance.into_alloy(), alloy::primitives::U256::MAX, ) - .from(trader.address().into_alloy()) + .from(trader.address()) .send_and_watch() .await .unwrap(); @@ -149,10 +150,7 @@ async fn liquidity_source_notification(web3: Web3) { web3.alloy .anvil_send_impersonated_transaction_with_config( token_usdt - .transfer( - liquorice_maker.address().into_alloy(), - trade_amount.into_alloy(), - ) + .transfer(liquorice_maker.address(), trade_amount.into_alloy()) .from(USDT_WHALE) .into_transaction_request(), ImpersonateConfig { @@ -172,7 +170,7 @@ async fn liquidity_source_notification(web3: Web3) { liquorice_balance_manager_address.into_alloy(), alloy::primitives::U256::MAX, ) - .from(liquorice_maker.address().into_alloy()) + .from(liquorice_maker.address()) .send_and_watch() .await .unwrap(); @@ -269,7 +267,7 @@ http-timeout = "10s" quoteTokenAmount: trade_amount.into_alloy(), minFillAmount: U256::from(1), quoteExpiry: U256::from(Utc::now().timestamp() as u64 + 10), - recipient: liquorice_maker.address().into_alloy(), + recipient: liquorice_maker.address(), }; // Create calldata @@ -287,7 +285,7 @@ http-timeout = "10s" // Create Liquorice settlement calldata liquorice_settlement .settleSingle( - liquorice_maker.address().into_alloy(), + liquorice_maker.address(), liquorice_order.clone(), LiquoriceSettlement::Signature::TypedSignature { signatureType: 3, // EIP712 diff --git a/crates/e2e/tests/e2e/order_cancellation.rs b/crates/e2e/tests/e2e/order_cancellation.rs index 9b00fb1e43..774c12d59b 100644 --- a/crates/e2e/tests/e2e/order_cancellation.rs +++ b/crates/e2e/tests/e2e/order_cancellation.rs @@ -1,7 +1,11 @@ use { + ::alloy::primitives::U256 as AlloyU256, database::order_events::OrderEventLabel, e2e::setup::{eth, *}, - ethrpc::alloy::{CallBuilderExt, conversions::IntoAlloy}, + ethrpc::alloy::{ + CallBuilderExt, + conversions::{IntoAlloy, IntoLegacy}, + }, model::{ order::{ CancellationPayload, @@ -32,19 +36,19 @@ async fn local_node_order_cancellation() { async fn order_cancellation(web3: Web3) { let mut onchain = OnchainComponents::deploy(web3).await; - let [solver] = onchain.make_solvers(to_wei(1)).await; - let [trader] = onchain.make_accounts(to_wei(1)).await; + let [solver] = onchain.make_solvers(eth(1)).await; + let [trader] = onchain.make_accounts(eth(1)).await; let [token] = onchain .deploy_tokens_with_weth_uni_v2_pools(to_wei(1_000), to_wei(1_000)) .await; - token.mint(trader.address(), to_wei(10)).await; + token.mint(trader.address(), eth(10)).await; // Approve GPv2 for trading token .approve(onchain.contracts().allowance.into_alloy(), eth(10)) - .from(trader.address().into_alloy()) + .from(trader.address()) .send_and_watch() .await .unwrap(); @@ -89,7 +93,7 @@ async fn order_cancellation(web3: Web3) { let trader = &trader; let request = OrderQuoteRequest { - from: trader.address().into_alloy(), + from: trader.address(), sell_token: *token.address(), buy_token: *onchain.contracts().weth.address(), side: OrderQuoteSide::Sell { @@ -107,11 +111,12 @@ async fn order_cancellation(web3: Web3) { let order = OrderCreation { kind: quote.kind, - sell_token: quote.sell_token, - sell_amount: quote.sell_amount, + sell_token: quote.sell_token.into_legacy(), + sell_amount: quote.sell_amount.into_legacy(), fee_amount: 0.into(), - buy_token: quote.buy_token, - buy_amount: (quote.buy_amount * 99) / 100, + buy_token: quote.buy_token.into_legacy(), + buy_amount: ((quote.buy_amount * AlloyU256::from(99)) / AlloyU256::from(100)) + .into_legacy(), valid_to: quote.valid_to, app_data: quote.app_data, ..Default::default() diff --git a/crates/e2e/tests/e2e/partial_fill.rs b/crates/e2e/tests/e2e/partial_fill.rs index 5779dce5df..81f017ac51 100644 --- a/crates/e2e/tests/e2e/partial_fill.rs +++ b/crates/e2e/tests/e2e/partial_fill.rs @@ -25,8 +25,8 @@ async fn test(web3: Web3) { tracing::info!("Setting up chain state."); let mut onchain = OnchainComponents::deploy(web3).await; - let [solver] = onchain.make_solvers(to_wei(10)).await; - let [trader] = onchain.make_accounts(to_wei(10)).await; + let [solver] = onchain.make_solvers(eth(10)).await; + let [trader] = onchain.make_accounts(eth(10)).await; // Use a shallow pool to make partial fills easier to setup. let [token] = onchain .deploy_tokens_with_weth_uni_v2_pools(to_wei(10), to_wei(10)) @@ -36,7 +36,7 @@ async fn test(web3: Web3) { .contracts() .weth .approve(onchain.contracts().allowance.into_alloy(), eth(4)) - .from(trader.address().into_alloy()) + .from(trader.address()) .send_and_watch() .await .unwrap(); @@ -44,7 +44,7 @@ async fn test(web3: Web3) { .contracts() .weth .deposit() - .from(trader.address().into_alloy()) + .from(trader.address()) .value(eth(4)) .send_and_watch() .await @@ -55,11 +55,7 @@ async fn test(web3: Web3) { services.start_protocol(solver.clone()).await; tracing::info!("Placing order"); - let balance = token - .balanceOf(trader.address().into_alloy()) - .call() - .await - .unwrap(); + let balance = token.balanceOf(trader.address()).call().await.unwrap(); assert_eq!(balance, U256::ZERO); let order = OrderCreation { sell_token: onchain.contracts().weth.address().into_legacy(), @@ -83,12 +79,12 @@ async fn test(web3: Web3) { tracing::info!("Waiting for trade."); let trade_happened = || async { - token - .balanceOf(trader.address().into_alloy()) + !token + .balanceOf(trader.address()) .call() .await .unwrap() - != U256::ZERO + .is_zero() }; wait_for_condition(TIMEOUT, trade_happened).await.unwrap(); @@ -96,7 +92,7 @@ async fn test(web3: Web3) { let sell_balance = onchain .contracts() .weth - .balanceOf(trader.address().into_alloy()) + .balanceOf(trader.address()) .call() .await .unwrap(); @@ -105,11 +101,7 @@ async fn test(web3: Web3) { (1_999_000_000_000_000_000_u128..2_000_000_000_000_000_000_u128) .contains(&u128::try_from(sell_balance).unwrap()) ); - let buy_balance = token - .balanceOf(trader.address().into_alloy()) - .call() - .await - .unwrap(); + let buy_balance = token.balanceOf(trader.address()).call().await.unwrap(); assert!( (1_650_000_000_000_000_000_u128..1_670_000_000_000_000_000_u128) .contains(&u128::try_from(buy_balance).unwrap()) diff --git a/crates/e2e/tests/e2e/partially_fillable_balance.rs b/crates/e2e/tests/e2e/partially_fillable_balance.rs index f8148a3b69..4d548d8a5a 100644 --- a/crates/e2e/tests/e2e/partially_fillable_balance.rs +++ b/crates/e2e/tests/e2e/partially_fillable_balance.rs @@ -23,35 +23,35 @@ async fn local_node_partially_fillable_balance() { async fn test(web3: Web3) { let mut onchain = OnchainComponents::deploy(web3).await; - let [solver] = onchain.make_solvers(to_wei(1)).await; - let [trader_a] = onchain.make_accounts(to_wei(1)).await; + let [solver] = onchain.make_solvers(eth(1)).await; + let [trader_a] = onchain.make_accounts(eth(1)).await; let [token_a, token_b] = onchain .deploy_tokens_with_weth_uni_v2_pools(to_wei(10_000), to_wei(10_000)) .await; - token_a.mint(trader_a.address(), to_wei(50)).await; - token_a.mint(solver.address(), to_wei(1000)).await; - token_b.mint(solver.address(), to_wei(1000)).await; + token_a.mint(trader_a.address(), eth(50)).await; + token_a.mint(solver.address(), eth(1000)).await; + token_b.mint(solver.address(), eth(1000)).await; onchain .contracts() .uniswap_v2_factory .createPair(*token_a.address(), *token_b.address()) - .from(solver.address().into_alloy()) + .from(solver.address()) .send_and_watch() .await .unwrap(); token_a .approve(*onchain.contracts().uniswap_v2_router.address(), eth(1000)) - .from(solver.address().into_alloy()) + .from(solver.address()) .send_and_watch() .await .unwrap(); token_b .approve(*onchain.contracts().uniswap_v2_router.address(), eth(1000)) - .from(solver.address().into_alloy()) + .from(solver.address()) .send_and_watch() .await .unwrap(); @@ -65,17 +65,17 @@ async fn test(web3: Web3) { eth(1000), U256::ZERO, U256::ZERO, - solver.address().into_alloy(), + solver.address(), U256::MAX, ) - .from(solver.address().into_alloy()) + .from(solver.address()) .send_and_watch() .await .unwrap(); token_a .approve(onchain.contracts().allowance.into_alloy(), eth(500)) - .from(trader_a.address().into_alloy()) + .from(trader_a.address()) .send_and_watch() .await .unwrap(); @@ -106,11 +106,7 @@ async fn test(web3: Web3) { tracing::info!("Waiting for trade."); wait_for_condition(TIMEOUT, || async { - let balance = token_b - .balanceOf(trader_a.address().into_alloy()) - .call() - .await - .unwrap(); + let balance = token_b.balanceOf(trader_a.address()).call().await.unwrap(); !balance.is_zero() }) .await @@ -118,18 +114,10 @@ async fn test(web3: Web3) { // Expecting a partial fill because order sells 100 but user only has balance of // 50. - let sell_balance = token_a - .balanceOf(trader_a.address().into_alloy()) - .call() - .await - .unwrap(); + let sell_balance = token_a.balanceOf(trader_a.address()).call().await.unwrap(); // Depending on how the solver works might not have sold all balance. assert!(U256::ZERO <= sell_balance && sell_balance < U256::from(10u64.pow(18))); - let buy_balance = token_b - .balanceOf(trader_a.address().into_alloy()) - .call() - .await - .unwrap(); + let buy_balance = token_b.balanceOf(trader_a.address()).call().await.unwrap(); // We don't know exact buy balance because of the fee. assert!( U256::from(45) * U256::from(10u64.pow(18)) <= buy_balance diff --git a/crates/e2e/tests/e2e/partially_fillable_pool.rs b/crates/e2e/tests/e2e/partially_fillable_pool.rs index 6d39aee755..db8f925b49 100644 --- a/crates/e2e/tests/e2e/partially_fillable_pool.rs +++ b/crates/e2e/tests/e2e/partially_fillable_pool.rs @@ -22,35 +22,35 @@ async fn local_node_partially_fillable_pool() { async fn test(web3: Web3) { let mut onchain = OnchainComponents::deploy(web3).await; - let [solver] = onchain.make_solvers(to_wei(1)).await; - let [trader_a] = onchain.make_accounts(to_wei(1)).await; + let [solver] = onchain.make_solvers(eth(1)).await; + let [trader_a] = onchain.make_accounts(eth(1)).await; let [token_a, token_b] = onchain .deploy_tokens_with_weth_uni_v2_pools(to_wei(1_000), to_wei(1_000)) .await; - token_a.mint(trader_a.address(), to_wei(500)).await; - token_a.mint(solver.address(), to_wei(1000)).await; - token_b.mint(solver.address(), to_wei(1000)).await; + token_a.mint(trader_a.address(), eth(500)).await; + token_a.mint(solver.address(), eth(1000)).await; + token_b.mint(solver.address(), eth(1000)).await; onchain .contracts() .uniswap_v2_factory .createPair(*token_a.address(), *token_b.address()) - .from(solver.address().into_alloy()) + .from(solver.address()) .send_and_watch() .await .unwrap(); token_a .approve(*onchain.contracts().uniswap_v2_router.address(), eth(1000)) - .from(solver.address().into_alloy()) + .from(solver.address()) .send_and_watch() .await .unwrap(); token_b .approve(*onchain.contracts().uniswap_v2_router.address(), eth(1000)) - .from(solver.address().into_alloy()) + .from(solver.address()) .send_and_watch() .await .unwrap(); @@ -64,17 +64,17 @@ async fn test(web3: Web3) { eth(1000), U256::ZERO, U256::ZERO, - solver.address().into_alloy(), + solver.address(), U256::MAX, ) - .from(solver.address().into_alloy()) + .from(solver.address()) .send_and_watch() .await .unwrap(); token_a .approve(onchain.contracts().allowance.into_alloy(), eth(500)) - .from(trader_a.address().into_alloy()) + .from(trader_a.address()) .send_and_watch() .await .unwrap(); @@ -105,11 +105,7 @@ async fn test(web3: Web3) { tracing::info!("Waiting for trade."); wait_for_condition(TIMEOUT, || async { - let balance = token_b - .balanceOf(trader_a.address().into_alloy()) - .call() - .await - .unwrap(); + let balance = token_b.balanceOf(trader_a.address()).call().await.unwrap(); onchain.mint_block().await; !balance.is_zero() }) @@ -117,21 +113,13 @@ async fn test(web3: Web3) { .unwrap(); // Expecting a partial fill because the pool cannot trade the full amount. - let sell_balance = token_a - .balanceOf(trader_a.address().into_alloy()) - .call() - .await - .unwrap(); + let sell_balance = token_a.balanceOf(trader_a.address()).call().await.unwrap(); assert!( // Sell balance is strictly less than 250.0 because of the fee. (249_999_000_000_000_000_000_u128..250_000_000_000_000_000_000_u128) .contains(&u128::try_from(sell_balance).unwrap()) ); - let buy_balance = token_b - .balanceOf(trader_a.address().into_alloy()) - .call() - .await - .unwrap(); + let buy_balance = token_b.balanceOf(trader_a.address()).call().await.unwrap(); assert!( (199_000_000_000_000_000_000_u128..201_000_000_000_000_000_000_u128) .contains(&u128::try_from(buy_balance).unwrap()) diff --git a/crates/e2e/tests/e2e/place_order_with_quote.rs b/crates/e2e/tests/e2e/place_order_with_quote.rs index 423fdb4e5d..cc89a975d9 100644 --- a/crates/e2e/tests/e2e/place_order_with_quote.rs +++ b/crates/e2e/tests/e2e/place_order_with_quote.rs @@ -26,8 +26,8 @@ async fn local_node_test() { async fn place_order_with_quote(web3: Web3) { let mut onchain = OnchainComponents::deploy(web3.clone()).await; - let [solver] = onchain.make_solvers(to_wei(10)).await; - let [trader] = onchain.make_accounts(to_wei(10)).await; + let [solver] = onchain.make_solvers(eth(10)).await; + let [trader] = onchain.make_accounts(eth(10)).await; let [token] = onchain .deploy_tokens_with_weth_uni_v2_pools(to_wei(1_000), to_wei(1_000)) .await; @@ -36,7 +36,7 @@ async fn place_order_with_quote(web3: Web3) { .contracts() .weth .approve(onchain.contracts().allowance.into_alloy(), eth(3)) - .from(trader.address().into_alloy()) + .from(trader.address()) .send_and_watch() .await .unwrap(); @@ -44,7 +44,7 @@ async fn place_order_with_quote(web3: Web3) { .contracts() .weth .deposit() - .from(trader.address().into_alloy()) + .from(trader.address()) .value(eth(3)) .send_and_watch() .await @@ -63,7 +63,7 @@ async fn place_order_with_quote(web3: Web3) { tracing::info!("Quoting"); let quote_sell_amount = to_wei(1); let quote_request = OrderQuoteRequest { - from: trader.address().into_alloy(), + from: trader.address(), sell_token: *onchain.contracts().weth.address(), buy_token: *token.address(), side: OrderQuoteSide::Sell { @@ -84,18 +84,14 @@ async fn place_order_with_quote(web3: Web3) { tracing::debug!(?quote_metadata); tracing::info!("Placing order"); - let balance = token - .balanceOf(trader.address().into_alloy()) - .call() - .await - .unwrap(); + let balance = token.balanceOf(trader.address()).call().await.unwrap(); assert_eq!(balance, U256::ZERO); let order = OrderCreation { quote_id: quote_response.id, sell_token: onchain.contracts().weth.address().into_legacy(), sell_amount: quote_sell_amount, buy_token: token.address().into_legacy(), - buy_amount: quote_response.quote.buy_amount, + buy_amount: quote_response.quote.buy_amount.into_legacy(), valid_to: model::time::now_in_epoch_seconds() + 300, kind: OrderKind::Sell, ..Default::default() diff --git a/crates/e2e/tests/e2e/protocol_fee.rs b/crates/e2e/tests/e2e/protocol_fee.rs index 2139f5bc85..180345274a 100644 --- a/crates/e2e/tests/e2e/protocol_fee.rs +++ b/crates/e2e/tests/e2e/protocol_fee.rs @@ -1,4 +1,5 @@ use { + ::alloy::primitives::U256 as AlloyU256, driver::domain::eth::NonZeroU256, e2e::{ assert_approximately_eq, @@ -82,8 +83,8 @@ async fn combined_protocol_fees(web3: Web3) { let mut onchain = OnchainComponents::deploy(web3.clone()).await; - let [solver] = onchain.make_solvers(to_wei(200)).await; - let [trader] = onchain.make_accounts(to_wei(200)).await; + let [solver] = onchain.make_solvers(eth(200)).await; + let [trader] = onchain.make_accounts(eth(200)).await; let [ limit_order_token, market_order_token, @@ -97,18 +98,18 @@ async fn combined_protocol_fees(web3: Web3) { &market_order_token, &partner_fee_order_token, ] { - token.mint(solver.address(), to_wei(1000)).await; + token.mint(solver.address(), eth(1000)).await; token .approve(*onchain.contracts().uniswap_v2_router.address(), eth(1000)) - .from(solver.address().into_alloy()) + .from(solver.address()) .send_and_watch() .await .unwrap(); token .approve(*onchain.contracts().uniswap_v2_router.address(), eth(100)) - .from(trader.address().into_alloy()) + .from(trader.address()) .send_and_watch() .await .unwrap(); @@ -118,7 +119,7 @@ async fn combined_protocol_fees(web3: Web3) { .contracts() .weth .approve(onchain.contracts().allowance.into_alloy(), eth(100)) - .from(trader.address().into_alloy()) + .from(trader.address()) .send_and_watch() .await .unwrap(); @@ -126,7 +127,7 @@ async fn combined_protocol_fees(web3: Web3) { .contracts() .weth .deposit() - .from(trader.address().into_alloy()) + .from(trader.address()) .value(eth(100)) .send_and_watch() .await @@ -135,7 +136,7 @@ async fn combined_protocol_fees(web3: Web3) { .contracts() .weth .approve(*onchain.contracts().uniswap_v2_router.address(), eth(200)) - .from(solver.address().into_alloy()) + .from(solver.address()) .send_and_watch() .await .unwrap(); @@ -189,7 +190,9 @@ async fn combined_protocol_fees(web3: Web3) { let market_price_improvement_order = OrderCreation { sell_amount, // to make sure the order is in-market - buy_amount: market_quote_before.quote.buy_amount * 2 / 3, + buy_amount: (market_quote_before.quote.buy_amount * AlloyU256::from(2) + / AlloyU256::from(3)) + .into_legacy(), ..sell_order_from_quote(&market_quote_before) } .sign( @@ -200,7 +203,8 @@ async fn combined_protocol_fees(web3: Web3) { let limit_surplus_order = OrderCreation { sell_amount, // to make sure the order is out-of-market - buy_amount: limit_quote_before.quote.buy_amount * 3 / 2, + buy_amount: (limit_quote_before.quote.buy_amount * AlloyU256::from(3) / AlloyU256::from(2)) + .into_legacy(), ..sell_order_from_quote(&limit_quote_before) } .sign( @@ -211,7 +215,8 @@ async fn combined_protocol_fees(web3: Web3) { let partner_fee_order = OrderCreation { sell_amount, // to make sure the order is out-of-market - buy_amount: partner_fee_quote.quote.buy_amount * 3 / 2, + buy_amount: (partner_fee_quote.quote.buy_amount * AlloyU256::from(3) / AlloyU256::from(2)) + .into_legacy(), app_data: partner_fee_app_data.clone(), ..sell_order_from_quote(&partner_fee_quote) } @@ -223,13 +228,13 @@ async fn combined_protocol_fees(web3: Web3) { tracing::info!("Rebalancing AMM pools for market & limit order."); onchain - .mint_token_to_weth_uni_v2_pool(&market_order_token, to_wei(1000)) + .mint_token_to_weth_uni_v2_pool(&market_order_token, eth(1000)) .await; onchain - .mint_token_to_weth_uni_v2_pool(&limit_order_token, to_wei(1000)) + .mint_token_to_weth_uni_v2_pool(&limit_order_token, eth(1000)) .await; onchain - .mint_token_to_weth_uni_v2_pool(&partner_fee_order_token, to_wei(1000)) + .mint_token_to_weth_uni_v2_pool(&partner_fee_order_token, eth(1000)) .await; tracing::info!("Waiting for liquidity state to update"); @@ -249,7 +254,8 @@ async fn combined_protocol_fees(web3: Web3) { // Only proceed with test once the quote changes significantly (2x) to avoid // progressing due to tiny fluctuations in gas price which would lead to // errors down the line. - new_market_order_quote.quote.buy_amount > market_quote_before.quote.buy_amount * 2 + new_market_order_quote.quote.buy_amount + > market_quote_before.quote.buy_amount * AlloyU256::from(2) }) .await .expect("Timeout waiting for eviction of the cached liquidity"); @@ -335,21 +341,28 @@ async fn combined_protocol_fees(web3: Web3) { .buy_amount .saturating_sub(market_quote_before.quote.buy_amount); // see `market_price_improvement_policy.factor`, which is 0.3 - assert!(market_executed_fee_in_buy_token >= market_quote_diff * 3 / 10); + assert!( + market_executed_fee_in_buy_token.into_alloy() + >= (market_quote_diff * AlloyU256::from(3) / AlloyU256::from(10)) + ); let partner_fee_order = services.get_order(&partner_fee_order_uid).await.unwrap(); let partner_fee_executed_fee_in_buy_token = fee_in_buy_token(&partner_fee_order, &partner_fee_quote_after.quote); assert!( // see `--fee-policy-max-partner-fee` autopilot config argument, which is 0.02 - partner_fee_executed_fee_in_buy_token >= partner_fee_quote.quote.buy_amount * 2 / 100 + partner_fee_executed_fee_in_buy_token.into_alloy() + >= (partner_fee_quote.quote.buy_amount * AlloyU256::from(2) / AlloyU256::from(100)) ); let limit_quote_diff = partner_fee_quote_after .quote .buy_amount - .saturating_sub(partner_fee_order.data.buy_amount.into_legacy()); + .saturating_sub(partner_fee_order.data.buy_amount); // see `limit_surplus_policy.factor`, which is 0.3 - assert!(partner_fee_executed_fee_in_buy_token >= limit_quote_diff * 3 / 10); + assert!( + partner_fee_executed_fee_in_buy_token.into_alloy() + >= (limit_quote_diff * AlloyU256::from(3) / AlloyU256::from(10)) + ); let limit_surplus_order = services.get_order(&limit_surplus_order_uid).await.unwrap(); let limit_executed_fee_in_buy_token = @@ -357,9 +370,12 @@ async fn combined_protocol_fees(web3: Web3) { let limit_quote_diff = limit_quote_after .quote .buy_amount - .saturating_sub(limit_surplus_order.data.buy_amount.into_legacy()); + .saturating_sub(limit_surplus_order.data.buy_amount); // see `limit_surplus_policy.factor`, which is 0.3 - assert!(limit_executed_fee_in_buy_token >= limit_quote_diff * 3 / 10); + assert!( + limit_executed_fee_in_buy_token.into_alloy() + >= (limit_quote_diff * AlloyU256::from(3) / AlloyU256::from(10)) + ); let [ market_order_token_balance, @@ -438,24 +454,24 @@ async fn surplus_partner_fee(web3: Web3) { let mut onchain = OnchainComponents::deploy(web3.clone()).await; - let [solver] = onchain.make_solvers(to_wei(200)).await; - let [trader] = onchain.make_accounts(to_wei(200)).await; + let [solver] = onchain.make_solvers(eth(200)).await; + let [trader] = onchain.make_accounts(eth(200)).await; let [token] = onchain .deploy_tokens_with_weth_uni_v2_pools(to_wei(20), to_wei(20)) .await; - token.mint(solver.address(), to_wei(1000)).await; + token.mint(solver.address(), eth(1000)).await; token .approve(*onchain.contracts().uniswap_v2_router.address(), eth(1000)) - .from(solver.address().into_alloy()) + .from(solver.address()) .send_and_watch() .await .unwrap(); token .approve(*onchain.contracts().uniswap_v2_router.address(), eth(100)) - .from(trader.address().into_alloy()) + .from(trader.address()) .send_and_watch() .await .unwrap(); @@ -463,7 +479,7 @@ async fn surplus_partner_fee(web3: Web3) { .contracts() .weth .approve(onchain.contracts().allowance.into_alloy(), eth(100)) - .from(trader.address().into_alloy()) + .from(trader.address()) .send_and_watch() .await .unwrap(); @@ -471,7 +487,7 @@ async fn surplus_partner_fee(web3: Web3) { .contracts() .weth .deposit() - .from(trader.address().into_alloy()) + .from(trader.address()) .value(eth(100)) .send_and_watch() .await @@ -480,7 +496,7 @@ async fn surplus_partner_fee(web3: Web3) { .contracts() .weth .approve(*onchain.contracts().uniswap_v2_router.address(), eth(200)) - .from(solver.address().into_alloy()) + .from(solver.address()) .send_and_watch() .await .unwrap(); @@ -616,15 +632,15 @@ async fn get_quote( } fn fee_in_buy_token(order: &Order, quote: &OrderQuote) -> U256 { - order.metadata.executed_fee * quote.buy_amount / quote.sell_amount + (order.metadata.executed_fee.into_alloy() * quote.buy_amount / quote.sell_amount).into_legacy() } fn sell_order_from_quote(quote: &OrderQuoteResponse) -> OrderCreation { OrderCreation { - sell_token: quote.quote.sell_token, - sell_amount: quote.quote.sell_amount, - buy_token: quote.quote.buy_token, - buy_amount: quote.quote.buy_amount, + sell_token: quote.quote.sell_token.into_legacy(), + sell_amount: quote.quote.sell_amount.into_legacy(), + buy_token: quote.quote.buy_token.into_legacy(), + buy_amount: quote.quote.buy_amount.into_legacy(), valid_to: quote.quote.valid_to, kind: OrderKind::Sell, quote_id: quote.id, @@ -660,37 +676,37 @@ async fn volume_fee_buy_order_test(web3: Web3) { let mut onchain = OnchainComponents::deploy(web3.clone()).await; - let [solver] = onchain.make_solvers(to_wei(1)).await; - let [trader] = onchain.make_accounts(to_wei(1)).await; + let [solver] = onchain.make_solvers(eth(1)).await; + let [trader] = onchain.make_accounts(eth(1)).await; let [token_gno, token_dai] = onchain .deploy_tokens_with_weth_uni_v2_pools(to_wei(1_000), to_wei(1000)) .await; // Fund trader accounts - token_gno.mint(trader.address(), to_wei(100)).await; + token_gno.mint(trader.address(), eth(100)).await; // Create and fund Uniswap pool - token_gno.mint(solver.address(), to_wei(1000)).await; - token_dai.mint(solver.address(), to_wei(1000)).await; + token_gno.mint(solver.address(), eth(1000)).await; + token_dai.mint(solver.address(), eth(1000)).await; onchain .contracts() .uniswap_v2_factory .createPair(*token_gno.address(), *token_dai.address()) - .from(solver.address().into_alloy()) + .from(solver.address()) .send_and_watch() .await .unwrap(); token_gno .approve(*onchain.contracts().uniswap_v2_router.address(), eth(1000)) - .from(solver.address().into_alloy()) + .from(solver.address()) .send_and_watch() .await .unwrap(); token_dai .approve(*onchain.contracts().uniswap_v2_router.address(), eth(1000)) - .from(solver.address().into_alloy()) + .from(solver.address()) .send_and_watch() .await .unwrap(); @@ -704,10 +720,10 @@ async fn volume_fee_buy_order_test(web3: Web3) { eth(1000), ::alloy::primitives::U256::ZERO, ::alloy::primitives::U256::ZERO, - solver.address().into_alloy(), + solver.address(), ::alloy::primitives::U256::MAX, ) - .from(solver.address().into_alloy()) + .from(solver.address()) .send_and_watch() .await .unwrap(); @@ -716,7 +732,7 @@ async fn volume_fee_buy_order_test(web3: Web3) { token_gno .approve(onchain.contracts().allowance.into_alloy(), eth(100)) - .from(trader.address().into_alloy()) + .from(trader.address()) .send_and_watch() .await .unwrap(); @@ -747,7 +763,7 @@ async fn volume_fee_buy_order_test(web3: Web3) { let order = OrderCreation { sell_token: token_gno.address().into_legacy(), - sell_amount: quote.sell_amount * 3 / 2, + sell_amount: (quote.sell_amount * AlloyU256::from(3) / AlloyU256::from(2)).into_legacy(), buy_token: token_dai.address().into_legacy(), buy_amount: to_wei(5), valid_to: model::time::now_in_epoch_seconds() + 300, @@ -772,7 +788,10 @@ async fn volume_fee_buy_order_test(web3: Web3) { let order = services.get_order(&uid).await.unwrap(); let fee_in_buy_token = quote.fee_amount * quote.buy_amount / quote.sell_amount; - assert!(order.metadata.executed_fee >= fee_in_buy_token + quote.sell_amount / 10); + assert!( + order.metadata.executed_fee.into_alloy() + >= fee_in_buy_token + (quote.sell_amount / AlloyU256::from(10)) + ); // Check settlement contract balance let balance_after = token_gno @@ -812,37 +831,37 @@ async fn volume_fee_buy_order_upcoming_future_test(web3: Web3) { let mut onchain = OnchainComponents::deploy(web3.clone()).await; - let [solver] = onchain.make_solvers(to_wei(1)).await; - let [trader] = onchain.make_accounts(to_wei(1)).await; + let [solver] = onchain.make_solvers(eth(1)).await; + let [trader] = onchain.make_accounts(eth(1)).await; let [token_gno, token_dai] = onchain .deploy_tokens_with_weth_uni_v2_pools(to_wei(1_000), to_wei(1000)) .await; // Fund trader accounts - token_gno.mint(trader.address(), to_wei(100)).await; + token_gno.mint(trader.address(), eth(100)).await; // Create and fund Uniswap pool - token_gno.mint(solver.address(), to_wei(1000)).await; - token_dai.mint(solver.address(), to_wei(1000)).await; + token_gno.mint(solver.address(), eth(1000)).await; + token_dai.mint(solver.address(), eth(1000)).await; onchain .contracts() .uniswap_v2_factory .createPair(*token_gno.address(), *token_dai.address()) - .from(solver.address().into_alloy()) + .from(solver.address()) .send_and_watch() .await .unwrap(); token_gno .approve(*onchain.contracts().uniswap_v2_router.address(), eth(1000)) - .from(solver.address().into_alloy()) + .from(solver.address()) .send_and_watch() .await .unwrap(); token_dai .approve(*onchain.contracts().uniswap_v2_router.address(), eth(1000)) - .from(solver.address().into_alloy()) + .from(solver.address()) .send_and_watch() .await .unwrap(); @@ -856,10 +875,10 @@ async fn volume_fee_buy_order_upcoming_future_test(web3: Web3) { eth(1000), ::alloy::primitives::U256::ZERO, ::alloy::primitives::U256::ZERO, - solver.address().into_alloy(), + solver.address(), ::alloy::primitives::U256::MAX, ) - .from(solver.address().into_alloy()) + .from(solver.address()) .send_and_watch() .await .unwrap(); @@ -868,7 +887,7 @@ async fn volume_fee_buy_order_upcoming_future_test(web3: Web3) { token_gno .approve(onchain.contracts().allowance.into_alloy(), eth(100)) - .from(trader.address().into_alloy()) + .from(trader.address()) .send_and_watch() .await .unwrap(); @@ -899,7 +918,7 @@ async fn volume_fee_buy_order_upcoming_future_test(web3: Web3) { let order = OrderCreation { sell_token: token_gno.address().into_legacy(), - sell_amount: quote.sell_amount * 3 / 2, + sell_amount: (quote.sell_amount * AlloyU256::from(3) / AlloyU256::from(2)).into_legacy(), buy_token: token_dai.address().into_legacy(), buy_amount: to_wei(5), valid_to: model::time::now_in_epoch_seconds() + 300, @@ -924,7 +943,10 @@ async fn volume_fee_buy_order_upcoming_future_test(web3: Web3) { let order = services.get_order(&uid).await.unwrap(); let fee_in_buy_token = quote.fee_amount * quote.buy_amount / quote.sell_amount; - assert!(order.metadata.executed_fee >= fee_in_buy_token + quote.sell_amount / 10); + assert!( + order.metadata.executed_fee.into_alloy() + >= fee_in_buy_token + (quote.sell_amount / AlloyU256::from(10)) + ); // Check settlement contract balance let balance_after = token_gno diff --git a/crates/e2e/tests/e2e/quote_verification.rs b/crates/e2e/tests/e2e/quote_verification.rs index b1e2585f35..c67e307270 100644 --- a/crates/e2e/tests/e2e/quote_verification.rs +++ b/crates/e2e/tests/e2e/quote_verification.rs @@ -86,17 +86,17 @@ async fn standard_verified_quote(web3: Web3) { tracing::info!("Setting up chain state."); let mut onchain = OnchainComponents::deploy(web3).await; - let [solver] = onchain.make_solvers(to_wei(10)).await; - let [trader] = onchain.make_accounts(to_wei(1)).await; + let [solver] = onchain.make_solvers(eth(10)).await; + let [trader] = onchain.make_accounts(eth(1)).await; let [token] = onchain .deploy_tokens_with_weth_uni_v2_pools(to_wei(1_000), to_wei(1_000)) .await; - token.mint(trader.address(), to_wei(1)).await; + token.mint(trader.address(), eth(1)).await; token .approve(onchain.contracts().allowance.into_alloy(), eth(1)) - .from(trader.address().into_alloy()) + .from(trader.address()) .send_and_watch() .await .unwrap(); @@ -108,7 +108,7 @@ async fn standard_verified_quote(web3: Web3) { // quote where the trader has sufficient balance and an approval set. let response = services .submit_quote(&OrderQuoteRequest { - from: trader.address().into_alloy(), + from: trader.address(), sell_token: *token.address(), buy_token: *onchain.contracts().weth.address(), side: OrderQuoteSide::Sell { @@ -174,9 +174,8 @@ async fn test_bypass_verification_for_rfq_quotes(web3: Web3) { in_amount: NonZeroU256::new(12.into()).unwrap(), }, &Verification { - from: H160::from_str("0x73688c2b34bf6c09c125fed02fe92d17a94b897a").unwrap().into_alloy(), - receiver: H160::from_str("0x73688c2b34bf6c09c125fed02fe92d17a94b897a") - .unwrap().into_alloy(), + from: address!("0x73688c2b34bf6c09c125fed02fe92d17a94b897a"), + receiver: address!("0x73688c2b34bf6c09c125fed02fe92d17a94b897a"), pre_interactions: vec![], post_interactions: vec![], sell_token_source: SellTokenSource::Erc20, @@ -237,8 +236,8 @@ async fn verified_quote_eth_balance(web3: Web3) { tracing::info!("Setting up chain state."); let mut onchain = OnchainComponents::deploy(web3).await; - let [solver] = onchain.make_solvers(to_wei(10)).await; - let [trader] = onchain.make_accounts(to_wei(1)).await; + let [solver] = onchain.make_solvers(eth(10)).await; + let [trader] = onchain.make_accounts(eth(1)).await; let [token] = onchain .deploy_tokens_with_weth_uni_v2_pools(to_wei(1_000), to_wei(1_000)) .await; @@ -251,25 +250,22 @@ async fn verified_quote_eth_balance(web3: Web3) { // quote where the trader has no WETH balances or approval set, but // sufficient ETH for the trade assert!( - weth.balanceOf(trader.address().into_alloy()) + weth.balanceOf(trader.address()) .call() .await .unwrap() .is_zero() ); assert!( - weth.allowance( - trader.address().into_alloy(), - onchain.contracts().allowance.into_alloy() - ) - .call() - .await - .unwrap() - .is_zero() + weth.allowance(trader.address(), onchain.contracts().allowance.into_alloy()) + .call() + .await + .unwrap() + .is_zero() ); let response = services .submit_quote(&OrderQuoteRequest { - from: trader.address().into_alloy(), + from: trader.address(), sell_token: *weth.address(), buy_token: *token.address(), side: OrderQuoteSide::Sell { @@ -290,8 +286,8 @@ async fn verified_quote_for_settlement_contract(web3: Web3) { tracing::info!("Setting up chain state."); let mut onchain = OnchainComponents::deploy(web3).await; - let [solver] = onchain.make_solvers(to_wei(10)).await; - let [trader] = onchain.make_accounts(to_wei(3)).await; + let [solver] = onchain.make_solvers(eth(10)).await; + let [trader] = onchain.make_accounts(eth(3)).await; let [token] = onchain .deploy_tokens_with_weth_uni_v2_pools(to_wei(1_000), to_wei(1_000)) .await; @@ -299,10 +295,7 @@ async fn verified_quote_for_settlement_contract(web3: Web3) { // Send 3 ETH to the settlement contract so we can get verified quotes for // selling WETH. onchain - .send_wei( - onchain.contracts().gp_settlement.address().into_legacy(), - to_wei(3), - ) + .send_wei(*onchain.contracts().gp_settlement.address(), eth(3)) .await; tracing::info!("Starting services."); @@ -346,7 +339,7 @@ async fn verified_quote_for_settlement_contract(web3: Web3) { let response = services .submit_quote(&OrderQuoteRequest { from: *onchain.contracts().gp_settlement.address(), - receiver: Some(trader.address().into_alloy()), + receiver: Some(trader.address()), ..request.clone() }) .await @@ -356,7 +349,7 @@ async fn verified_quote_for_settlement_contract(web3: Web3) { // quote where a random trader sends funds to the settlement contract let response = services .submit_quote(&OrderQuoteRequest { - from: trader.address().into_alloy(), + from: trader.address(), receiver: Some(*onchain.contracts().gp_settlement.address()), ..request.clone() }) @@ -371,8 +364,8 @@ async fn verified_quote_with_simulated_balance(web3: Web3) { tracing::info!("Setting up chain state."); let mut onchain = OnchainComponents::deploy(web3).await; - let [solver] = onchain.make_solvers(to_wei(10)).await; - let [trader] = onchain.make_accounts(to_wei(0)).await; + let [solver] = onchain.make_solvers(eth(10)).await; + let [trader] = onchain.make_accounts(eth(0)).await; let [token] = onchain .deploy_tokens_with_weth_uni_v2_pools(to_wei(1_000), to_wei(1_000)) .await; @@ -400,16 +393,9 @@ async fn verified_quote_with_simulated_balance(web3: Web3) { // quote where the trader has no balances or approval set from TOKEN->WETH assert_eq!( ( + token.balanceOf(trader.address()).call().await.unwrap(), token - .balanceOf(trader.address().into_alloy()) - .call() - .await - .unwrap(), - token - .allowance( - trader.address().into_alloy(), - onchain.contracts().allowance.into_alloy() - ) + .allowance(trader.address(), onchain.contracts().allowance.into_alloy()) .call() .await .unwrap(), @@ -421,7 +407,7 @@ async fn verified_quote_with_simulated_balance(web3: Web3) { ); let response = services .submit_quote(&OrderQuoteRequest { - from: trader.address().into_alloy(), + from: trader.address(), sell_token: *token.address(), buy_token: *weth.address(), side: OrderQuoteSide::Sell { @@ -440,31 +426,28 @@ async fn verified_quote_with_simulated_balance(web3: Web3) { onchain .web3() .eth() - .balance(trader.address(), None) + .balance(trader.address().into_legacy(), None) .await .unwrap() .is_zero() ); assert!( - weth.balanceOf(trader.address().into_alloy()) + weth.balanceOf(trader.address()) .call() .await .unwrap() .is_zero() ); assert!( - weth.allowance( - trader.address().into_alloy(), - onchain.contracts().allowance.into_alloy() - ) - .call() - .await - .unwrap() - .is_zero() + weth.allowance(trader.address(), onchain.contracts().allowance.into_alloy()) + .call() + .await + .unwrap() + .is_zero() ); let response = services .submit_quote(&OrderQuoteRequest { - from: trader.address().into_alloy(), + from: trader.address(), sell_token: *weth.address(), buy_token: *token.address(), side: OrderQuoteSide::Sell { @@ -482,7 +465,7 @@ async fn verified_quote_with_simulated_balance(web3: Web3) { // which is used when no wallet is connected in the frontend let response = services .submit_quote(&OrderQuoteRequest { - from: H160::zero().into_alloy(), + from: Address::ZERO, sell_token: *weth.address(), buy_token: *token.address(), side: OrderQuoteSide::Sell { @@ -500,7 +483,7 @@ async fn verified_quote_with_simulated_balance(web3: Web3) { // if the user provided pre-interactions. This works now. let response = services .submit_quote(&OrderQuoteRequest { - from: H160::zero().into_alloy(), + from: Address::ZERO, sell_token: *weth.address(), buy_token: *token.address(), side: OrderQuoteSide::Sell { @@ -536,7 +519,7 @@ async fn verified_quote_with_simulated_balance(web3: Web3) { async fn usdt_quote_verification(web3: Web3) { let mut onchain = OnchainComponents::deployed(web3.clone()).await; - let [solver] = onchain.make_solvers_forked(to_wei(1)).await; + let [solver] = onchain.make_solvers_forked(eth(1)).await; let usdc = address!("a0b86991c6218b36c1d19d4a2e9eb0ce3606eb48"); let usdt = address!("dac17f958d2ee523a2206206994597c13d831ec7"); diff --git a/crates/e2e/tests/e2e/quoting.rs b/crates/e2e/tests/e2e/quoting.rs index e81176f27c..84ebc3776a 100644 --- a/crates/e2e/tests/e2e/quoting.rs +++ b/crates/e2e/tests/e2e/quoting.rs @@ -52,8 +52,8 @@ async fn test(web3: Web3) { tracing::info!("Setting up chain state."); let mut onchain = OnchainComponents::deploy(web3).await; - let [solver] = onchain.make_solvers(to_wei(10)).await; - let [trader] = onchain.make_accounts(to_wei(10)).await; + let [solver] = onchain.make_solvers(eth(10)).await; + let [trader] = onchain.make_accounts(eth(10)).await; let [token] = onchain .deploy_tokens_with_weth_uni_v2_pools(to_wei(1_000), to_wei(1_000)) .await; @@ -62,7 +62,7 @@ async fn test(web3: Web3) { .contracts() .weth .approve(onchain.contracts().allowance.into_alloy(), eth(3)) - .from(trader.address().into_alloy()) + .from(trader.address()) .send_and_watch() .await .unwrap(); @@ -70,7 +70,7 @@ async fn test(web3: Web3) { .contracts() .weth .deposit() - .from(trader.address().into_alloy()) + .from(trader.address()) .value(eth(3)) .send_and_watch() .await @@ -91,7 +91,7 @@ async fn test(web3: Web3) { tracing::info!("Quoting order"); let request = OrderQuoteRequest { - from: trader.address().into_alloy(), + from: trader.address(), sell_token: *onchain.contracts().weth.address(), buy_token: *token.address(), side: OrderQuoteSide::Sell { @@ -200,8 +200,8 @@ async fn uses_stale_liquidity(web3: Web3) { tracing::info!("Setting up chain state."); let mut onchain = OnchainComponents::deploy(web3.clone()).await; - let [solver] = onchain.make_solvers(to_wei(10)).await; - let [trader] = onchain.make_accounts(to_wei(2)).await; + let [solver] = onchain.make_solvers(eth(10)).await; + let [trader] = onchain.make_accounts(eth(2)).await; let [token] = onchain .deploy_tokens_with_weth_uni_v2_pools(to_wei(1_000), to_wei(1_000)) .await; @@ -210,7 +210,7 @@ async fn uses_stale_liquidity(web3: Web3) { .contracts() .weth .approve(onchain.contracts().allowance.into_alloy(), eth(1)) - .from(trader.address().into_alloy()) + .from(trader.address()) .send_and_watch() .await .unwrap(); @@ -218,7 +218,7 @@ async fn uses_stale_liquidity(web3: Web3) { .contracts() .weth .deposit() - .from(trader.address().into_alloy()) + .from(trader.address()) .value(eth(1)) .send_and_watch() .await @@ -229,7 +229,7 @@ async fn uses_stale_liquidity(web3: Web3) { services.start_protocol(solver).await; let quote = OrderQuoteRequest { - from: trader.address().into_alloy(), + from: trader.address(), sell_token: *onchain.contracts().weth.address(), buy_token: *token.address(), side: OrderQuoteSide::Sell { @@ -246,7 +246,7 @@ async fn uses_stale_liquidity(web3: Web3) { // Now, we want to manually unbalance the pools and assert that the quote // doesn't change (as the price estimation will use stale pricing data). onchain - .mint_token_to_weth_uni_v2_pool(&token, to_wei(1_000)) + .mint_token_to_weth_uni_v2_pool(&token, eth(1_000)) .await; tracing::info!("performining second quote, which should match first"); @@ -272,8 +272,8 @@ async fn quote_timeout(web3: Web3) { tracing::info!("Setting up chain state."); let mut onchain = OnchainComponents::deploy(web3.clone()).await; - let [solver] = onchain.make_solvers(to_wei(10)).await; - let [trader] = onchain.make_accounts(to_wei(2)).await; + let [solver] = onchain.make_solvers(eth(10)).await; + let [trader] = onchain.make_accounts(eth(2)).await; let [sell_token] = onchain .deploy_tokens_with_weth_uni_v2_pools(to_wei(1_000), to_wei(1_000)) .await; @@ -330,7 +330,7 @@ async fn quote_timeout(web3: Web3) { })); let quote_request = |timeout| OrderQuoteRequest { - from: trader.address().into_alloy(), + from: trader.address(), sell_token: *onchain.contracts().weth.address(), buy_token: *sell_token.address(), side: OrderQuoteSide::Sell { @@ -385,11 +385,11 @@ async fn quote_timeout(web3: Web3) { assert_within_variance(start, MAX_QUOTE_TIME_MS); // set up trader to pass balance checks during order creation - sell_token.mint(trader.address(), to_wei(1)).await; + sell_token.mint(trader.address(), eth(1)).await; sell_token .approve(onchain.contracts().allowance.into_alloy(), eth(1)) - .from(trader.address().into_alloy()) + .from(trader.address()) .send_and_watch() .await .unwrap(); @@ -423,8 +423,8 @@ async fn quote_timeout(web3: Web3) { async fn volume_fee(web3: Web3) { let mut onchain = OnchainComponents::deploy(web3).await; - let [solver] = onchain.make_solvers(to_wei(10)).await; - let [trader] = onchain.make_accounts(to_wei(10)).await; + let [solver] = onchain.make_solvers(eth(10)).await; + let [trader] = onchain.make_accounts(eth(10)).await; let [token] = onchain .deploy_tokens_with_weth_uni_v2_pools(to_wei(1_000), to_wei(1_000)) .await; @@ -433,7 +433,7 @@ async fn volume_fee(web3: Web3) { .contracts() .weth .approve(onchain.contracts().allowance.into_alloy(), eth(3)) - .from(trader.address().into_alloy()) + .from(trader.address()) .send_and_watch() .await .unwrap(); @@ -441,7 +441,7 @@ async fn volume_fee(web3: Web3) { .contracts() .weth .deposit() - .from(trader.address().into_alloy()) + .from(trader.address()) .value(eth(3)) .send_and_watch() .await @@ -462,7 +462,7 @@ async fn volume_fee(web3: Web3) { tracing::info!("Testing SELL quote with volume fee"); let sell_request = OrderQuoteRequest { - from: trader.address().into_alloy(), + from: trader.address(), sell_token: *onchain.contracts().weth.address(), buy_token: *token.address(), side: OrderQuoteSide::Sell { @@ -481,7 +481,7 @@ async fn volume_fee(web3: Web3) { tracing::info!("Testing BUY quote with volume fee"); let buy_request = OrderQuoteRequest { - from: trader.address().into_alloy(), + from: trader.address(), sell_token: *onchain.contracts().weth.address(), buy_token: *token.address(), side: OrderQuoteSide::Buy { diff --git a/crates/e2e/tests/e2e/refunder.rs b/crates/e2e/tests/e2e/refunder.rs index 29d6346baf..98de58b547 100644 --- a/crates/e2e/tests/e2e/refunder.rs +++ b/crates/e2e/tests/e2e/refunder.rs @@ -6,7 +6,7 @@ use { ethcontract::U256, ethrpc::{ Web3, - alloy::conversions::{IntoAlloy, TryIntoAlloyAsync}, + alloy::conversions::TryIntoAlloyAsync, block_stream::timestamp_of_current_block_in_seconds, }, model::quote::{OrderQuoteRequest, OrderQuoteSide, QuoteSigningScheme, Validity}, @@ -24,8 +24,8 @@ async fn local_node_refunder_tx() { async fn refunder_tx(web3: Web3) { let mut onchain = OnchainComponents::deploy(web3.clone()).await; - let [solver] = onchain.make_solvers(to_wei(10)).await; - let [user, refunder] = onchain.make_accounts(to_wei(10)).await; + let [solver] = onchain.make_solvers(eth(10)).await; + let [user, refunder] = onchain.make_accounts(eth(10)).await; let [token] = onchain .deploy_tokens_with_weth_uni_v2_pools(to_wei(1_000), to_wei(1_000)) .await; @@ -93,10 +93,10 @@ async fn refunder_tx(web3: Web3) { ExtendedEthFlowOrder::from_quote("e_response, valid_to).include_slippage_bps(9999); ethflow_order - .mine_order_creation(user.address().into_alloy(), ethflow_contract) + .mine_order_creation(user.address(), ethflow_contract) .await; ethflow_order_2 - .mine_order_creation(user.address().into_alloy(), ethflow_contract_2) + .mine_order_creation(user.address(), ethflow_contract_2) .await; let order_id = ethflow_order diff --git a/crates/e2e/tests/e2e/replace_order.rs b/crates/e2e/tests/e2e/replace_order.rs index 979e532ce2..719b551c32 100644 --- a/crates/e2e/tests/e2e/replace_order.rs +++ b/crates/e2e/tests/e2e/replace_order.rs @@ -44,37 +44,37 @@ async fn local_node_try_replace_executed_order() { async fn try_replace_unreplaceable_order_test(web3: Web3) { let mut onchain = OnchainComponents::deploy(web3.clone()).await; - let [solver] = onchain.make_solvers(to_wei(1)).await; - let [trader] = onchain.make_accounts(to_wei(1)).await; + let [solver] = onchain.make_solvers(eth(1)).await; + let [trader] = onchain.make_accounts(eth(1)).await; let [token_a, token_b] = onchain .deploy_tokens_with_weth_uni_v2_pools(to_wei(1_000), to_wei(1_000)) .await; // Fund trader accounts - token_a.mint(trader.address(), to_wei(30)).await; + token_a.mint(trader.address(), eth(30)).await; // Create and fund Uniswap pool - token_a.mint(solver.address(), to_wei(1000)).await; - token_b.mint(solver.address(), to_wei(1000)).await; + token_a.mint(solver.address(), eth(1000)).await; + token_b.mint(solver.address(), eth(1000)).await; onchain .contracts() .uniswap_v2_factory .createPair(*token_a.address(), *token_b.address()) - .from(solver.address().into_alloy()) + .from(solver.address()) .send_and_watch() .await .unwrap(); token_a .approve(*onchain.contracts().uniswap_v2_router.address(), eth(1000)) - .from(solver.address().into_alloy()) + .from(solver.address()) .send_and_watch() .await .unwrap(); token_b .approve(*onchain.contracts().uniswap_v2_router.address(), eth(1000)) - .from(solver.address().into_alloy()) + .from(solver.address()) .send_and_watch() .await .unwrap(); @@ -88,10 +88,10 @@ async fn try_replace_unreplaceable_order_test(web3: Web3) { eth(1000), U256::ZERO, U256::ZERO, - solver.address().into_alloy(), + solver.address(), U256::MAX, ) - .from(solver.address().into_alloy()) + .from(solver.address()) .send_and_watch() .await .unwrap(); @@ -100,7 +100,7 @@ async fn try_replace_unreplaceable_order_test(web3: Web3) { token_a .approve(onchain.contracts().allowance.into_alloy(), eth(15)) - .from(trader.address().into_alloy()) + .from(trader.address()) .send_and_watch() .await .unwrap(); @@ -129,11 +129,7 @@ async fn try_replace_unreplaceable_order_test(web3: Web3) { &onchain.contracts().domain_separator, SecretKeyRef::from(&SecretKey::from_slice(trader.private_key()).unwrap()), ); - let balance_before = token_a - .balanceOf(trader.address().into_alloy()) - .call() - .await - .unwrap(); + let balance_before = token_a.balanceOf(trader.address()).call().await.unwrap(); onchain.mint_block().await; let order_id = services.create_order(&order).await.unwrap(); @@ -193,11 +189,7 @@ async fn try_replace_unreplaceable_order_test(web3: Web3) { tracing::info!("Waiting for the old order to be executed"); wait_for_condition(TIMEOUT, || async { - let balance_after = token_a - .balanceOf(trader.address().into_alloy()) - .call() - .await - .unwrap(); + let balance_after = token_a.balanceOf(trader.address()).call().await.unwrap(); balance_before.saturating_sub(balance_after) == eth(10) && !services.get_trades(&order_id).await.unwrap().is_empty() }) @@ -224,38 +216,38 @@ async fn try_replace_unreplaceable_order_test(web3: Web3) { async fn try_replace_someone_else_order_test(web3: Web3) { let mut onchain = OnchainComponents::deploy(web3.clone()).await; - let [solver] = onchain.make_solvers(to_wei(1)).await; - let [trader_a, trader_b] = onchain.make_accounts(to_wei(1)).await; + let [solver] = onchain.make_solvers(eth(1)).await; + let [trader_a, trader_b] = onchain.make_accounts(eth(1)).await; let [token_a, token_b] = onchain .deploy_tokens_with_weth_uni_v2_pools(to_wei(1_000), to_wei(1_000)) .await; // Fund trader accounts - token_a.mint(trader_a.address(), to_wei(30)).await; - token_a.mint(trader_b.address(), to_wei(30)).await; + token_a.mint(trader_a.address(), eth(30)).await; + token_a.mint(trader_b.address(), eth(30)).await; // Create and fund Uniswap pool - token_a.mint(solver.address(), to_wei(1000)).await; - token_b.mint(solver.address(), to_wei(1000)).await; + token_a.mint(solver.address(), eth(1000)).await; + token_b.mint(solver.address(), eth(1000)).await; onchain .contracts() .uniswap_v2_factory .createPair(*token_a.address(), *token_b.address()) - .from(solver.address().into_alloy()) + .from(solver.address()) .send_and_watch() .await .unwrap(); token_a .approve(*onchain.contracts().uniswap_v2_router.address(), eth(1000)) - .from(solver.address().into_alloy()) + .from(solver.address()) .send_and_watch() .await .unwrap(); token_b .approve(*onchain.contracts().uniswap_v2_router.address(), eth(1000)) - .from(solver.address().into_alloy()) + .from(solver.address()) .send_and_watch() .await .unwrap(); @@ -269,10 +261,10 @@ async fn try_replace_someone_else_order_test(web3: Web3) { eth(1000), U256::ZERO, U256::ZERO, - solver.address().into_alloy(), + solver.address(), U256::MAX, ) - .from(solver.address().into_alloy()) + .from(solver.address()) .send_and_watch() .await .unwrap(); @@ -281,14 +273,14 @@ async fn try_replace_someone_else_order_test(web3: Web3) { token_a .approve(onchain.contracts().allowance.into_alloy(), eth(15)) - .from(trader_a.address().into_alloy()) + .from(trader_a.address()) .send_and_watch() .await .unwrap(); token_a .approve(onchain.contracts().allowance.into_alloy(), eth(15)) - .from(trader_b.address().into_alloy()) + .from(trader_b.address()) .send_and_watch() .await .unwrap(); @@ -337,11 +329,7 @@ async fn try_replace_someone_else_order_test(web3: Web3) { &onchain.contracts().domain_separator, SecretKeyRef::from(&SecretKey::from_slice(trader_b.private_key()).unwrap()), ); - let balance_before = token_a - .balanceOf(trader_a.address().into_alloy()) - .call() - .await - .unwrap(); + let balance_before = token_a.balanceOf(trader_a.address()).call().await.unwrap(); let response = services.create_order(&new_order).await; let (error_code, _) = response.err().unwrap(); assert_eq!(error_code, StatusCode::UNAUTHORIZED); @@ -350,11 +338,7 @@ async fn try_replace_someone_else_order_test(web3: Web3) { tracing::info!("Waiting for trade."); wait_for_condition(TIMEOUT, || async { onchain.mint_block().await; - let balance_after = token_a - .balanceOf(trader_a.address().into_alloy()) - .call() - .await - .unwrap(); + let balance_after = token_a.balanceOf(trader_a.address()).call().await.unwrap(); balance_before.saturating_sub(balance_after) == eth(10) }) .await @@ -364,37 +348,37 @@ async fn try_replace_someone_else_order_test(web3: Web3) { async fn single_replace_order_test(web3: Web3) { let mut onchain = OnchainComponents::deploy(web3.clone()).await; - let [solver] = onchain.make_solvers(to_wei(1)).await; - let [trader] = onchain.make_accounts(to_wei(1)).await; + let [solver] = onchain.make_solvers(eth(1)).await; + let [trader] = onchain.make_accounts(eth(1)).await; let [token_a, token_b] = onchain .deploy_tokens_with_weth_uni_v2_pools(to_wei(1_000), to_wei(1_000)) .await; // Fund trader accounts - token_a.mint(trader.address(), to_wei(30)).await; + token_a.mint(trader.address(), eth(30)).await; // Create and fund Uniswap pool - token_a.mint(solver.address(), to_wei(1000)).await; - token_b.mint(solver.address(), to_wei(1000)).await; + token_a.mint(solver.address(), eth(1000)).await; + token_b.mint(solver.address(), eth(1000)).await; onchain .contracts() .uniswap_v2_factory .createPair(*token_a.address(), *token_b.address()) - .from(solver.address().into_alloy()) + .from(solver.address()) .send_and_watch() .await .unwrap(); token_a .approve(*onchain.contracts().uniswap_v2_router.address(), eth(1000)) - .from(solver.address().into_alloy()) + .from(solver.address()) .send_and_watch() .await .unwrap(); token_b .approve(*onchain.contracts().uniswap_v2_router.address(), eth(1000)) - .from(solver.address().into_alloy()) + .from(solver.address()) .send_and_watch() .await .unwrap(); @@ -408,10 +392,10 @@ async fn single_replace_order_test(web3: Web3) { eth(1000), U256::ZERO, U256::ZERO, - solver.address().into_alloy(), + solver.address(), U256::MAX, ) - .from(solver.address().into_alloy()) + .from(solver.address()) .send_and_watch() .await .unwrap(); @@ -420,7 +404,7 @@ async fn single_replace_order_test(web3: Web3) { token_a .approve(onchain.contracts().allowance.into_alloy(), eth(15)) - .from(trader.address().into_alloy()) + .from(trader.address()) .send_and_watch() .await .unwrap(); @@ -443,11 +427,7 @@ async fn single_replace_order_test(web3: Web3) { ) .await; - let balance_before = token_a - .balanceOf(trader.address().into_alloy()) - .call() - .await - .unwrap(); + let balance_before = token_a.balanceOf(trader.address()).call().await.unwrap(); let order = OrderCreation { sell_token: token_a.address().into_legacy(), sell_amount: to_wei(10), @@ -526,11 +506,7 @@ async fn single_replace_order_test(web3: Web3) { // Drive solution to verify that new order can be settled tracing::info!("Waiting for trade."); wait_for_condition(TIMEOUT, || async { - let balance_after = token_a - .balanceOf(trader.address().into_alloy()) - .call() - .await - .unwrap(); + let balance_after = token_a.balanceOf(trader.address()).call().await.unwrap(); onchain.mint_block().await; balance_before.saturating_sub(balance_after) == eth(3) }) diff --git a/crates/e2e/tests/e2e/smart_contract_orders.rs b/crates/e2e/tests/e2e/smart_contract_orders.rs index eb17c02e2e..0e238e7575 100644 --- a/crates/e2e/tests/e2e/smart_contract_orders.rs +++ b/crates/e2e/tests/e2e/smart_contract_orders.rs @@ -28,15 +28,15 @@ async fn local_node_max_gas_limit() { async fn smart_contract_orders(web3: Web3) { let mut onchain = OnchainComponents::deploy(web3.clone()).await; - let [solver] = onchain.make_solvers(to_wei(1)).await; - let [trader] = onchain.make_accounts(to_wei(1)).await; + let [solver] = onchain.make_solvers(eth(1)).await; + let [trader] = onchain.make_accounts(eth(1)).await; let safe = Safe::deploy(trader, web3.alloy.clone()).await; let [token] = onchain .deploy_tokens_with_weth_uni_v2_pools(to_wei(100_000), to_wei(100_000)) .await; - token.mint(safe.address().into_legacy(), to_wei(10)).await; + token.mint(safe.address(), eth(10)).await; // Approve GPv2 for trading safe.exec_alloy_call( @@ -156,7 +156,7 @@ async fn smart_contract_orders(web3: Web3) { async fn erc1271_gas_limit(web3: Web3) { let mut onchain = OnchainComponents::deploy(web3.clone()).await; - let [solver] = onchain.make_solvers(to_wei(1)).await; + let [solver] = onchain.make_solvers(eth(1)).await; let trader = contracts::alloy::test::GasHog::Instance::deploy(web3.alloy.clone()) .await .unwrap(); @@ -166,14 +166,14 @@ async fn erc1271_gas_limit(web3: Web3) { .await; // Fund trader accounts and approve relayer - cow.fund(trader.address().into_legacy(), to_wei(5)).await; + cow.fund(*trader.address(), eth(5)).await; trader .approve( *cow.address(), onchain.contracts().allowance.into_alloy(), eth(10), ) - .from(solver.address().into_alloy()) + .from(solver.address()) .send_and_watch() .await .unwrap(); diff --git a/crates/e2e/tests/e2e/solver_competition.rs b/crates/e2e/tests/e2e/solver_competition.rs index 85dcbcd069..351862cd39 100644 --- a/crates/e2e/tests/e2e/solver_competition.rs +++ b/crates/e2e/tests/e2e/solver_competition.rs @@ -37,21 +37,21 @@ async fn local_node_store_filtered_solutions() { async fn solver_competition(web3: Web3) { let mut onchain = OnchainComponents::deploy(web3).await; - let [solver] = onchain.make_solvers(to_wei(1)).await; - let [trader] = onchain.make_accounts(to_wei(1)).await; + let [solver] = onchain.make_solvers(eth(1)).await; + let [trader] = onchain.make_accounts(eth(1)).await; let [token_a] = onchain .deploy_tokens_with_weth_uni_v2_pools(to_wei(1_000), to_wei(1_000)) .await; // Fund trader, settlement accounts, and pool creation - token_a.mint(trader.address(), to_wei(10)).await; - token_a.mint(solver.address(), to_wei(1000)).await; + token_a.mint(trader.address(), eth(10)).await; + token_a.mint(solver.address(), eth(1000)).await; // Approve GPv2 for trading token_a .approve(onchain.contracts().allowance.into_alloy(), eth(100)) - .from(trader.address().into_alloy()) + .from(trader.address()) .send_and_watch() .await .unwrap(); @@ -117,11 +117,11 @@ async fn solver_competition(web3: Web3) { tracing::info!("waiting for trade"); let trade_happened = || async { token_a - .balanceOf(trader.address().into_alloy()) + .balanceOf(trader.address()) .call() .await .unwrap() - == U256::ZERO + .is_zero() }; wait_for_condition(TIMEOUT, trade_happened).await.unwrap(); @@ -156,15 +156,15 @@ async fn solver_competition(web3: Web3) { async fn wrong_solution_submission_address(web3: Web3) { let mut onchain = OnchainComponents::deploy(web3).await; - let [solver] = onchain.make_solvers(to_wei(1)).await; - let [trader_a, trader_b] = onchain.make_accounts(to_wei(1)).await; + let [solver] = onchain.make_solvers(eth(1)).await; + let [trader_a, trader_b] = onchain.make_accounts(eth(1)).await; let [token_a, token_b] = onchain .deploy_tokens_with_weth_uni_v2_pools(to_wei(1_000), to_wei(1_000)) .await; // Fund traders - token_a.mint(trader_a.address(), to_wei(10)).await; - token_b.mint(trader_b.address(), to_wei(10)).await; + token_a.mint(trader_a.address(), eth(10)).await; + token_b.mint(trader_b.address(), eth(10)).await; // Create more liquid routes between token_a (token_b) and weth via base_a // (base_b). base_a has more liquidity then base_b, leading to the solver that @@ -173,24 +173,24 @@ async fn wrong_solution_submission_address(web3: Web3) { .deploy_tokens_with_weth_uni_v2_pools(to_wei(10_000), to_wei(10_000)) .await; onchain - .seed_uni_v2_pool((&token_a, to_wei(100_000)), (&base_a, to_wei(100_000))) + .seed_uni_v2_pool((&token_a, eth(100_000)), (&base_a, eth(100_000))) .await; onchain - .seed_uni_v2_pool((&token_b, to_wei(10_000)), (&base_b, to_wei(10_000))) + .seed_uni_v2_pool((&token_b, eth(10_000)), (&base_b, eth(10_000))) .await; // Approve GPv2 for trading token_a .approve(onchain.contracts().allowance.into_alloy(), eth(100)) - .from(trader_a.address().into_alloy()) + .from(trader_a.address()) .send_and_watch() .await .unwrap(); token_b .approve(onchain.contracts().allowance.into_alloy(), eth(100)) - .from(trader_b.address().into_alloy()) + .from(trader_b.address()) .send_and_watch() .await .unwrap(); @@ -295,7 +295,7 @@ async fn wrong_solution_submission_address(web3: Web3) { tracing::info!(?competition, "competition"); assert_eq!( competition.solutions.last().unwrap().solver_address, - solver.address().into_alloy() + solver.address() ); assert_eq!(competition.solutions.len(), 1); } @@ -303,8 +303,8 @@ async fn wrong_solution_submission_address(web3: Web3) { async fn store_filtered_solutions(web3: Web3) { let mut onchain = OnchainComponents::deploy(web3.clone()).await; - let [good_solver_account, bad_solver_account] = onchain.make_solvers(to_wei(100)).await; - let [trader] = onchain.make_accounts(to_wei(100)).await; + let [good_solver_account, bad_solver_account] = onchain.make_solvers(eth(100)).await; + let [trader] = onchain.make_accounts(eth(100)).await; let [token_a, token_b, token_c] = onchain .deploy_tokens_with_weth_uni_v2_pools(to_wei(300_000), to_wei(1_000)) .await; @@ -312,24 +312,18 @@ async fn store_filtered_solutions(web3: Web3) { // give the settlement contract a ton of the traded tokens so that the mocked // solver solutions can simply give money away to make the trade execute token_b - .mint( - onchain.contracts().gp_settlement.address().into_legacy(), - to_wei(50), - ) + .mint(*onchain.contracts().gp_settlement.address(), eth(50)) .await; token_c - .mint( - onchain.contracts().gp_settlement.address().into_legacy(), - to_wei(50), - ) + .mint(*onchain.contracts().gp_settlement.address(), eth(50)) .await; // set up trader for their order - token_a.mint(trader.address(), to_wei(2)).await; + token_a.mint(trader.address(), eth(2)).await; token_a .approve(onchain.contracts().allowance.into_alloy(), eth(2)) - .from(trader.address().into_alloy()) + .from(trader.address()) .send_and_watch() .await .unwrap(); @@ -529,8 +523,8 @@ async fn store_filtered_solutions(web3: Web3) { assert_eq!( competition .reference_scores - .get(&good_solver_account.address().into_alloy()), - Some(&0.into()) + .get(&good_solver_account.address()), + Some(&U256::ZERO) ); assert_eq!(competition.solutions.len(), 2); @@ -540,10 +534,7 @@ async fn store_filtered_solutions(web3: Web3) { assert_eq!(bad_solution.ranking, 2); assert!(bad_solution.filtered_out); assert!(!bad_solution.is_winner); - assert_eq!( - bad_solution.solver_address, - bad_solver_account.address().into_alloy() - ); + assert_eq!(bad_solution.solver_address, bad_solver_account.address()); assert!(bad_solution.tx_hash.is_none()); assert!(bad_solution.reference_score.is_none()); @@ -551,13 +542,10 @@ async fn store_filtered_solutions(web3: Web3) { assert_eq!(good_solution.ranking, 1); assert!(!good_solution.filtered_out); assert!(good_solution.is_winner); - assert_eq!( - good_solution.solver_address, - good_solver_account.address().into_alloy() - ); + assert_eq!(good_solution.solver_address, good_solver_account.address()); assert_eq!(good_solution.tx_hash.unwrap(), trade.tx_hash.unwrap()); // since the only other solutions were unfair the reference score is zero - assert_eq!(good_solution.reference_score, Some(0.into())); + assert_eq!(good_solution.reference_score, Some(U256::ZERO)); // check that new DB tables contain the filtered solution let mut db = services.db().acquire().await.unwrap(); diff --git a/crates/e2e/tests/e2e/solver_participation_guard.rs b/crates/e2e/tests/e2e/solver_participation_guard.rs index dcc1e34ebe..9898443166 100644 --- a/crates/e2e/tests/e2e/solver_participation_guard.rs +++ b/crates/e2e/tests/e2e/solver_participation_guard.rs @@ -51,7 +51,7 @@ async fn local_node_not_allowed_solver() { async fn non_settling_solver(web3: Web3) { let mut onchain = OnchainComponents::deploy(web3.clone()).await; - let [solver, solver_b] = onchain.make_solvers(to_wei(1)).await; + let [solver, solver_b] = onchain.make_solvers(eth(1)).await; let (trader_a, token_a, token_b) = setup(&mut onchain, &solver).await; let services = Services::new(&onchain).await; @@ -90,7 +90,7 @@ async fn non_settling_solver(web3: Web3) { .take(3) .cloned() .collect::>(); - replace_solver_for_auction_ids(pool, &last_auctions, &solver_b.address()).await; + replace_solver_for_auction_ids(pool, &last_auctions, &solver_b.address().into_legacy()).await; // The competition still passes since the stats are updated only after a new // solution from anyone is received and stored. let now = Instant::now(); @@ -122,7 +122,7 @@ async fn non_settling_solver(web3: Web3) { async fn low_settling_solver(web3: Web3) { let mut onchain = OnchainComponents::deploy(web3.clone()).await; - let [solver, solver_b] = onchain.make_solvers(to_wei(1)).await; + let [solver, solver_b] = onchain.make_solvers(eth(1)).await; let (trader_a, token_a, token_b) = setup(&mut onchain, &solver).await; let services = Services::new(&onchain).await; @@ -162,7 +162,7 @@ async fn low_settling_solver(web3: Web3) { .enumerate() .filter_map(|(i, id)| (i % 2 == 0).then_some(*id)) .collect::>(); - replace_solver_for_auction_ids(pool, &random_auctions, &solver_b.address()).await; + replace_solver_for_auction_ids(pool, &random_auctions, &solver_b.address().into_legacy()).await; // The competition still passes since the stats are updated only after a new // solution from anyone is received and stored. let now = Instant::now(); @@ -194,7 +194,7 @@ async fn low_settling_solver(web3: Web3) { async fn not_allowed_solver(web3: Web3) { let mut onchain = OnchainComponents::deploy(web3.clone()).await; - let [solver] = onchain.make_solvers(to_wei(1)).await; + let [solver] = onchain.make_solvers(eth(1)).await; let (trader_a, token_a, token_b) = setup(&mut onchain, &solver).await; let solver_address = solver.address(); @@ -209,7 +209,7 @@ async fn not_allowed_solver(web3: Web3) { onchain .contracts() .gp_authenticator - .removeSolver(solver_address.into_alloy()) + .removeSolver(solver_address) .send_and_watch() .await .unwrap(); @@ -224,7 +224,7 @@ async fn not_allowed_solver(web3: Web3) { onchain .contracts() .gp_authenticator - .addSolver(solver_address.into_alloy()) + .addSolver(solver_address) .send_and_watch() .await .unwrap(); @@ -238,36 +238,36 @@ async fn setup( onchain: &mut OnchainComponents, solver: &TestAccount, ) -> (TestAccount, MintableToken, MintableToken) { - let [trader_a] = onchain.make_accounts(to_wei(1)).await; + let [trader_a] = onchain.make_accounts(eth(1)).await; let [token_a, token_b] = onchain .deploy_tokens_with_weth_uni_v2_pools(to_wei(1_000), to_wei(1_000)) .await; // Fund trader accounts - token_a.mint(trader_a.address(), to_wei(1000)).await; + token_a.mint(trader_a.address(), eth(1000)).await; // Create and fund Uniswap pool - token_a.mint(solver.address(), to_wei(1000)).await; - token_b.mint(solver.address(), to_wei(1000)).await; + token_a.mint(solver.address(), eth(1000)).await; + token_b.mint(solver.address(), eth(1000)).await; onchain .contracts() .uniswap_v2_factory .createPair(*token_a.address(), *token_b.address()) - .from(solver.address().into_alloy()) + .from(solver.address()) .send_and_watch() .await .unwrap(); token_a .approve(*onchain.contracts().uniswap_v2_router.address(), eth(1000)) - .from(solver.address().into_alloy()) + .from(solver.address()) .send_and_watch() .await .unwrap(); token_b .approve(*onchain.contracts().uniswap_v2_router.address(), eth(1000)) - .from(solver.address().into_alloy()) + .from(solver.address()) .send_and_watch() .await .unwrap(); @@ -281,10 +281,10 @@ async fn setup( eth(1000), U256::ZERO, U256::ZERO, - solver.address().into_alloy(), + solver.address(), U256::MAX, ) - .from(solver.address().into_alloy()) + .from(solver.address()) .send_and_watch() .await .unwrap(); @@ -293,7 +293,7 @@ async fn setup( token_a .approve(onchain.contracts().allowance.into_alloy(), eth(1000)) - .from(trader_a.address().into_alloy()) + .from(trader_a.address()) .send_and_watch() .await .unwrap(); @@ -346,11 +346,7 @@ async fn execute_order( &onchain.contracts().domain_separator, SecretKeyRef::from(&SecretKey::from_slice(trader_a.private_key()).unwrap()), ); - let balance_before = token_b - .balanceOf(trader_a.address().into_alloy()) - .call() - .await - .unwrap(); + let balance_before = token_b.balanceOf(trader_a.address()).call().await.unwrap(); let order_id = services.create_order(&order).await.unwrap(); onchain.mint_block().await; let limit_order = services.get_order(&order_id).await.unwrap(); @@ -360,11 +356,7 @@ async fn execute_order( // Drive solution tracing::info!("Waiting for trade."); wait_for_condition(TIMEOUT, || async { - let balance_after = token_b - .balanceOf(trader_a.address().into_alloy()) - .call() - .await - .unwrap(); + let balance_after = token_b.balanceOf(trader_a.address()).call().await.unwrap(); let balance_changes = balance_after.checked_sub(balance_before).unwrap() >= eth(5); let auction_ids_after = fetch_last_settled_auction_ids(services.db()).await.len() > auction_ids_before; diff --git a/crates/e2e/tests/e2e/submission.rs b/crates/e2e/tests/e2e/submission.rs index 89416eba00..60a2c63b5d 100644 --- a/crates/e2e/tests/e2e/submission.rs +++ b/crates/e2e/tests/e2e/submission.rs @@ -26,9 +26,9 @@ async fn local_node_test() { async fn test_cancel_on_expiry(web3: Web3) { let mut onchain = OnchainComponents::deploy(web3.clone()).await; - let [solver] = onchain.make_solvers(to_wei(10)).await; + let [solver] = onchain.make_solvers(eth(10)).await; let nonce = solver.nonce(&web3).await; - let [trader] = onchain.make_accounts(to_wei(10)).await; + let [trader] = onchain.make_accounts(eth(10)).await; let [token] = onchain .deploy_tokens_with_weth_uni_v2_pools(to_wei(1_000), to_wei(1_000)) .await; @@ -37,7 +37,7 @@ async fn test_cancel_on_expiry(web3: Web3) { .contracts() .weth .approve(onchain.contracts().allowance.into_alloy(), eth(3)) - .from(trader.address().into_alloy()) + .from(trader.address()) .send_and_watch() .await .unwrap(); @@ -45,7 +45,7 @@ async fn test_cancel_on_expiry(web3: Web3) { .contracts() .weth .deposit() - .from(trader.address().into_alloy()) + .from(trader.address()) .value(eth(3)) .send_and_watch() .await @@ -62,11 +62,7 @@ async fn test_cancel_on_expiry(web3: Web3) { .expect("Must be able to disable automine"); tracing::info!("Placing order"); - let balance = token - .balanceOf(trader.address().into_alloy()) - .call() - .await - .unwrap(); + let balance = token.balanceOf(trader.address()).call().await.unwrap(); assert_eq!(balance, U256::ZERO); let order = OrderCreation { sell_token: onchain.contracts().weth.address().into_legacy(), diff --git a/crates/e2e/tests/e2e/tracking_insufficient_funds.rs b/crates/e2e/tests/e2e/tracking_insufficient_funds.rs index e0094a3f90..eea7456e6b 100644 --- a/crates/e2e/tests/e2e/tracking_insufficient_funds.rs +++ b/crates/e2e/tests/e2e/tracking_insufficient_funds.rs @@ -24,8 +24,8 @@ async fn test(web3: Web3) { tracing::info!("Setting up chain state."); let mut onchain = OnchainComponents::deploy(web3).await; - let [solver] = onchain.make_solvers(to_wei(10)).await; - let [trader_a, trader_b] = onchain.make_accounts(to_wei(10)).await; + let [solver] = onchain.make_solvers(eth(10)).await; + let [trader_a, trader_b] = onchain.make_accounts(eth(10)).await; let [token] = onchain .deploy_tokens_with_weth_uni_v2_pools(to_wei(1_000), to_wei(1_000)) .await; @@ -34,7 +34,7 @@ async fn test(web3: Web3) { .contracts() .weth .approve(onchain.contracts().allowance.into_alloy(), eth(3)) - .from(trader_a.address().into_alloy()) + .from(trader_a.address()) .send_and_watch() .await .unwrap(); @@ -42,7 +42,7 @@ async fn test(web3: Web3) { .contracts() .weth .deposit() - .from(trader_a.address().into_alloy()) + .from(trader_a.address()) .value(eth(3)) .send_and_watch() .await @@ -51,7 +51,7 @@ async fn test(web3: Web3) { .contracts() .weth .approve(onchain.contracts().allowance.into_alloy(), eth(3)) - .from(trader_b.address().into_alloy()) + .from(trader_b.address()) .send_and_watch() .await .unwrap(); @@ -59,7 +59,7 @@ async fn test(web3: Web3) { .contracts() .weth .deposit() - .from(trader_b.address().into_alloy()) + .from(trader_b.address()) .value(eth(3)) .send_and_watch() .await @@ -106,7 +106,7 @@ async fn test(web3: Web3) { .contracts() .weth .withdraw(eth(3)) - .from(trader_a.address().into_alloy()) + .from(trader_a.address()) .send_and_watch() .await .unwrap(); @@ -114,7 +114,7 @@ async fn test(web3: Web3) { .contracts() .weth .withdraw(eth(3)) - .from(trader_b.address().into_alloy()) + .from(trader_b.address()) .send_and_watch() .await .unwrap(); @@ -139,7 +139,7 @@ async fn test(web3: Web3) { .contracts() .weth .deposit() - .from(trader_a.address().into_alloy()) + .from(trader_a.address()) .value(eth(3)) .send_and_watch() .await @@ -161,7 +161,7 @@ async fn test(web3: Web3) { .contracts() .weth .deposit() - .from(trader_b.address().into_alloy()) + .from(trader_b.address()) .value(eth(3)) .send_and_watch() .await diff --git a/crates/e2e/tests/e2e/uncovered_order.rs b/crates/e2e/tests/e2e/uncovered_order.rs index 97fb964011..3159477a4f 100644 --- a/crates/e2e/tests/e2e/uncovered_order.rs +++ b/crates/e2e/tests/e2e/uncovered_order.rs @@ -26,15 +26,15 @@ async fn test(web3: Web3) { tracing::info!("Setting up chain state."); let mut onchain = OnchainComponents::deploy(web3).await; - let [solver] = onchain.make_solvers(to_wei(10)).await; - let [trader] = onchain.make_accounts(to_wei(10)).await; + let [solver] = onchain.make_solvers(eth(10)).await; + let [trader] = onchain.make_accounts(eth(10)).await; let [token] = onchain .deploy_tokens_with_weth_uni_v2_pools(to_wei(1_000), to_wei(1_000)) .await; let weth = &onchain.contracts().weth; weth.approve(onchain.contracts().allowance.into_alloy(), eth(3)) - .from(trader.address().into_alloy()) + .from(trader.address()) .send_and_watch() .await .unwrap(); @@ -66,7 +66,7 @@ async fn test(web3: Web3) { tracing::info!("Placing order with 1 wei of sell_tokens"); weth.deposit() - .from(trader.address().into_alloy()) + .from(trader.address()) .value(::alloy::primitives::U256::ONE) .send_and_watch() .await @@ -77,7 +77,7 @@ async fn test(web3: Web3) { tracing::info!("Deposit ETH to make order executable"); weth.deposit() - .from(trader.address().into_alloy()) + .from(trader.address()) .value(eth(2)) .send_and_watch() .await @@ -85,11 +85,7 @@ async fn test(web3: Web3) { tracing::info!("Waiting for trade."); wait_for_condition(TIMEOUT, || async { - let balance_after = weth - .balanceOf(trader.address().into_alloy()) - .call() - .await - .unwrap(); + let balance_after = weth.balanceOf(trader.address()).call().await.unwrap(); !balance_after.is_zero() }) .await diff --git a/crates/e2e/tests/e2e/univ2.rs b/crates/e2e/tests/e2e/univ2.rs index 27792283f4..f781e43ba1 100644 --- a/crates/e2e/tests/e2e/univ2.rs +++ b/crates/e2e/tests/e2e/univ2.rs @@ -26,8 +26,8 @@ async fn test(web3: Web3) { tracing::info!("Setting up chain state."); let mut onchain = OnchainComponents::deploy(web3).await; - let [solver] = onchain.make_solvers(to_wei(10)).await; - let [trader] = onchain.make_accounts(to_wei(10)).await; + let [solver] = onchain.make_solvers(eth(10)).await; + let [trader] = onchain.make_accounts(eth(10)).await; let [token] = onchain .deploy_tokens_with_weth_uni_v2_pools(to_wei(1_000), to_wei(1_000)) .await; @@ -36,7 +36,7 @@ async fn test(web3: Web3) { .contracts() .weth .approve(onchain.contracts().allowance.into_alloy(), eth(3)) - .from(trader.address().into_alloy()) + .from(trader.address()) .send_and_watch() .await .unwrap(); @@ -44,7 +44,7 @@ async fn test(web3: Web3) { .contracts() .weth .deposit() - .from(trader.address().into_alloy()) + .from(trader.address()) .value(eth(3)) .send_and_watch() .await @@ -55,11 +55,7 @@ async fn test(web3: Web3) { services.start_protocol(solver.clone()).await; tracing::info!("Placing order"); - let balance = token - .balanceOf(trader.address().into_alloy()) - .call() - .await - .unwrap(); + let balance = token.balanceOf(trader.address()).call().await.unwrap(); assert_eq!(balance, U256::ZERO); let order = OrderCreation { sell_token: onchain.contracts().weth.address().into_legacy(), @@ -88,7 +84,7 @@ async fn test(web3: Web3) { Default::default(), [ vec![GPv2Settlement::GPv2Interaction::Data { - target: trader.address().into_alloy(), + target: trader.address(), value: U256::ZERO, callData: Default::default(), }], @@ -96,27 +92,23 @@ async fn test(web3: Web3) { Default::default(), ], ) - .from(solver.address().into_alloy()) + .from(solver.address()) .send_and_watch() .await .unwrap(); tracing::info!("Waiting for trade."); let trade_happened = || async { - token - .balanceOf(trader.address().into_alloy()) + !token + .balanceOf(trader.address()) .call() .await .unwrap() - != U256::ZERO + .is_zero() }; wait_for_condition(TIMEOUT, trade_happened).await.unwrap(); - let balance = token - .balanceOf(trader.address().into_alloy()) - .call() - .await - .unwrap(); + let balance = token.balanceOf(trader.address()).call().await.unwrap(); assert_eq!(balance, eth(1)); let all_events_registered = || async { diff --git a/crates/e2e/tests/e2e/vault_balances.rs b/crates/e2e/tests/e2e/vault_balances.rs index 5491410586..2569021e8d 100644 --- a/crates/e2e/tests/e2e/vault_balances.rs +++ b/crates/e2e/tests/e2e/vault_balances.rs @@ -22,19 +22,19 @@ async fn local_node_vault_balances() { async fn vault_balances(web3: Web3) { let mut onchain = OnchainComponents::deploy(web3).await; - let [solver] = onchain.make_solvers(to_wei(1)).await; - let [trader] = onchain.make_accounts(to_wei(1)).await; + let [solver] = onchain.make_solvers(eth(1)).await; + let [trader] = onchain.make_accounts(eth(1)).await; let [token] = onchain .deploy_tokens_with_weth_uni_v2_pools(to_wei(1_000), to_wei(1_000)) .await; - token.mint(trader.address(), to_wei(10)).await; + token.mint(trader.address(), eth(10)).await; // Approve GPv2 for trading token .approve(*onchain.contracts().balancer_vault.address(), eth(10)) - .from(trader.address().into_alloy()) + .from(trader.address()) .send_and_watch() .await .unwrap(); @@ -42,11 +42,11 @@ async fn vault_balances(web3: Web3) { .contracts() .balancer_vault .setRelayerApproval( - trader.address().into_alloy(), + trader.address(), onchain.contracts().allowance.into_alloy(), true, ) - .from(trader.address().into_alloy()) + .from(trader.address()) .send_and_watch() .await .unwrap(); @@ -75,7 +75,7 @@ async fn vault_balances(web3: Web3) { let balance_before = onchain .contracts() .weth - .balanceOf(trader.address().into_alloy()) + .balanceOf(trader.address()) .call() .await .unwrap(); @@ -84,7 +84,7 @@ async fn vault_balances(web3: Web3) { tracing::info!("Waiting for trade."); wait_for_condition(TIMEOUT, || async { let token_balance = token - .balanceOf(trader.address().into_alloy()) + .balanceOf(trader.address()) .call() .await .expect("Couldn't fetch token balance"); @@ -92,7 +92,7 @@ async fn vault_balances(web3: Web3) { let weth_balance_after = onchain .contracts() .weth - .balanceOf(trader.address().into_alloy()) + .balanceOf(trader.address()) .call() .await .unwrap(); diff --git a/crates/e2e/tests/e2e/wrapper.rs b/crates/e2e/tests/e2e/wrapper.rs index 55b07a95bc..612166664b 100644 --- a/crates/e2e/tests/e2e/wrapper.rs +++ b/crates/e2e/tests/e2e/wrapper.rs @@ -48,8 +48,8 @@ async fn forked_node_mainnet_wrapper() { async fn forked_mainnet_wrapper_test(web3: Web3) { let mut onchain = OnchainComponents::deployed(web3.clone()).await; - let [solver] = onchain.make_solvers_forked(to_wei(1)).await; - let [trader] = onchain.make_accounts(to_wei(2)).await; + let [solver] = onchain.make_solvers_forked(eth(1)).await; + let [trader] = onchain.make_accounts(eth(2)).await; let token_weth = onchain.contracts().weth.clone(); let token_usdc = ERC20::Instance::new( @@ -75,7 +75,7 @@ async fn forked_mainnet_wrapper_test(web3: Web3) { ) .into_transaction_request(), ImpersonateConfig { - fund_amount: Some(to_wei(1).into_alloy()), + fund_amount: Some(eth(1)), stop_impersonate: true, }, ) @@ -88,19 +88,16 @@ async fn forked_mainnet_wrapper_test(web3: Web3) { // Trader deposits ETH to get WETH token_weth .deposit() - .value(to_wei(1).into_alloy()) - .from(trader.address().into_alloy()) + .value(eth(1)) + .from(trader.address()) .send_and_watch() .await .unwrap(); // Approve GPv2 for trading token_weth - .approve( - onchain.contracts().allowance.into_alloy(), - to_wei(1).into_alloy(), - ) - .from(trader.address().into_alloy()) + .approve(onchain.contracts().allowance.into_alloy(), eth(1)) + .from(trader.address()) .send_and_watch() .await .unwrap(); @@ -171,16 +168,8 @@ async fn forked_mainnet_wrapper_test(web3: Web3) { SecretKeyRef::from(&SecretKey::from_slice(trader.private_key()).unwrap()), ); - let sell_token_balance_before = token_weth - .balanceOf(trader.address().into_alloy()) - .call() - .await - .unwrap(); - let buy_token_balance_before = token_usdc - .balanceOf(trader.address().into_alloy()) - .call() - .await - .unwrap(); + let sell_token_balance_before = token_weth.balanceOf(trader.address()).call().await.unwrap(); + let buy_token_balance_before = token_usdc.balanceOf(trader.address()).call().await.unwrap(); // Create the order let order_uid = services.create_order(&order).await.unwrap(); @@ -203,16 +192,8 @@ async fn forked_mainnet_wrapper_test(web3: Web3) { wait_for_condition(TIMEOUT, || async { onchain.mint_block().await; - let sell_token_balance_after = token_weth - .balanceOf(trader.address().into_alloy()) - .call() - .await - .unwrap(); - let buy_token_balance_after = token_usdc - .balanceOf(trader.address().into_alloy()) - .call() - .await - .unwrap(); + let sell_token_balance_after = token_weth.balanceOf(trader.address()).call().await.unwrap(); + let buy_token_balance_after = token_usdc.balanceOf(trader.address()).call().await.unwrap(); (sell_token_balance_before > sell_token_balance_after) && (buy_token_balance_after > buy_token_balance_before) diff --git a/crates/model/src/order.rs b/crates/model/src/order.rs index e9649ebd3b..970c50db0f 100644 --- a/crates/model/src/order.rs +++ b/crates/model/src/order.rs @@ -273,22 +273,9 @@ impl OrderData { /// Checks if the order is a market order. pub fn within_market(&self, quote: QuoteAmounts) -> bool { - // Manual transformation because this crate doesn't have the conversiont trait - let mut buy_buffer = [0; 32]; - quote.buy.to_big_endian(&mut buy_buffer); - let quote_buy = alloy::primitives::U256::from_be_bytes(buy_buffer); - - let mut sell_buffer = [0; 32]; - quote.sell.to_big_endian(&mut sell_buffer); - let quote_sell = alloy::primitives::U256::from_be_bytes(sell_buffer); - - let mut fee_buffer = [0; 32]; - quote.fee.to_big_endian(&mut fee_buffer); - let quote_fee = alloy::primitives::U256::from_be_bytes(fee_buffer); - // Using let here because widening_mul isn't able to infer the result size - let lhs: U512 = (self.sell_amount + self.fee_amount).widening_mul(quote_buy); - let rhs: U512 = (quote_sell + quote_fee).widening_mul(self.buy_amount); + let lhs: U512 = (self.sell_amount + self.fee_amount).widening_mul(quote.buy); + let rhs: U512 = (quote.sell + quote.fee).widening_mul(self.buy_amount); lhs >= rhs } } @@ -297,9 +284,9 @@ impl OrderData { /// sell token and buy `buy` amount of buy token. Additionally, `fee`` /// denominated in the sell token needs to be payed. pub struct QuoteAmounts { - pub sell: U256, - pub buy: U256, - pub fee: U256, + pub sell: alloy::primitives::U256, + pub buy: alloy::primitives::U256, + pub fee: alloy::primitives::U256, } /// An order as provided to the POST order endpoint. diff --git a/crates/model/src/quote.rs b/crates/model/src/quote.rs index 171fbd9da5..c1dc2dd05c 100644 --- a/crates/model/src/quote.rs +++ b/crates/model/src/quote.rs @@ -4,12 +4,11 @@ use { signature::SigningScheme, time, }, - alloy::primitives::Address, + alloy::primitives::{Address, U256}, anyhow::bail, app_data::AppDataHash, chrono::{DateTime, Utc}, number::{nonzero::U256 as NonZeroU256, serialization::HexOrDecimalU256}, - primitive_types::{H160, U256}, serde::{ Deserialize, Deserializer, @@ -304,9 +303,9 @@ pub enum SellAmount { #[derive(Clone, Debug, Eq, PartialEq, Deserialize, Serialize)] #[serde(rename_all = "camelCase")] pub struct OrderQuote { - pub sell_token: H160, - pub buy_token: H160, - pub receiver: Option, + pub sell_token: Address, + pub buy_token: Address, + pub receiver: Option
, #[serde_as(as = "HexOrDecimalU256")] pub sell_amount: U256, #[serde_as(as = "HexOrDecimalU256")] @@ -330,7 +329,7 @@ pub type QuoteId = i64; #[serde(rename_all = "camelCase")] pub struct OrderQuoteResponse { pub quote: OrderQuote, - pub from: H160, + pub from: Address, pub expiration: DateTime, pub id: Option, pub verified: bool, diff --git a/crates/model/src/solver_competition.rs b/crates/model/src/solver_competition.rs index 56c101643f..e2532459a8 100644 --- a/crates/model/src/solver_competition.rs +++ b/crates/model/src/solver_competition.rs @@ -1,8 +1,7 @@ use { crate::{AuctionId, order::OrderUid}, - alloy::primitives::{Address, B256}, + alloy::primitives::{Address, B256, U256}, number::serialization::HexOrDecimalU256, - primitive_types::U256, serde::{Deserialize, Serialize}, serde_with::serde_as, std::collections::BTreeMap, @@ -36,7 +35,7 @@ pub struct SolverCompetitionAPI { pub struct CompetitionAuction { pub orders: Vec, #[serde_as(as = "BTreeMap<_, HexOrDecimalU256>")] - pub prices: BTreeMap, + pub prices: BTreeMap, } #[serde_as] @@ -51,7 +50,7 @@ pub struct SolverSettlement { #[serde(default)] pub ranking: usize, #[serde_as(as = "BTreeMap<_, HexOrDecimalU256>")] - pub clearing_prices: BTreeMap, + pub clearing_prices: BTreeMap, pub orders: Vec, #[serde(default)] pub is_winner: bool, @@ -189,28 +188,28 @@ mod tests { OrderUid([0x33; 56]), ], prices: btreemap! { - Address::repeat_byte(0x11) => alloy::primitives::U256::from(1000), - Address::repeat_byte(0x22) => alloy::primitives::U256::from(2000), - Address::repeat_byte(0x33) => alloy::primitives::U256::from(3000), + Address::repeat_byte(0x11) => U256::from(1000), + Address::repeat_byte(0x22) => U256::from(2000), + Address::repeat_byte(0x33) => U256::from(3000), }, }, solutions: vec![SolverSettlement { solver: "2".to_string(), solver_address: Address::repeat_byte(0x22), - score: Some(Score::Solver(1.into())), + score: Some(Score::Solver(U256::ONE)), ranking: 1, clearing_prices: btreemap! { - Address::repeat_byte(0x22) => alloy::primitives::U256::from(8), + Address::repeat_byte(0x22) => U256::from(8), }, orders: vec![ Order::Colocated { id: OrderUid([0x33; 56]), - sell_amount: alloy::primitives::U256::from(12), - buy_amount: alloy::primitives::U256::from(13), + sell_amount: U256::from(12), + buy_amount: U256::from(13), }, Order::Legacy { id: OrderUid([0x44; 56]), - executed_amount: alloy::primitives::U256::from(14), + executed_amount: U256::from(14), }, ], is_winner: true, diff --git a/crates/model/src/solver_competition_v2.rs b/crates/model/src/solver_competition_v2.rs index bb5d154db8..30d83f8a02 100644 --- a/crates/model/src/solver_competition_v2.rs +++ b/crates/model/src/solver_competition_v2.rs @@ -1,8 +1,7 @@ use { crate::{AuctionId, order::OrderUid}, - alloy::primitives::{Address, B256}, + alloy::primitives::{Address, B256, U256}, number::serialization::HexOrDecimalU256, - primitive_types::U256, serde::{Deserialize, Serialize}, serde_with::serde_as, std::collections::BTreeMap, @@ -121,32 +120,32 @@ mod tests { auction_start_block: 13, transaction_hashes: vec![tx], reference_scores: btreemap! { - solver => 0.into() + solver => U256::ZERO }, auction: Auction { orders: vec![OrderUid([0x11; 56])], prices: btreemap! { - Address::new([0x22; 20]) => 2000.into(), + Address::new([0x22; 20]) => U256::from(2000), }, }, solutions: vec![Solution { solver_address: solver, - score: 123.into(), + score: U256::from(123), ranking: 1, clearing_prices: btreemap! { - Address::new([0x22; 20]) => 8.into(), + Address::new([0x22; 20]) => U256::from(8), }, orders: vec![Order { id: OrderUid([0x11; 56]), - sell_amount: 12.into(), - buy_amount: 13.into(), + sell_amount: U256::from(12), + buy_amount: U256::from(13), buy_token: Address::new([0x22; 20]), sell_token: Address::new([0x22; 20]), }], is_winner: true, filtered_out: false, tx_hash: Some(tx), - reference_score: Some(10.into()), + reference_score: Some(U256::from(10)), }], }; diff --git a/crates/orderbook/src/api/post_quote.rs b/crates/orderbook/src/api/post_quote.rs index 46d18a06cd..ce8d9d2b75 100644 --- a/crates/orderbook/src/api/post_quote.rs +++ b/crates/orderbook/src/api/post_quote.rs @@ -92,7 +92,6 @@ mod tests { anyhow::anyhow, app_data::AppDataHash, chrono::{TimeZone, Utc}, - ethcontract::H160, model::{ order::{BuyTokenDestination, SellTokenSource}, quote::{ @@ -315,7 +314,7 @@ mod tests { }; let order_quote_response = OrderQuoteResponse { quote, - from: H160::zero(), + from: Address::ZERO, expiration: Utc.timestamp_millis_opt(0).unwrap(), id: Some(0), verified: false, diff --git a/crates/orderbook/src/database/solver_competition_v2.rs b/crates/orderbook/src/database/solver_competition_v2.rs index 71d735e089..8a38620fb4 100644 --- a/crates/orderbook/src/database/solver_competition_v2.rs +++ b/crates/orderbook/src/database/solver_competition_v2.rs @@ -8,7 +8,7 @@ use { order::OrderUid, solver_competition_v2::{Auction, Order, Response as ApiResponse, Solution}, }, - number::conversions::big_decimal_to_u256, + number::conversions::alloy::big_decimal_to_u256, std::collections::{BTreeMap, HashMap}, }; diff --git a/crates/orderbook/src/quoter.rs b/crates/orderbook/src/quoter.rs index dec7eb7769..7b274d4d60 100644 --- a/crates/orderbook/src/quoter.rs +++ b/crates/orderbook/src/quoter.rs @@ -5,7 +5,6 @@ use { }, alloy::primitives::{U256, U512, Uint, ruint::UintTryFrom}, chrono::{TimeZone, Utc}, - ethrpc::alloy::conversions::IntoLegacy, model::{ order::OrderCreationAppData, quote::{OrderQuote, OrderQuoteRequest, OrderQuoteResponse, OrderQuoteSide, PriceQuality}, @@ -129,11 +128,11 @@ impl QuoteHandler { .map_err(|err| OrderQuoteError::CalculateQuote(err.into()))?; let response = OrderQuoteResponse { quote: OrderQuote { - sell_token: request.sell_token.into_legacy(), - buy_token: request.buy_token.into_legacy(), - receiver: request.receiver.map(IntoLegacy::into_legacy), - sell_amount: adjusted_quote.sell_amount.into_legacy(), - buy_amount: adjusted_quote.buy_amount.into_legacy(), + sell_token: request.sell_token, + buy_token: request.buy_token, + receiver: request.receiver, + sell_amount: adjusted_quote.sell_amount, + buy_amount: adjusted_quote.buy_amount, valid_to, app_data: match &request.app_data { OrderCreationAppData::Full { full } => OrderCreationAppData::Both { @@ -142,14 +141,14 @@ impl QuoteHandler { }, app_data => app_data.clone(), }, - fee_amount: quote.fee_amount.into_legacy(), + fee_amount: quote.fee_amount, kind: quote.data.kind, partially_fillable: false, sell_token_balance: request.sell_token_balance, buy_token_balance: request.buy_token_balance, signing_scheme: request.signing_scheme.into(), }, - from: request.from.into_legacy(), + from: request.from, expiration: quote.data.expiration, id: quote.id, verified: quote.data.verified, @@ -256,6 +255,7 @@ mod tests { super::*, crate::arguments::FeeFactor, alloy::primitives::U256, + ethrpc::alloy::conversions::IntoLegacy, model::quote::OrderQuoteSide, shared::order_quoting::{Quote, QuoteData}, }; diff --git a/crates/solvers/src/util/math.rs b/crates/solvers/src/util/math.rs deleted file mode 100644 index 96018c1e5f..0000000000 --- a/crates/solvers/src/util/math.rs +++ /dev/null @@ -1,20 +0,0 @@ -use ethereum_types::U256; - -/// Perform a ceiled U256 integer division. -/// -/// Returns `None` when dividing by `0`. -pub fn div_ceil(q: U256, d: U256) -> Option { - if d.is_zero() { - return None; - } - - let (r, rem) = q.div_mod(d); - if rem.is_zero() { - Some(r) - } else { - Some( - r.checked_add(U256::one()) - .expect("unexpected ceiled division overflow"), - ) - } -} diff --git a/crates/solvers/src/util/mod.rs b/crates/solvers/src/util/mod.rs index ce85e8add0..051f909a2d 100644 --- a/crates/solvers/src/util/mod.rs +++ b/crates/solvers/src/util/mod.rs @@ -1,5 +1,4 @@ pub mod bytes; pub mod conv; pub mod fmt; -pub mod math; pub mod serialize;