Add command to update registerTokenFee and sendTokenFee

contracts/src/Gateway.sol

@@ -173,6 +173,11 @@ contract Gateway is IGateway, IInitializable {
             catch {
                 success = false;
             }
+        } else if (message.command == Command.SetTokenTransferFees) {
+            try Gateway(this).setTokenTransferFees{gas: maxDispatchGas}(message.params) {}
+            catch {
+                success = false;
+            }
         }
 
         // Calculate the actual cost of executing this message
@@ -230,6 +235,11 @@ contract Gateway is IGateway, IInitializable {
         return ERC1967.load();
     }
 
+    function tokenTransferFees() external view returns (uint256, uint256) {
+        AssetsStorage.Layout storage $ = AssetsStorage.layout();
+        return ($.registerTokenFee, $.sendTokenFee);
+    }
+
     /**
      * Handlers
      */
@@ -411,6 +421,22 @@ contract Gateway is IGateway, IInitializable {
         emit AgentFundsWithdrawn(params.agentID, params.recipient, params.amount);
     }
 
+    struct SetTokenTransferFeesParams {
+        /// @dev The fee for register token
+        uint256 register;
+        /// @dev The fee for send token from ethereum to polkadot
+        uint256 send;
+    }
+
+    // @dev Set the operating mode of the gateway
+    function setTokenTransferFees(bytes calldata data) external onlySelf {
+        AssetsStorage.Layout storage $ = AssetsStorage.layout();
+        SetTokenTransferFeesParams memory params = abi.decode(data, (SetTokenTransferFeesParams));
+        $.registerTokenFee = params.register;
+        $.sendTokenFee = params.send;
+        emit TokenTransferFeesChanged(params.register, params.send);
+    }
+
     /**
      * Assets
      */

contracts/src/Types.sol

@@ -72,7 +72,8 @@ enum Command {
     CreateChannel,
     UpdateChannel,
     SetOperatingMode,
-    TransferNativeFromAgent
+    TransferNativeFromAgent,
+    SetTokenTransferFees
 }
 
 enum AgentExecuteCommand {TransferToken}

contracts/src/interfaces/IGateway.sol

@@ -34,6 +34,8 @@ interface IGateway {
     // Emitted when funds are withdrawn from an agent
     event AgentFundsWithdrawn(bytes32 indexed agentID, address indexed recipient, uint256 amount);
 
+    // Emitted when the fees updated
+    event TokenTransferFeesChanged(uint256 register, uint256 send);
     /// @dev Emitted once the funds are locked and a message is successfully queued.
     event TokenSent(
         address indexed token, address indexed sender, ParaID destinationChain, bytes destinationAddress, uint128 amount
@@ -65,6 +67,7 @@ interface IGateway {
     /**
      * Token Transfers
      */
+    function tokenTransferFees() external view returns (uint256, uint256);
 
     /// @dev Send a message to the AssetHub parachain to register a new fungible asset
     ///      in the `ForeignAssets` pallet.

contracts/test/Gateway.t.sol

@@ -749,4 +749,16 @@ contract GatewayTest is Test {
             InboundMessage(bridgeHubParaID, 1, command, params, 1, maxRefund, reward), proof, makeMockProof()
         );
     }
+
+    function testSetTokenFees() public {
+        (uint256 register, uint256 send) = IGateway(address(gateway)).tokenTransferFees();
+        assertEq(register, 1 ether);
+        assertEq(send, 1 ether);
+        GatewayMock(address(gateway)).setTokenTransferFeesPublic(
+            abi.encode(Gateway.SetTokenTransferFeesParams({register: 1, send: 1}))
+        );
+        (register, send) = IGateway(address(gateway)).tokenTransferFees();
+        assertEq(register, 1);
+        assertEq(send, 1);
+    }
 }

contracts/test/mocks/GatewayMock.sol

@@ -63,6 +63,10 @@ contract GatewayMock is Gateway {
             return commitmentsAreVerified;
         }
     }
+
+    function setTokenTransferFeesPublic(bytes calldata params) external {
+        this.setTokenTransferFees(params);
+    }
 }
 
 library AdditionalStorage {

contracts/test/mocks/GatewayUpgradeMock.sol

@@ -32,6 +32,10 @@ contract GatewayUpgradeMock is IGateway, IInitializable {
         return address(0);
     }
 
+    function tokenTransferFees() external pure returns (uint256, uint256) {
+        return (1, 1);
+    }
+
     function implementation() external pure returns (address) {
         return address(0);
     }

parachain/pallets/control/src/lib.rs

@@ -176,6 +176,8 @@ pub mod pallet {
 		SetOperatingMode { mode: OperatingMode },
 		/// An TransferNativeFromAgent message was sent to the Gateway
 		TransferNativeFromAgent { agent_id: AgentId, recipient: H160, amount: u128 },
+		/// A SetTokenTransferFees message was sent to the Gateway
+		SetTokenTransferFees { register: u128, send: u128 },
 	}
 
 	#[pallet::error]
@@ -188,6 +190,7 @@ pub mod pallet {
 		UnsupportedLocationVersion,
 		InvalidLocation,
 		Send(SendError),
+		InvalidTokenTransferFees,
 	}
 
 	/// The set of registered agents
@@ -424,6 +427,33 @@ pub mod pallet {
 
 			Self::do_transfer_native_from_agent(agent_id, para_id, recipient, amount, pays_fee)
 		}
+
+		/// Sends a message to the Gateway contract to set token transfer fees
+		///
+		/// Privileged. Can only be called by root.
+		///
+		/// Fee required: No
+		///
+		/// - `origin`: Must be root
+		/// - `register`: The fee for register token
+		/// - `send`: The fee for send token to parachain
+		#[pallet::call_index(8)]
+		#[pallet::weight(T::WeightInfo::set_token_transfer_fees())]
+		pub fn set_token_transfer_fees(
+			origin: OriginFor<T>,
+			register: u128,
+			send: u128,
+		) -> DispatchResult {
+			ensure_root(origin)?;
+
+			ensure!(register > 0 && send > 0, Error::<T>::InvalidTokenTransferFees);
+
+			let command = Command::SetTokenTransferFees { register, send };
+			Self::send(T::OwnParaId::get(), command, PaysFee::<T>::No)?;
+
+			Self::deposit_event(Event::<T>::SetTokenTransferFees { register, send });
+			Ok(())
+		}
 	}
 
 	impl<T: Config> Pallet<T> {

parachain/pallets/control/src/weights.rs

@@ -40,6 +40,7 @@ pub trait WeightInfo {
 	fn set_operating_mode() -> Weight;
 	fn transfer_native_from_agent() -> Weight;
 	fn force_transfer_native_from_agent() -> Weight;
+	fn set_token_transfer_fees() -> Weight;
 }
 
 // For backwards compatibility and tests.
@@ -204,4 +205,24 @@ impl WeightInfo for () {
 			.saturating_add(RocksDbWeight::get().reads(5_u64))
 			.saturating_add(RocksDbWeight::get().writes(3_u64))
 	}
+
+	/// Storage: ParachainInfo ParachainId (r:1 w:0)
+	/// Proof: ParachainInfo ParachainId (max_values: Some(1), max_size: Some(4), added: 499, mode: MaxEncodedLen)
+	/// Storage: EthereumOutboundQueue PalletOperatingMode (r:1 w:0)
+	/// Proof: EthereumOutboundQueue PalletOperatingMode (max_values: Some(1), max_size: Some(1), added: 496, mode: MaxEncodedLen)
+	/// Storage: MessageQueue BookStateFor (r:1 w:1)
+	/// Proof: MessageQueue BookStateFor (max_values: None, max_size: Some(52), added: 2527, mode: MaxEncodedLen)
+	/// Storage: MessageQueue ServiceHead (r:1 w:1)
+	/// Proof: MessageQueue ServiceHead (max_values: Some(1), max_size: Some(5), added: 500, mode: MaxEncodedLen)
+	/// Storage: MessageQueue Pages (r:0 w:1)
+	/// Proof: MessageQueue Pages (max_values: None, max_size: Some(65585), added: 68060, mode: MaxEncodedLen)
+	fn set_token_transfer_fees() -> Weight {
+		// Proof Size summary in bytes:
+		//  Measured:  `80`
+		//  Estimated: `3517`
+		// Minimum execution time: 31_000_000 picoseconds.
+		Weight::from_parts(42_000_000, 3517)
+			.saturating_add(RocksDbWeight::get().reads(4_u64))
+			.saturating_add(RocksDbWeight::get().writes(3_u64))
+	}
 }

parachain/primitives/core/src/outbound.rs

@@ -111,6 +111,13 @@ mod v1 {
 			/// The amount to transfer
 			amount: u128,
 		},
+		/// Set token fees of the Gateway contract
+		SetTokenTransferFees {
+			/// The fee for register token
+			register: u128,
+			/// The fee for send token to para chain
+			send: u128,
+		},
 	}
 
 	impl Command {
@@ -124,6 +131,7 @@ mod v1 {
 				Command::UpdateChannel { .. } => 4,
 				Command::SetOperatingMode { .. } => 5,
 				Command::TransferNativeFromAgent { .. } => 6,
+				Command::SetTokenTransferFees { .. } => 7,
 			}
 		}
 
@@ -170,6 +178,11 @@ mod v1 {
 						Token::Address(*recipient),
 						Token::Uint(U256::from(*amount)),
 					])]),
+				Command::SetTokenTransferFees { register, send } =>
+					ethabi::encode(&[Token::Tuple(vec![
+						Token::Uint(U256::from(*register)),
+						Token::Uint(U256::from(*send)),
+					])]),
 			}
 		}
 	}
@@ -335,6 +348,7 @@ impl GasMeter for ConstantGasMeter {
 				// the the initializer is called.
 				50_000 + initializer_max_gas
 			},
+			Command::SetTokenTransferFees { .. } => 60_000,
 		}
 	}
 }

smoketest/src/helper.rs

@@ -301,10 +301,7 @@ pub async fn governance_bridgehub_call_from_relay_chain(
 	}));
 	let message = Box::new(RelaychainVersionedXcm::V3(RelaychainXcm(vec![
 		RelaychainInstruction::UnpaidExecution {
-			weight_limit: RelaychainWeightLimit::Limited(RelaychainWeight {
-				ref_time: weight,
-				proof_size,
-			}),
+			weight_limit: RelaychainWeightLimit::Unlimited,
 			check_origin: None,
 		},
 		RelaychainInstruction::Transact {

smoketest/tests/set_token_transfer_fees.rs

@@ -0,0 +1,39 @@
+use ethers::prelude::Address;
+use snowbridge_smoketest::{
+	constants::*,
+	contracts::{i_gateway, i_gateway::SetTokenTransferFeesFilter},
+	helper::*,
+	parachains::bridgehub::api::{
+		ethereum_control::events::SetTokenTransferFees,
+		runtime_types::{self, bridge_hub_rococo_runtime::RuntimeCall as BHRuntimeCall},
+	},
+};
+
+#[tokio::test]
+async fn set_token_transfer_fees() {
+	let test_clients = initial_clients().await.expect("initialize clients");
+
+	let gateway_addr: Address = GATEWAY_PROXY_CONTRACT.into();
+	let ethereum_client = *(test_clients.ethereum_client.clone());
+	let gateway = i_gateway::IGateway::new(gateway_addr, ethereum_client.clone());
+	let fees = gateway.token_transfer_fees().await.expect("get fees");
+	println!("asset fees {:?}", fees);
+
+	let set_token_fees_call = BHRuntimeCall::EthereumControl(
+		runtime_types::snowbridge_control::pallet::Call::set_token_transfer_fees {
+			register: 10_000_000_000_000,
+			send: 20_000_000_000,
+		},
+	);
+
+	governance_bridgehub_call_from_relay_chain(vec![set_token_fees_call])
+		.await
+		.expect("set token fees");
+
+	wait_for_bridgehub_event::<SetTokenTransferFees>(&test_clients.bridge_hub_client).await;
+
+	wait_for_ethereum_event::<SetTokenTransferFeesFilter>(&test_clients.ethereum_client).await;
+
+	let fees = gateway.token_transfer_fees().await.expect("get fees");
+	println!("asset fees {:?}", fees);
+}

smoketest/tests/transfer_token.rs

@@ -60,31 +60,28 @@ async fn transfer_token() {
 	let signer: PairSigner<AssetHubConfig, _> = PairSigner::new(keypair);
 
 	let amount: u128 = 1_000_000_000;
-	let assets = VersionedMultiAssets::V3(MultiAssets(vec![
-		MultiAsset {
-			id: AssetId::Concrete(MultiLocation {
-				parents: 2,
-				interior: Junctions::X2(
-					Junction::GlobalConsensus(NetworkId::Ethereum { chain_id: 15 }),
-					Junction::AccountKey20 { network: None, key: WETH_CONTRACT.into() },
-				),
-			}),
-			fun: Fungibility::Fungible(amount),
-		},
-	]));
+	let assets = VersionedMultiAssets::V3(MultiAssets(vec![MultiAsset {
+		id: AssetId::Concrete(MultiLocation {
+			parents: 2,
+			interior: Junctions::X2(
+				Junction::GlobalConsensus(NetworkId::Ethereum { chain_id: 15 }),
+				Junction::AccountKey20 { network: None, key: WETH_CONTRACT.into() },
+			),
+		}),
+		fun: Fungibility::Fungible(amount),
+	}]));
 
 	let destination = VersionedMultiLocation::V3(MultiLocation {
 		parents: 2,
-		interior: Junctions::X1(
-			Junction::GlobalConsensus(NetworkId::Ethereum { chain_id: 15 }),
-		),
+		interior: Junctions::X1(Junction::GlobalConsensus(NetworkId::Ethereum { chain_id: 15 })),
 	});
 
 	let beneficiary = VersionedMultiLocation::V3(MultiLocation {
 		parents: 0,
-		interior: Junctions::X1(
-			Junction::AccountKey20 { network: None, key: DESTINATION_ADDRESS.into() },
-		),
+		interior: Junctions::X1(Junction::AccountKey20 {
+			network: None,
+			key: DESTINATION_ADDRESS.into(),
+		}),
 	});
 
 	let token_transfer_call =