get everything working e2e

parachain/pallets/control/src/lib.rs

@@ -67,8 +67,8 @@ use frame_support::{
 use frame_system::pallet_prelude::*;
 use snowbridge_core::{
 	outbound::{Command, Initializer, Message, OperatingMode, SendError, SendMessage},
-	sibling_sovereign_account, AgentId, Channel, ChannelId, ParaId, BRIDGE_HUB_AGENT_ID,
-	PRIMARY_GOVERNANCE_CHANNEL, SECONDARY_GOVERNANCE_CHANNEL,
+	sibling_sovereign_account, AgentId, Channel, ChannelId, ChannelLookup, ParaId,
+	BRIDGE_HUB_AGENT_ID, PRIMARY_GOVERNANCE_CHANNEL, SECONDARY_GOVERNANCE_CHANNEL,
 };
 
 #[cfg(feature = "runtime-benchmarks")]
@@ -564,4 +564,10 @@ pub mod pallet {
 			Ok(())
 		}
 	}
+
+	impl<T: Config> ChannelLookup for Pallet<T> {
+		fn lookup(channel_id: ChannelId) -> Option<Channel> {
+			Channels::<T>::get(channel_id)
+		}
+	}
 }

relayer/relays/execution/config.go

@@ -1,6 +1,10 @@
 package execution
 
 import (
+	"encoding/hex"
+	"errors"
+	"strings"
+
 	"github.com/snowfork/snowbridge/relayer/config"
 )
 
@@ -12,7 +16,7 @@ type Config struct {
 type SourceConfig struct {
 	Ethereum  config.EthereumConfig `mapstructure:"ethereum"`
 	Contracts ContractsConfig       `mapstructure:"contracts"`
-	ChannelID uint32                `mapstructure:"channel-id"`
+	ChannelID ChannelID             `mapstructure:"channel-id"`
 }
 
 type ContractsConfig struct {
@@ -22,3 +26,36 @@ type ContractsConfig struct {
 type SinkConfig struct {
 	Parachain config.ParachainConfig `mapstructure:"parachain"`
 }
+
+type ChannelID [32]byte
+
+func (m *ChannelID) UnmarshalJSON(bz []byte) error {
+	data, err := HexDecodeString(string(bz))
+	if err != nil {
+		return err
+	}
+	if len(data) != 32 {
+		return errors.New("Invalid Channel ID")
+	}
+
+	copy(m[:], data)
+
+	return nil
+}
+
+// HexDecodeString decodes bytes from a hex string. Contrary to hex.DecodeString, this function does not error if "0x"
+// is prefixed, and adds an extra 0 if the hex string has an odd length.
+func HexDecodeString(s string) ([]byte, error) {
+	s = strings.TrimPrefix(s, "0x")
+
+	if len(s)%2 != 0 {
+		s = "0" + s
+	}
+
+	b, err := hex.DecodeString(s)
+	if err != nil {
+		return nil, err
+	}
+
+	return b, nil
+}

relayer/relays/execution/main.go

@@ -138,7 +138,7 @@ func (r *Relay) Start(ctx context.Context, eg *errgroup.Group) error {
 					"blockHash":   ev.Raw.BlockHash.Hex(),
 					"blockNumber": ev.Raw.BlockNumber,
 					"txHash":      ev.Raw.TxHash.Hex(),
-					"dest":        ev.Destination,
+					"channelID":   types.H256(ev.ChannelID).Hex(),
 				})
 
 				if ev.Nonce <= paraNonce {
@@ -193,7 +193,7 @@ func (r *Relay) fetchEthereumNonce(ctx context.Context, blockNumber uint64) (uin
 		BlockNumber: new(big.Int).SetUint64(blockNumber),
 		Context:     ctx,
 	}
-	_, ethOutboundNonce, err := r.gatewayContract.ChannelNoncesOf(&opts, big.NewInt(int64(r.config.Source.ChannelID)))
+	_, ethOutboundNonce, err := r.gatewayContract.ChannelNoncesOf(&opts, r.config.Source.ChannelID)
 	if err != nil {
 		return 0, fmt.Errorf("fetch Gateway.ChannelNoncesOf(%v): %w", r.config.Source.ChannelID, err)
 	}
@@ -209,7 +209,7 @@ func (r *Relay) findEvents(
 	start uint64,
 ) ([]*contracts.GatewayOutboundMessageAccepted, error) {
 
-	paraID := r.config.Source.ChannelID
+	channelID := r.config.Source.ChannelID
 
 	var allEvents []*contracts.GatewayOutboundMessageAccepted
 
@@ -231,7 +231,7 @@ func (r *Relay) findEvents(
 			Context: ctx,
 		}
 
-		done, events, err := r.findEventsWithFilter(&opts, paraID, start)
+		done, events, err := r.findEventsWithFilter(&opts, channelID, start)
 		if err != nil {
 			return nil, fmt.Errorf("filter events: %w", err)
 		}
@@ -254,8 +254,8 @@ func (r *Relay) findEvents(
 	return allEvents, nil
 }
 
-func (r *Relay) findEventsWithFilter(opts *bind.FilterOpts, paraID uint32, start uint64) (bool, []*contracts.GatewayOutboundMessageAccepted, error) {
-	iter, err := r.gatewayContract.FilterOutboundMessageAccepted(opts, []*big.Int{big.NewInt(int64(paraID))}, [][32]byte{})
+func (r *Relay) findEventsWithFilter(opts *bind.FilterOpts, channelID [32]byte, start uint64) (bool, []*contracts.GatewayOutboundMessageAccepted, error) {
+	iter, err := r.gatewayContract.FilterOutboundMessageAccepted(opts, [][32]byte{channelID}, [][32]byte{})
 	if err != nil {
 		return false, nil, err
 	}

relayer/relays/parachain/config.go

@@ -1,6 +1,10 @@
 package parachain
 
 import (
+	"encoding/hex"
+	"errors"
+	"strings"
+
 	"github.com/snowfork/snowbridge/relayer/config"
 )
 
@@ -15,7 +19,7 @@ type SourceConfig struct {
 	Parachain config.ParachainConfig `mapstructure:"parachain"`
 	Ethereum  config.EthereumConfig  `mapstructure:"ethereum"`
 	Contracts SourceContractsConfig  `mapstructure:"contracts"`
-	ChannelID uint32                 `mapstructure:"channel-id"`
+	ChannelID ChannelID              `mapstructure:"channel-id"`
 }
 
 type SourceContractsConfig struct {
@@ -31,3 +35,36 @@ type SinkConfig struct {
 type SinkContractsConfig struct {
 	Gateway string `mapstructure:"Gateway"`
 }
+
+type ChannelID [32]byte
+
+func (m *ChannelID) UnmarshalJSON(bz []byte) error {
+	data, err := HexDecodeString(string(bz))
+	if err != nil {
+		return err
+	}
+	if len(data) != 32 {
+		return errors.New("Invalid Channel ID")
+	}
+
+	copy(m[:], data)
+
+	return nil
+}
+
+// HexDecodeString decodes bytes from a hex string. Contrary to hex.DecodeString, this function does not error if "0x"
+// is prefixed, and adds an extra 0 if the hex string has an odd length.
+func HexDecodeString(s string) ([]byte, error) {
+	s = strings.TrimPrefix(s, "0x")
+
+	if len(s)%2 != 0 {
+		s = "0" + s
+	}
+
+	b, err := hex.DecodeString(s)
+	if err != nil {
+		return nil, err
+	}
+
+	return b, nil
+}

relayer/relays/parachain/ethereum-writer.go

@@ -183,9 +183,9 @@ func (wr *EthereumWriter) WriteChannel(
 				return fmt.Errorf("unpack event log: %w", err)
 			}
 			log.WithFields(log.Fields{
-				"origin":  holder.Origin,
-				"nonce":   holder.Nonce,
-				"success": holder.Success,
+				"channelID": Hex(holder.ChannelID[:]),
+				"nonce":     holder.Nonce,
+				"success":   holder.Success,
 			}).Info("Message dispatched")
 		}
 	}

relayer/relays/parachain/logger.go

@@ -43,10 +43,10 @@ func (wr *EthereumWriter) logFieldsForSubmission(
 
 	params := log.Fields{
 		"message": log.Fields{
-			"origin":  message.Origin,
-			"nonce":   message.Nonce,
-			"command": message.Command,
-			"params":  Hex(message.Params),
+			"channelID": Hex(message.ChannelID[:]),
+			"nonce":     message.Nonce,
+			"command":   message.Command,
+			"params":    Hex(message.Params),
 		},
 		"messageProof": messageProofHexes,
 		"proof": log.Fields{

relayer/relays/parachain/scanner.go

@@ -2,9 +2,7 @@ package parachain
 
 import (
 	"context"
-	"encoding/binary"
 	"fmt"
-	"math/big"
 
 	"github.com/ethereum/go-ethereum/accounts/abi/bind"
 	"github.com/ethereum/go-ethereum/common"
@@ -84,7 +82,7 @@ func (s *Scanner) findTasks(
 		Pending: true,
 		Context: ctx,
 	}
-	ethInboundNonce, _, err := gatewayContract.ChannelNoncesOf(&options, big.NewInt(int64(s.config.ChannelID)))
+	ethInboundNonce, _, err := gatewayContract.ChannelNoncesOf(&options, s.config.ChannelID)
 	if err != nil {
 		return nil, fmt.Errorf("fetch nonce from gateway contract for channelID '%v': %w", s.config.ChannelID, err)
 	}
@@ -94,9 +92,8 @@ func (s *Scanner) findTasks(
 	}).Info("Checked latest nonce delivered to ethereum gateway")
 
 	// Fetch latest nonce in parachain outbound queue
-	sourceIDBytes := make([]byte, 4)
-	binary.LittleEndian.PutUint32(sourceIDBytes, s.config.ChannelID)
-	paraNonceKey, err := types.CreateStorageKey(s.paraConn.Metadata(), "EthereumOutboundQueue", "Nonce", sourceIDBytes, nil)
+
+	paraNonceKey, err := types.CreateStorageKey(s.paraConn.Metadata(), "EthereumOutboundQueue", "Nonce", s.config.ChannelID[:], nil)
 	if err != nil {
 		return nil, fmt.Errorf("create storage key for parachain outbound queue nonce with channelID '%v': %w", s.config.ChannelID, err)
 	}
@@ -126,7 +123,7 @@ func (s *Scanner) findTasks(
 	tasks, err := s.findTasksImpl(
 		ctx,
 		paraBlock,
-		s.config.ChannelID,
+		types.H256(s.config.ChannelID),
 		ethInboundNonce+1,
 	)
 	if err != nil {
@@ -143,7 +140,7 @@ func (s *Scanner) findTasks(
 func (s *Scanner) findTasksImpl(
 	_ context.Context,
 	lastParaBlockNumber uint64,
-	channelID uint32,
+	channelID types.H256,
 	startingNonce uint64,
 ) ([]*Task, error) {
 	log.WithFields(log.Fields{
@@ -331,7 +328,7 @@ func scanForOutboundQueueProofs(
 	blockHash types.Hash,
 	commitmentHash types.H256,
 	startingNonce uint64,
-	channelID uint32,
+	channelID types.H256,
 	messages []OutboundQueueMessage,
 ) (*struct {
 	proofs   []MessageProof
@@ -360,7 +357,7 @@ func scanForOutboundQueueProofs(
 	for i := len(messages) - 1; i >= 0; i-- {
 		message := messages[i]
 
-		if message.Origin != channelID {
+		if message.ChannelID != channelID {
 			continue
 		}
 
@@ -370,7 +367,7 @@ func scanForOutboundQueueProofs(
 		if messageNonce < startingNonce {
 			log.Debugf(
 				"Halting scan for channelID '%v'. Messages not committed yet on outbound channel",
-				message.Origin,
+				message.ChannelID.Hex(),
 			)
 			scanDone = true
 			break
@@ -384,7 +381,7 @@ func scanForOutboundQueueProofs(
 		if messageProof.Proof.Root != commitmentHash {
 			return nil, fmt.Errorf(
 				"Halting scan for channelID '%v'. Outbound queue proof root '%v' doesn't match digest item's commitment hash '%v'",
-				message.Origin,
+				message.ChannelID.Hex(),
 				messageProof.Proof.Root,
 				commitmentHash,
 			)

relayer/relays/parachain/types.go

@@ -1,8 +1,6 @@
 package parachain
 
 import (
-	"math/big"
-
 	"github.com/snowfork/go-substrate-rpc-client/v4/types"
 	"github.com/snowfork/snowbridge/relayer/chain/relaychain"
 	"github.com/snowfork/snowbridge/relayer/contracts"
@@ -83,7 +81,7 @@ func NewMerkleProof(rawProof RawMerkleProof) (MerkleProof, error) {
 }
 
 type OutboundQueueMessage struct {
-	Origin         uint32
+	ChannelID      types.H256
 	Nonce          uint64
 	Command        uint8
 	Params         []byte
@@ -95,7 +93,7 @@ type OutboundQueueMessage struct {
 
 func (m OutboundQueueMessage) IntoInboundMessage() contracts.InboundMessage {
 	return contracts.InboundMessage{
-		Origin:         big.NewInt(int64(m.Origin)),
+		ChannelID:      m.ChannelID,
 		Nonce:          m.Nonce,
 		Command:        m.Command,
 		Params:         m.Params,

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

@@ -36,7 +36,7 @@ bridgehub_ws_url="${BRIDGE_HUB_WS_URL:-ws://127.0.0.1:11144}"
 bridgehub_seed="${BRIDGE_HUB_SEED:-//Alice}"
 bridgehub_pallets_owner="${BRIDGE_HUB_PALLETS_OWNER:-0xd43593c715fdd31c61141abd04a99fd6822c8558854ccde39a5684e7a56da27d}"
 export BRIDGE_HUB_PARAID="${BRIDGE_HUB_PARAID:-1013}"
-export BRIDGE_HUB_AGENT_ID="${BRIDGE_HUB_AGENT_ID:-0x05f0ced792884ed09997292bd95f8d0d1094bb3bded91ec3f2f08531624037d6}"
+export BRIDGE_HUB_AGENT_ID="${BRIDGE_HUB_AGENT_ID:-0x0000000000000000000000000000000000000000000000000000000000000001}"
 
 assethub_ws_url="${ASSET_HUB_WS_URL:-ws://127.0.0.1:12144}"
 assethub_seed="${ASSET_HUB_SEED:-//Alice}"