Transact from eth to sub

contracts/src/Gateway.sol

@@ -17,7 +17,9 @@ import {
     Command,
     MultiAddress,
     Ticket,
-    Costs
+    Costs,
+    OriginKind,
+    Weight
 } from "./Types.sol";
 import {IGateway} from "./interfaces/IGateway.sol";
 import {IInitializable} from "./interfaces/IInitializable.sol";
@@ -27,6 +29,7 @@ import {SafeNativeTransfer} from "./utils/SafeTransfer.sol";
 import {Call} from "./utils/Call.sol";
 import {Math} from "./utils/Math.sol";
 import {ScaleCodec} from "./utils/ScaleCodec.sol";
+import {SubstrateTypes} from "./SubstrateTypes.sol";
 
 import {
     UpgradeParams,
@@ -86,6 +89,7 @@ contract Gateway is IGateway, IInitializable {
     error InvalidAgentExecutionPayload();
     error InvalidCodeHash();
     error InvalidConstructorParams();
+    error InvalidTransact();
 
     // handler functions are privileged
     modifier onlySelf() {
@@ -617,4 +621,31 @@ contract Gateway is IGateway, IInitializable {
         assets.assetHubCreateAssetFee = config.assetHubCreateAssetFee;
         assets.assetHubReserveTransferFee = config.assetHubReserveTransferFee;
     }
+
+    /// @inheritdoc IGateway
+    function transact(
+        ParaID destinationChain,
+        OriginKind originKind,
+        uint128 destinationFee,
+        Weight calldata weightAtMost,
+        bytes calldata call
+    ) external payable {
+        if (call.length < 2 || destinationFee == 0 || weightAtMost.refTime == 0 || weightAtMost.proofSize == 0) {
+            revert InvalidTransact();
+        }
+        Ticket memory ticket;
+        Costs memory costs;
+        bytes memory payload =
+            SubstrateTypes.Transact(msg.sender, originKind.encode(), destinationFee, weightAtMost, call);
+        ticket.dest = destinationChain;
+        ticket.costs = costs;
+        ticket.payload = payload;
+        _submitOutbound(ticket);
+    }
+
+    /// @inheritdoc IGateway
+    function quoteTransactFee() external view returns (uint256) {
+        PricingStorage.Layout storage pricing = PricingStorage.layout();
+        return _convertToNative(pricing.exchangeRate, pricing.deliveryCost);
+    }
 }

contracts/src/SubstrateTypes.sol

@@ -3,7 +3,7 @@
 pragma solidity 0.8.23;
 
 import {ScaleCodec} from "./utils/ScaleCodec.sol";
-import {ParaID} from "./Types.sol";
+import {ParaID, Weight, OriginKind} from "./Types.sol";
 
 /**
  * @title SCALE encoders for common Substrate types
@@ -133,4 +133,24 @@ library SubstrateTypes {
             ScaleCodec.encodeU128(xcmFee)
         );
     }
+
+    // Arbitrary transact
+    function Transact(address sender, bytes1 originKind, uint128 fee, Weight memory weight, bytes memory call)
+        internal
+        view
+        returns (bytes memory)
+    {
+        return bytes.concat(
+            bytes1(0x00),
+            ScaleCodec.encodeU64(uint64(block.chainid)),
+            bytes1(0x02),
+            SubstrateTypes.H160(sender),
+            originKind,
+            ScaleCodec.encodeU128(fee),
+            ScaleCodec.encodeU64(weight.refTime),
+            ScaleCodec.encodeU64(weight.proofSize),
+            ScaleCodec.checkedEncodeCompactU32(call.length),
+            call
+        );
+    }
 }

contracts/src/Types.sol

@@ -109,3 +109,25 @@ struct TokenInfo {
     bool isRegistered;
     bytes31 __padding;
 }
+
+struct Weight {
+    uint64 refTime;
+    uint64 proofSize;
+}
+
+/// @dev OriginKind from https://github.com/Snowfork/polkadot-sdk/blob/348a1a010481002e41594ed75e5d78b7c2dbed92/polkadot/xcm/src/v2/mod.rs#L86
+enum OriginKind {
+    SovereignAccount,
+    Xcm
+}
+
+using {encode} for OriginKind global;
+
+function encode(OriginKind kind) pure returns (bytes1 result) {
+    if (kind == OriginKind.SovereignAccount) {
+        result = 0x01;
+    } else if (kind == OriginKind.Xcm) {
+        result = 0x03;
+    }
+    return result;
+}

contracts/src/interfaces/IGateway.sol

@@ -2,7 +2,7 @@
 // SPDX-FileCopyrightText: 2023 Snowfork <[email protected]>
 pragma solidity 0.8.23;
 
-import {OperatingMode, InboundMessage, ParaID, ChannelID, MultiAddress} from "../Types.sol";
+import {OperatingMode, InboundMessage, ParaID, ChannelID, MultiAddress, OriginKind, Weight} from "../Types.sol";
 import {Verification} from "../Verification.sol";
 import {UD60x18} from "prb/math/src/UD60x18.sol";
 
@@ -105,4 +105,16 @@ interface IGateway {
         uint128 destinationFee,
         uint128 amount
     ) external payable;
+
+    /// @dev Call transact in destinationChain
+    function transact(
+        ParaID destinationChain,
+        OriginKind originKind,
+        uint128 destinationFee,
+        Weight calldata weightAtMost,
+        bytes calldata call
+    ) external payable;
+
+    /// @dev Quote a fee in Ether for transact
+    function quoteTransactFee() external view returns (uint256);
 }

contracts/test/Gateway.t.sol

@@ -42,22 +42,27 @@ import {
     ParaID,
     Command,
     multiAddressFromBytes32,
-    multiAddressFromBytes20
+    multiAddressFromBytes20,
+    Weight,
+    OriginKind
 } from "../src/Types.sol";
 
 import {WETH9} from "canonical-weth/WETH9.sol";
 import "./mocks/GatewayUpgradeMock.sol";
 import {UD60x18, ud60x18, convert} from "prb/math/src/UD60x18.sol";
 
 contract GatewayTest is Test {
-    ParaID public bridgeHubParaID = ParaID.wrap(1001);
-    bytes32 public bridgeHubAgentID = keccak256("1001");
+    ParaID public bridgeHubParaID = ParaID.wrap(1013);
+    bytes32 public bridgeHubAgentID = keccak256("1013");
     address public bridgeHubAgent;
 
-    ParaID public assetHubParaID = ParaID.wrap(1002);
-    bytes32 public assetHubAgentID = keccak256("1002");
+    ParaID public assetHubParaID = ParaID.wrap(1000);
+    bytes32 public assetHubAgentID = keccak256("1000");
     address public assetHubAgent;
 
+    ParaID public penpalParaID = ParaID.wrap(2000);
+    bytes32 public penpalAgentID = keccak256("2000");
+
     address public relayer;
 
     bytes32[] public proof = [bytes32(0x2f9ee6cfdf244060dc28aa46347c5219e303fc95062dd672b4e406ca5c29764b)];
@@ -114,6 +119,14 @@ contract GatewayTest is Test {
         bridgeHubAgent = IGateway(address(gateway)).agentOf(bridgeHubAgentID);
         assetHubAgent = IGateway(address(gateway)).agentOf(assetHubAgentID);
 
+        // Initialize agent/channel for Penpal
+        GatewayMock(address(gateway)).createAgentPublic(abi.encode(CreateAgentParams({agentID: penpalAgentID})));
+        GatewayMock(address(gateway)).createChannelPublic(
+            abi.encode(
+                CreateChannelParams({channelID: penpalParaID.into(), agentID: penpalAgentID, mode: OperatingMode.Normal})
+            )
+        );
+
         // fund the message relayer account
         relayer = makeAddr("relayer");
 
@@ -825,4 +838,40 @@ contract GatewayTest is Test {
         fee = IGateway(address(gateway)).quoteRegisterTokenFee();
         assertEq(fee, 10000000000000000);
     }
+
+    /**
+     * Transact
+     */
+    function testTransactFromXcmOrigin() public {
+        bytes memory payload = SubstrateTypes.Transact(account1, 0x03, 1, Weight(1, 1), bytes("0x1"));
+        console.logBytes(payload);
+        vm.expectEmit(true, false, false, true);
+        emit IGateway.OutboundMessageAccepted(penpalParaID.into(), 1, messageID, payload);
+        hoax(address(account1));
+        IGateway(address(gateway)).transact{value: 1 ether}(penpalParaID, OriginKind.Xcm, 1, Weight(1, 1), bytes("0x1"));
+    }
+
+    function testTransactFromSovereignAccount() public {
+        bytes memory payload = SubstrateTypes.Transact(account1, 0x01, 1, Weight(1, 1), bytes("0x1"));
+        console.logBytes(payload);
+        vm.expectEmit(true, false, false, true);
+        emit IGateway.OutboundMessageAccepted(penpalParaID.into(), 1, messageID, payload);
+        hoax(address(account1));
+        IGateway(address(gateway)).transact{value: 1 ether}(
+            penpalParaID, OriginKind.SovereignAccount, 1, Weight(1, 1), bytes("0x1")
+        );
+    }
+
+    function testTransactFromSovereignAccountWithFee() public {
+        bytes memory payload = SubstrateTypes.Transact(account1, 0x01, 1, Weight(1, 1), bytes("0x1"));
+        console.logBytes(payload);
+        uint256 fee = IGateway(address(gateway)).quoteTransactFee();
+        assertEq(fee, 2500000000000000);
+        vm.expectEmit(true, false, false, true);
+        emit IGateway.OutboundMessageAccepted(penpalParaID.into(), 1, messageID, payload);
+        hoax(address(account1));
+        IGateway(address(gateway)).transact{value: fee}(
+            penpalParaID, OriginKind.SovereignAccount, 1, Weight(1, 1), bytes("0x1")
+        );
+    }
 }

contracts/test/mocks/GatewayUpgradeMock.sol

@@ -2,7 +2,17 @@
 // SPDX-FileCopyrightText: 2023 Snowfork <[email protected]>
 pragma solidity 0.8.23;
 
-import {Channel, InboundMessage, OperatingMode, ParaID, Command, ChannelID, MultiAddress} from "../../src/Types.sol";
+import {
+    Channel,
+    InboundMessage,
+    OperatingMode,
+    ParaID,
+    Command,
+    ChannelID,
+    MultiAddress,
+    OriginKind,
+    Weight
+} from "../../src/Types.sol";
 import {IGateway} from "../../src/interfaces/IGateway.sol";
 import {IInitializable} from "../../src/interfaces/IInitializable.sol";
 import {Verification} from "../../src/Verification.sol";
@@ -61,4 +71,16 @@ contract GatewayUpgradeMock is IGateway, IInitializable {
     function pricingParameters() external pure returns (UD60x18, uint128) {
         return (convert(0), uint128(0));
     }
+
+    function transact(
+        ParaID destinationChain,
+        OriginKind originKind,
+        uint128 destinationFee,
+        Weight calldata weightAtMost,
+        bytes calldata call
+    ) external payable {}
+
+    function quoteTransactFee() external pure returns (uint256) {
+        return 1;
+    }
 }

smoketest/tests/transact_from_eth_to_penpal.rs

@@ -0,0 +1,74 @@
+use ethers::{core::types::Address, prelude::U256, types::Bytes};
+use futures::StreamExt;
+use hex_literal::hex;
+use snowbridge_smoketest::{
+	constants::*,
+	contracts::{gateway_upgrade_mock::TransactMessage, i_gateway, shared_types::Weight},
+	helper::{initial_clients, print_event_log_for_unit_tests},
+	parachains::penpal::api::system::events::Remarked,
+};
+
+#[tokio::test]
+async fn transact_from_eth_to_penpal() {
+	let test_clients = initial_clients().await.expect("initialize clients");
+	let ethereum_client = *(test_clients.ethereum_signed_client.clone());
+	let penpal_client = *(test_clients.penpal_client.clone());
+
+	let gateway_addr: Address = GATEWAY_PROXY_CONTRACT.into();
+	let gateway = i_gateway::IGateway::new(gateway_addr, ethereum_client.clone());
+
+	let message = TransactMessage {
+		origin_kind: 0,
+		fee: 40_000_000_000,
+		weight_at_most: Weight { ref_time: 40_000_000, proof_size: 8_000 },
+		//system.remark
+		call: Bytes::from(hex!("00071468656c6c6f").to_vec()),
+	};
+
+	let receipt = gateway
+		.transact(PENPAL_PARA_ID, message)
+		.value::<U256>(100_000_000_000_000_000_u128.into())
+		.send()
+		.await
+		.unwrap()
+		.await
+		.unwrap()
+		.unwrap();
+
+	println!(
+		"receipt transaction hash: {:#?}, transaction block: {:#?}",
+		hex::encode(receipt.transaction_hash),
+		receipt.block_number
+	);
+
+	// Log for OutboundMessageAccepted
+	let outbound_message_accepted_log = receipt.logs.last().unwrap();
+
+	// print log for unit tests
+	print_event_log_for_unit_tests(outbound_message_accepted_log);
+
+	assert_eq!(receipt.status.unwrap().as_u64(), 1u64);
+
+	let wait_for_blocks = 50;
+	let mut blocks = penpal_client
+		.blocks()
+		.subscribe_finalized()
+		.await
+		.expect("block subscription")
+		.take(wait_for_blocks);
+
+	let mut event_found = false;
+	while let Some(Ok(block)) = blocks.next().await {
+		println!("Polling penpal block {} for system remark event.", block.number());
+
+		let events = block.events().await.unwrap();
+		for _ in events.find::<Remarked>() {
+			println!("Remarked event found in penpal block {}.", block.number());
+			event_found = true;
+		}
+		if event_found {
+			break
+		}
+	}
+	assert!(event_found)
+}

web/packages/test/scripts/configure-penpal.sh

@@ -0,0 +1,20 @@
+#!/usr/bin/env bash
+set -eu
+
+source scripts/set-env.sh
+source scripts/xcm-helper.sh
+
+fund_bridgehub_sovereign() {
+    local call="0x0a08007369626cf5030000000000000000000000000000000000000000000000000000070010a5d4e8"
+    send_governance_transact_from_relaychain $PENPAL_PARAID "$call"
+}
+
+configure_penpal() {
+    fund_bridgehub_sovereign
+}
+
+if [ -z "${from_start_services:-}" ]; then
+    echo "config penpal only!"
+    configure_penpal
+    wait
+fi

web/packages/test/scripts/set-env.sh

@@ -44,11 +44,11 @@ assethub_ws_url="${ASSET_HUB_WS_URL:-ws://127.0.0.1:12144}"
 assethub_seed="${ASSET_HUB_SEED:-//Alice}"
 export ASSET_HUB_PARAID="${ASSET_HUB_PARAID:-1000}"
 export ASSET_HUB_AGENT_ID="${ASSET_HUB_AGENT_ID:-0x81c5ab2571199e3188135178f3c2c8e2d268be1313d029b30f534fa579b69b79}"
-
 export ASSET_HUB_CHANNEL_ID="0xc173fac324158e77fb5840738a1a541f633cbec8884c6a601c567d2b376a0539"
 export PENPAL_CHANNEL_ID="0xa69fbbae90bb6096d59b1930bbcfc8a3ef23959d226b1861deb7ad8fb06c6fa3"
 export PRIMARY_GOVERNANCE_CHANNEL_ID="0x0000000000000000000000000000000000000000000000000000000000000001"
 export SECONDARY_GOVERNANCE_CHANNEL_ID="0x0000000000000000000000000000000000000000000000000000000000000002"
+export PENPAL_PARAID="${PENPAL_PARAID:-2000}"
 
 # Token decimal of the relaychain(KSM|ROC:12,DOT:10)
 export FOREIGN_TOKEN_DECIMALS=12
@@ -62,6 +62,8 @@ reset_ethereum="${RESET_ETHEREUM:-true}"
 ## Important accounts
 
 # Useful tool to get these account values: https://www.shawntabrizi.com/substrate-js-utilities/
+# Account for bridgehub (Sibling parachain 1013 in testnet)
+bridgehub_sovereign_account="${BRIDGEHUB_SOVEREIGN_ACCOUNT:-0x7369626cf5030000000000000000000000000000000000000000000000000000}"
 # Account for assethub (Sibling parachain 1000 5Eg2fntNprdN3FgH4sfEaaZhYtddZQSQUqvYJ1f2mLtinVhV in testnet)
 assethub_sovereign_account="${ASSETHUB_SOVEREIGN_ACCOUNT:-0x7369626ce8030000000000000000000000000000000000000000000000000000}"
 # Account for penpal (Sibling parachain 2000 5Eg2fntJ27qsari4FGrGhrMqKFDRnkNSR6UshkZYBGXmSuC8 in testnet)