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,
@@ -623,4 +626,30 @@ contract Gateway is IGateway, IInitializable {
         assets.assetHubCreateAssetFee = config.assetHubCreateAssetFee;
         assets.assetHubReserveTransferFee = config.assetHubReserveTransferFee;
     }
+
+    // Calculate cost for transact
+    function _calculateTransactCost(uint128 destinationFee) internal pure returns (Costs memory costs) {
+        return Costs({native: 0, foreign: destinationFee});
+    }
+
+    /// @inheritdoc IGateway
+    function sendCall(
+        ParaID destinationChain,
+        OriginKind originKind,
+        uint128 destinationFee,
+        Weight calldata weightAtMost,
+        bytes calldata call
+    ) external payable {
+        bytes memory payload =
+            SubstrateTypes.Transact(msg.sender, originKind.encode(), destinationFee, weightAtMost, call);
+        Costs memory costs = _calculateTransactCost(destinationFee);
+        Ticket memory ticket = Ticket({dest: destinationChain, costs: costs, payload: payload});
+        _submitOutbound(ticket);
+    }
+
+    /// @inheritdoc IGateway
+    function quoteSendCallFee(uint128 destinationFee) external view returns (uint256) {
+        Costs memory costs = _calculateTransactCost(destinationFee);
+        return _calculateFee(costs);
+    }
 }

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.encodeCompactU64(weight.refTime),
+            ScaleCodec.encodeCompactU64(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 <hello@snowfork.com>
 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 sendCall(
+        ParaID destinationChain,
+        OriginKind originKind,
+        uint128 destinationFee,
+        Weight calldata weightAtMost,
+        bytes calldata call
+    ) external payable;
+
+    /// @dev Quote a fee in Ether for transact
+    function quoteSendCallFee(uint128 destinationFee) external view returns (uint256);
 }

contracts/src/utils/Math.sol

@@ -114,4 +114,18 @@ library Math {
             return a - b;
         }
     }
+
+    /**
+     * @dev Return the count of leading zeros of the uint64 value
+     */
+    function leadingZeros(uint64 val) internal pure returns (uint8) {
+        unchecked {
+            uint8 num = 0;
+            while (val > 0) {
+                val = val >> 1;
+                num++;
+            }
+            return 64 - num;
+        }
+    }
 }

contracts/src/utils/ScaleCodec.sol

@@ -2,7 +2,11 @@
 // SPDX-FileCopyrightText: 2023 Snowfork <hello@snowfork.com>
 pragma solidity 0.8.23;
 
+import {Math} from "./Math.sol";
+
 library ScaleCodec {
+    using Math for uint64;
+
     error UnsupportedCompactEncoding();
 
     uint256 internal constant MAX_COMPACT_ENCODABLE_UINT = 2 ** 30 - 1;
@@ -126,4 +130,20 @@ library ScaleCodec {
         }
         return encodeCompactU32(uint32(value));
     }
+
+    // Supports compact encoding of integers in [0, uint64.MAX]
+    function encodeCompactU64(uint64 value) internal pure returns (bytes memory) {
+        if (value <= 2 ** 30 - 1) {
+            return encodeCompactU32(uint32(value));
+        } else {
+            uint8 countOfZeros = value.leadingZeros();
+            uint8 bytesNeeded = 8 - countOfZeros / 8;
+            bytes memory result = abi.encodePacked(3 + ((bytesNeeded - 4) << 2));
+            for (uint8 i = 0; i < bytesNeeded; i++) {
+                result = bytes.concat(result, abi.encodePacked(uint8(value)));
+                value >>= 8;
+            }
+            return result;
+        }
+    }
 }

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");
 
@@ -901,4 +914,45 @@ contract GatewayTest is Test {
         vm.expectRevert(Assets.InvalidDestinationFee.selector);
         IGateway(address(gateway)).sendToken{value: fee}(address(token), destPara, recipientAddress32, 0, 1);
     }
+
+    /**
+     * 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)).sendCall{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)).sendCall{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)).quoteSendCallFee(1);
+        assertEq(fee, 2500000000250000);
+        vm.expectEmit(true, false, false, true);
+        emit IGateway.OutboundMessageAccepted(penpalParaID.into(), 1, messageID, payload);
+        hoax(address(account1));
+        IGateway(address(gateway)).sendCall{value: fee}(
+            penpalParaID, OriginKind.SovereignAccount, 1, Weight(1, 1), bytes("0x1")
+        );
+    }
+
+    function testQuoteSendCallFee() public {
+        uint256 fee = IGateway(address(gateway)).quoteSendCallFee(1);
+        assertEq(fee, 2500000000250000);
+    }
 }

contracts/test/ScaleCodec.t.sol

@@ -47,4 +47,16 @@ contract ScaleCodecTest is Test {
         vm.expectRevert(ScaleCodec.UnsupportedCompactEncoding.selector);
         ScaleCodec.checkedEncodeCompactU32(uint256(type(uint32).max) + 1);
     }
+
+    function testEncodeCompactU64() public {
+        assertEq(ScaleCodec.encodeCompactU64(0), hex"00");
+        assertEq(ScaleCodec.encodeCompactU64(63), hex"fc");
+        assertEq(ScaleCodec.encodeCompactU64(64), hex"0101");
+        assertEq(ScaleCodec.encodeCompactU64(16383), hex"fdff");
+        assertEq(ScaleCodec.encodeCompactU64(16384), hex"02000100");
+        assertEq(ScaleCodec.encodeCompactU64(1073741823), hex"feffffff");
+        assertEq(ScaleCodec.encodeCompactU64(1073741824), hex"0300000040");
+        assertEq(ScaleCodec.encodeCompactU64(type(uint32).max), hex"03ffffffff");
+        assertEq(ScaleCodec.encodeCompactU64(type(uint64).max), hex"13ffffffffffffffff");
+    }
 }

contracts/test/mocks/GatewayUpgradeMock.sol

@@ -2,7 +2,17 @@
 // SPDX-FileCopyrightText: 2023 Snowfork <hello@snowfork.com>
 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 sendCall(
+        ParaID destinationChain,
+        OriginKind originKind,
+        uint128 destinationFee,
+        Weight calldata weightAtMost,
+        bytes calldata call
+    ) external payable {}
+
+    function quoteSendCallFee(uint128) external pure returns (uint256) {
+        return 1;
+    }
 }

relayer/cmd/generate_beacon_data.go

@@ -41,6 +41,7 @@ func generateBeaconDataCmd() *cobra.Command {
 	cmd.Flags().Bool("wait_until_next_period", true, "Waiting until next period")
 	cmd.Flags().Uint32("nonce", 1, "Nonce of the inbound message")
 	cmd.Flags().String("test_case", "register_token", "Inbound test case")
+	cmd.Flags().String("execution_relay_config", "/tmp/snowbridge/execution-relay-asset-hub.json", "Config file for execution relayer")
 	return cmd
 }
 
@@ -161,7 +162,12 @@ func generateBeaconTestFixture(cmd *cobra.Command, _ []string) error {
 		log.WithFields(log.Fields{"endpoint": endpoint}).Info("connecting to beacon API")
 		s := syncer.New(endpoint, conf.Source.Beacon.Spec)
 
-		viper.SetConfigFile("/tmp/snowbridge/execution-relay-asset-hub.json")
+		executionRelayConfig, err := cmd.Flags().GetString("execution_relay_config")
+		if err != nil {
+			return err
+		}
+
+		viper.SetConfigFile(executionRelayConfig)
 
 		if err = viper.ReadInConfig(); err != nil {
 			return err
@@ -380,7 +386,7 @@ func generateBeaconTestFixture(cmd *cobra.Command, _ []string) error {
 		if err != nil {
 			return err
 		}
-		if testCase != "register_token" && testCase != "send_token" {
+		if testCase != "register_token" && testCase != "send_token" && testCase != "send_call_to_penpal" && testCase != "send_call_to_penpal" {
 			return fmt.Errorf("invalid test case: %s", testCase)
 		}
 		pathToInboundQueueFixtureTemplate := fmt.Sprintf(pathToInboundQueueFixtureTemplate, testCase)