Merge branch 'development' into amar-bound-read-events-v0

analog-gmp/test/utils/GmpProxy.sol

@@ -31,13 +31,9 @@ contract GmpProxy is IGmpReceiver {
         NETWORK_ID = GATEWAY.networkId();
     }
 
-    function sendMessage(GmpMessage calldata message) external payable {
+    function sendMessage(GmpMessage calldata message) external payable returns (bytes32) {
         uint256 value = address(this).balance.min(msg.value);
-        GATEWAY.submitMessage{value: value}(message.dest, message.destNetwork, message.gasLimit, message.data);
-    }
-
-    function estimateMessageCost(uint256 messageSize, uint256 gasLimit) external view returns (uint256) {
-        return GATEWAY.estimateMessageCost(NETWORK_ID, messageSize, gasLimit);
+        return GATEWAY.submitMessage{value: value}(message.dest, message.destNetwork, message.gasLimit, message.data);
     }
 
     function onGmpReceived(bytes32 id, uint128, bytes32, bytes calldata payload) external payable returns (bytes32) {

gmp/evm/src/lib.rs

@@ -691,17 +691,14 @@ impl IConnectorAdmin for Connector {
 		Ok(())
 	}
 	/// Estimates the message cost.
-	async fn estimate_message_cost(
-		&self,
-		gateway: Address,
-		dest: NetworkId,
-		msg_size: usize,
-		gas_limit: u128,
-	) -> Result<u128> {
-		let msg_size = U256::from_str_radix(&msg_size.to_string(), 16).unwrap();
+	async fn estimate_message_cost(&self, gateway: Address, msg: &GmpMessage) -> Result<u128> {
+		let dest = msg.dest_network;
+		let gas_limit = msg.gas_limit;
+		let msg: sol::GmpMessage = msg.clone().into();
+		let bytes = msg.abi_encode();
 		let call = sol::Gateway::estimateMessageCostCall {
 			networkid: dest,
-			messageSize: msg_size,
+			messageSize: U256::from(bytes.len()),
 			gasLimit: U256::from(gas_limit),
 		};
 		let result = self.evm_view(gateway, call, None).await?;
@@ -714,28 +711,14 @@ impl IConnectorAdmin for Connector {
 			.await
 	}
 	/// Sends a message using the test contract.
-	async fn send_message(&self, contract: Address, msg: GmpMessage) -> Result<MessageId> {
-		// EVM specific logic
-		let mut modified_msg = msg.clone();
-		modified_msg.gas_limit = 300_000;
-		let sol_msg: sol::GmpMessage = modified_msg.clone().into();
-		modified_msg.bytes = sol_msg.abi_encode();
-
-		let cost_call = sol::GmpTester::estimateMessageCostCall {
-			messageSize: U256::from(modified_msg.bytes.len()),
-			gasLimit: U256::from(modified_msg.gas_limit),
-		};
-
-		let msg_cost = self.evm_view(contract, cost_call, None).await?;
-		let msg_cost = u128::try_from(msg_cost._0)?;
-
-		let call = sol::GmpTester::sendMessageCall {
-			msg: modified_msg.clone().into(),
-		};
-
-		self.evm_call(contract, call, msg_cost, None, None).await?;
-		let msg_id = modified_msg.message_id();
-		Ok(msg_id)
+	async fn send_message(&self, msg: GmpMessage) -> Result<MessageId> {
+		anyhow::ensure!(msg.src_network == self.network_id, "invalid source network id");
+		let src = msg.src;
+		let gas_cost = msg.gas_cost;
+		let call = sol::GmpTester::sendMessageCall { msg: msg.into() };
+		let result = self.evm_call(src, call, gas_cost, None, None).await?;
+		let id: MessageId = *result.0._0;
+		Ok(id)
 	}
 	/// Receives messages from test contract.
 	async fn recv_messages(

gmp/evm/src/sol.rs

@@ -171,7 +171,7 @@ alloy_sol_types::sol! {
 
 	contract GmpTester {
 		constructor(address gateway);
-		function sendMessage(GmpMessage msg) payable;
+		function sendMessage(GmpMessage msg) payable returns (bytes32);
 		function estimateMessageCost(uint256 messageSize, uint256 gasLimit) external view returns (uint256);
 		event MessageReceived(GmpMessage msg);
 	}

gmp/grpc/src/lib.rs

@@ -256,25 +256,14 @@ impl IConnectorAdmin for Connector {
 		Ok((response.address, response.block))
 	}
 	/// Estimates the message cost.
-	async fn estimate_message_cost(
-		&self,
-		gateway: Address,
-		dest: NetworkId,
-		msg_size: usize,
-		gas_limit: u128,
-	) -> Result<u128> {
-		let request = Request::new(proto::EstimateMessageCostRequest {
-			gateway,
-			dest,
-			msg_size,
-			gas_limit,
-		});
+	async fn estimate_message_cost(&self, gateway: Address, msg: &GmpMessage) -> Result<u128> {
+		let request = Request::new(proto::EstimateMessageCostRequest { gateway, msg: msg.clone() });
 		let response = self.client.lock().await.estimate_message_cost(request).await?.into_inner();
 		Ok(response.cost)
 	}
 	/// Sends a message using the test contract.
-	async fn send_message(&self, contract: Address, msg: GmpMessage) -> Result<MessageId> {
-		let request = Request::new(proto::SendMessageRequest { contract, msg });
+	async fn send_message(&self, msg: GmpMessage) -> Result<MessageId> {
+		let request = Request::new(proto::SendMessageRequest { msg });
 		let response = self.client.lock().await.send_message(request).await?.into_inner();
 		Ok(response.message_id)
 	}

gmp/grpc/src/main.rs

@@ -249,7 +249,7 @@ impl Gmp for ConnectorWrapper {
 	) -> GmpResult<proto::EstimateMessageCostResponse> {
 		let (connector, msg) = self.connector(request)?;
 		let cost = connector
-			.estimate_message_cost(msg.gateway, msg.dest, msg.msg_size, msg.gas_limit)
+			.estimate_message_cost(msg.gateway, &msg.msg)
 			.await
 			.map_err(|err| Status::unknown(err.to_string()))?;
 		Ok(Response::new(proto::EstimateMessageCostResponse { cost }))
@@ -261,7 +261,7 @@ impl Gmp for ConnectorWrapper {
 	) -> GmpResult<proto::SendMessageResponse> {
 		let (connector, msg) = self.connector(request)?;
 		let message_id = connector
-			.send_message(msg.contract, msg.msg)
+			.send_message(msg.msg)
 			.await
 			.map_err(|err| Status::unknown(err.to_string()))?;
 		Ok(Response::new(proto::SendMessageResponse { message_id }))

gmp/grpc/src/proto.rs

@@ -1,7 +1,7 @@
 use serde::{Deserialize, Serialize};
 use serde_big_array::Array;
 use time_primitives::{
-	Address, BatchId, Gateway, GatewayMessage, GmpEvent, GmpMessage, MessageId, NetworkId, Route,
+	Address, BatchId, Gateway, GatewayMessage, GmpEvent, GmpMessage, MessageId, Route,
 	TssPublicKey, TssSignature,
 };
 
@@ -164,10 +164,8 @@ pub struct DeployTestResponse {
 
 #[derive(Serialize, Deserialize)]
 pub struct EstimateMessageCostRequest {
-	pub gateway: Gateway,
-	pub dest: NetworkId,
-	pub msg_size: usize,
-	pub gas_limit: u128,
+	pub gateway: Address,
+	pub msg: GmpMessage,
 }
 
 #[derive(Serialize, Deserialize)]
@@ -177,7 +175,6 @@ pub struct EstimateMessageCostResponse {
 
 #[derive(Serialize, Deserialize)]
 pub struct SendMessageRequest {
-	pub contract: Address,
 	pub msg: GmpMessage,
 }
 

gmp/rust/src/lib.rs

@@ -449,27 +449,23 @@ impl IConnectorAdmin for Connector {
 		Ok((tester, block))
 	}
 
-	async fn estimate_message_cost(
-		&self,
-		_gateway: Address,
-		_dest: NetworkId,
-		msg_size: usize,
-		_gas_limit: u128,
-	) -> Result<u128> {
-		Ok(msg_size as u128 * 100)
+	async fn estimate_message_cost(&self, _gateway: Address, msg: &GmpMessage) -> Result<u128> {
+		Ok(msg.bytes.len() as u128 * 100)
 	}
 
-	async fn send_message(&self, addr: Address, mut msg: GmpMessage) -> Result<MessageId> {
+	async fn send_message(&self, mut msg: GmpMessage) -> Result<MessageId> {
 		anyhow::ensure!(msg.src_network == self.network_id, "invalid source network id");
+		let addr = msg.src;
 		let tx = self.db.begin_write()?;
 		let id = {
 			// read nonce
 			let mut t = tx.open_table(NONCE)?;
 			let nonce = t.get((msg.src, addr))?.map(|a| a.value()).unwrap_or_default();
-			// increment nonce
-			t.insert((msg.src, addr), nonce + 1)?;
+			// set nonce
 			msg.nonce = nonce;
 			let id = msg.message_id();
+			// increment nonce
+			t.insert((msg.src, addr), nonce + 1)?;
 
 			// read gateway address
 			let t = tx.open_table(GATEWAY)?;
@@ -479,7 +475,6 @@ impl IConnectorAdmin for Connector {
 			let mut t = tx.open_multimap_table(EVENTS)?;
 			let block = block(self.genesis);
 			t.insert((gateway, block), GmpEvent::MessageReceived(msg))?;
-
 			id
 		};
 		tx.commit()?;
@@ -620,8 +615,9 @@ mod tests {
 		assert_eq!(events, vec![GmpEvent::ShardRegistered(shard.public_key())]);
 		let (src, _) = chain.deploy_test(gateway, "".as_ref()).await?;
 		let (dest, _) = chain.deploy_test(gateway, "".as_ref()).await?;
-		let msg = gmp_msg(src, dest);
-		chain.send_message(src, msg.clone()).await?;
+		let mut msg = gmp_msg(src, dest);
+		msg.gas_cost = chain.estimate_message_cost(gateway, &msg).await?;
+		chain.send_message(msg.clone()).await?;
 		let current2 = chain.block_stream().next().await.unwrap();
 		let events = chain.read_events(gateway, current..current2).await?;
 		assert_eq!(events, vec![GmpEvent::MessageReceived(msg.clone())]);

primitives/src/gmp.rs

@@ -413,15 +413,9 @@ pub trait IConnectorAdmin: IConnector {
 	/// Deploys a test contract.
 	async fn deploy_test(&self, gateway: Address, tester: &[u8]) -> Result<(Address, u64)>;
 	/// Estimates the message cost.
-	async fn estimate_message_cost(
-		&self,
-		gateway: Address,
-		dest: NetworkId,
-		msg_size: usize,
-		gas_limit: u128,
-	) -> Result<u128>;
-	/// Sends a message using the test contract.
-	async fn send_message(&self, contract: Address, msg: GmpMessage) -> Result<MessageId>;
+	async fn estimate_message_cost(&self, gateway: Address, msg: &GmpMessage) -> Result<u128>;
+	/// Sends a message using the test contract and returns the message id.
+	async fn send_message(&self, msg: GmpMessage) -> Result<MessageId>;
 	/// Receives messages from test contract.
 	async fn recv_messages(&self, contract: Address, blocks: Range<u64>)
 		-> Result<Vec<GmpMessage>>;

tc-cli/src/lib.rs

@@ -933,26 +933,40 @@ impl Tc {
 		connector.deploy_test(gateway, &contracts.tester).await
 	}
 
-	pub async fn send_message(
-		&self,
-		network: NetworkId,
-		tester: Address,
-		dest: NetworkId,
-		dest_addr: Address,
-		nonce: u64,
-	) -> Result<MessageId> {
-		let msg = GmpMessage {
-			src_network: network,
-			src: tester,
-			dest_network: dest,
-			dest: dest_addr,
-			nonce,
-			gas_limit: 100,
-			gas_cost: 200,
-			bytes: vec![],
-		};
-		let connector = self.connector(network)?;
-		connector.send_message(tester, msg.clone()).await
+	pub async fn estimate_message_cost(&self, msg: &GmpMessage) -> Result<u128> {
+		let (connector, gateway) = self.gateway(msg.src_network).await?;
+		connector.estimate_message_cost(gateway, msg).await
+	}
+
+	pub async fn send_message(&self, msg: GmpMessage) -> Result<MessageId> {
+		let connector = self.connector(msg.src_network)?;
+		let dest_network = msg.dest_network;
+		let dest = msg.dest;
+		let gas_cost = msg.gas_cost;
+		let id = self
+			.println(
+				None,
+				format!(
+					"send message to {} {} @{}gas",
+					dest_network,
+					self.format_address(Some(dest_network), dest)?,
+					gas_cost,
+				),
+			)
+			.await?;
+		let msg_id = connector.send_message(msg).await?;
+		self.println(
+			Some(id),
+			format!(
+				"sent message {} to {} {} @{}gas",
+				hex::encode(msg_id),
+				dest_network,
+				self.format_address(Some(dest_network), dest)?,
+				gas_cost,
+			),
+		)
+		.await?;
+		Ok(msg_id)
 	}
 
 	pub async fn remove_task(&self, task_id: TaskId) -> Result<()> {