add Converge testnet (#4394)

- add Converge to guardiand

- add Converge network to sdk

- add env from Converge testnent deployment

- add converge testnet to js sdk

```
-- Wormhole Core Addresses --------------------------------------------------
| Setup address                | 0xCbA13Df0270Af08478c88B2799B00DB43D50071C |
| Implementation address       | 0xF549bEB2A1eaB781899d46003f36F6652B5B8eb4 |
| Wormhole address             | 0x556B259cFaCd9896B2773310080c7c3bcE90Ff01 |
-----------------------------------------------------------------------------

Verifying test converge...
   Verifying EVM chain ID for test converge ✓
   Verifying finality values for test converge ✓
   Verifying contract address for test converge ✓
```

deploy with proper init signer

ethereum/env/.env.converge.testnet

@@ -0,0 +1,23 @@
+# forge 0.2.0 (ea2eff95b 2025-05-13T23:24:36.177577925Z)
+
+RPC_URL=https://rpc-converge-testnet-1.t.conduit.xyz
+FORGE_ARGS="--skip-simulation"
+
+INIT_SIGNERS=["0x13947Bd48b18E53fdAeEe77F3473391aC727C638"]
+INIT_GOV_CHAIN_ID=0x1
+INIT_GOV_CONTRACT=0x0000000000000000000000000000000000000000000000000000000000000004
+INIT_CHAIN_ID=53
+INIT_EVM_CHAIN_ID=52085145
+
+###                                 ###
+###  Bridge Contracts Not Deployed  ###
+###                                 ###
+
+# Bridge Migrations
+# BRIDGE_INIT_CHAIN_ID=53
+# BRIDGE_INIT_GOV_CHAIN_ID=0x1
+# BRIDGE_INIT_GOV_CONTRACT=0x0000000000000000000000000000000000000000000000000000000000000004
+
+# There is no WETH
+# BRIDGE_INIT_WETH=0x0000000000000000000000000000000000000000
+# BRIDGE_INIT_FINALITY=1

node/cmd/guardiand/adminnodes.go

@@ -136,6 +136,7 @@ func runListNodes(cmd *cobra.Command, args []string) {
 		{"Wormchain", vaa.ChainIDWormchain},
 		{"Mezo", vaa.ChainIDMezo},
 		{"Fogo", vaa.ChainIDFogo},
+		{"Converge", vaa.ChainIDConverge},
 		// The IBC chains (4000 range) are not included here.
 		{"Sepolia", vaa.ChainIDSepolia},
 		{"ArbitrumSepolia", vaa.ChainIDArbitrumSepolia},

node/cmd/guardiand/node.go

@@ -224,6 +224,9 @@ var (
 	mezoRPC      *string
 	mezoContract *string
 
+	convergeRPC      *string
+	convergeContract *string
+
 	sepoliaRPC      *string
 	sepoliaContract *string
 
@@ -477,6 +480,9 @@ func init() {
 	mezoRPC = node.RegisterFlagWithValidationOrFail(NodeCmd, "mezoRPC", "Mezo RPC URL", "ws://eth-devnet:8545", []string{"ws", "wss"})
 	mezoContract = NodeCmd.Flags().String("mezoContract", "", "Mezo contract address")
 
+	convergeRPC = node.RegisterFlagWithValidationOrFail(NodeCmd, "convergeRPC", "converge RPC_URL", "ws://eth-devnet:8545", []string{"ws", "wss"})
+	convergeContract = NodeCmd.Flags().String("convergeContract", "", "Converge contract address")
+
 	arbitrumSepoliaRPC = node.RegisterFlagWithValidationOrFail(NodeCmd, "arbitrumSepoliaRPC", "Arbitrum on Sepolia RPC URL", "ws://eth-devnet:8545", []string{"ws", "wss"})
 	arbitrumSepoliaContract = NodeCmd.Flags().String("arbitrumSepoliaContract", "", "Arbitrum on Sepolia contract address")
 
@@ -875,6 +881,7 @@ func runNode(cmd *cobra.Command, args []string) {
 	*monadContract = checkEvmArgs(logger, *monadRPC, *monadContract, vaa.ChainIDMonad)
 	*seiEvmContract = checkEvmArgs(logger, *seiEvmRPC, *seiEvmContract, vaa.ChainIDSeiEVM)
 	*mezoContract = checkEvmArgs(logger, *mezoRPC, *mezoContract, vaa.ChainIDMezo)
+	*convergeContract = checkEvmArgs(logger, *convergeRPC, *convergeContract, vaa.ChainIDConverge)
 
 	// These chains will only ever be testnet / devnet.
 	*sepoliaContract = checkEvmArgs(logger, *sepoliaRPC, *sepoliaContract, vaa.ChainIDSepolia)
@@ -1064,6 +1071,7 @@ func runNode(cmd *cobra.Command, args []string) {
 	rpcMap["monadRPC"] = *monadRPC
 	rpcMap["movementRPC"] = *movementRPC
 	rpcMap["mezoRPC"] = *mezoRPC
+	rpcMap["convergeRPC"] = *convergeRPC
 
 	// Wormchain is in the 3000 range.
 	rpcMap["wormchainURL"] = *wormchainURL
@@ -1252,7 +1260,7 @@ func runNode(cmd *cobra.Command, args []string) {
 		})
 	}
 
-	var watcherConfigs = []watchers.WatcherConfig{}
+	watcherConfigs := []watchers.WatcherConfig{}
 
 	if shouldStart(ethRPC) {
 		wc := &evm.WatcherConfig{
@@ -1619,6 +1627,17 @@ func runNode(cmd *cobra.Command, args []string) {
 		watcherConfigs = append(watcherConfigs, wc)
 	}
 
+	if shouldStart(convergeRPC) {
+		wc := &evm.WatcherConfig{
+			NetworkID:        "converge",
+			ChainID:          vaa.ChainIDConverge,
+			Rpc:              *convergeRPC,
+			Contract:         *convergeContract,
+			CcqBackfillCache: *ccqBackfillCache,
+		}
+		watcherConfigs = append(watcherConfigs, wc)
+	}
+
 	if shouldStart(terraWS) {
 		wc := &cosmwasm.WatcherConfig{
 			NetworkID: "terra",

node/pkg/query/query.go

@@ -144,6 +144,7 @@ var perChainConfig = map[vaa.ChainID]PerChainConfig{
 	vaa.ChainIDMonad:           {NumWorkers: 1, TimestampCacheSupported: true},
 	vaa.ChainIDSeiEVM:          {NumWorkers: 1, TimestampCacheSupported: true},
 	vaa.ChainIDMezo:            {NumWorkers: 1, TimestampCacheSupported: true},
+	vaa.ChainIDConverge:        {NumWorkers: 1, TimestampCacheSupported: true},
 	vaa.ChainIDFogo:            {NumWorkers: 10, TimestampCacheSupported: true},
 }
 

node/pkg/watchers/evm/chain_config.go

@@ -100,6 +100,7 @@ var (
 		vaa.ChainIDHyperEVM:   {Finalized: true, Safe: true, EvmChainID: 999, PublicRPC: "https://rpc.hyperliquid.xyz/evm", ContractAddr: "0x7C0faFc4384551f063e05aee704ab943b8B53aB3"},
 		// vaa.ChainIDMonad:      Not in Mainnet yet.
 		vaa.ChainIDMezo: {Finalized: true, Safe: true, EvmChainID: 31612, PublicRPC: "https://jsonrpc-mezo.boar.network/", ContractAddr: "0xaBf89de706B583424328B54dD05a8fC986750Da8"},
+		// vaa.ChainIDConverge: Not in Mainnet yet
 	}
 
 	// testnetChainConfig specifies the configuration for all chains enabled in Testnet.
@@ -151,6 +152,7 @@ var (
 		vaa.ChainIDHyperEVM:        {Finalized: true, Safe: true, EvmChainID: 998, PublicRPC: "https://rpc.hyperliquid-testnet.xyz/evm", ContractAddr: "0xBB73cB66C26740F31d1FabDC6b7A46a038A300dd"},
 		vaa.ChainIDMonad:           {Finalized: true, Safe: true, EvmChainID: 10143, PublicRPC: "https://testnet-rpc.monad.xyz", ContractAddr: "0xBB73cB66C26740F31d1FabDC6b7A46a038A300dd"},
 		vaa.ChainIDMezo:            {Finalized: true, Safe: true, EvmChainID: 31611, PublicRPC: "https://rpc.test.mezo.org", ContractAddr: "0x268557122Ffd64c85750d630b716471118F323c8"},
+		vaa.ChainIDConverge:        {Finalized: true, Safe: true, EvmChainID: 52085145, PublicRPC: "https://rpc-converge-testnet-1.t.conduit.xyz", ContractAddr: "0x556B259cFaCd9896B2773310080c7c3bcE90Ff01"},
 		vaa.ChainIDSepolia:         {Finalized: true, Safe: true, EvmChainID: 11155111, PublicRPC: "https://ethereum-sepolia-rpc.publicnode.com", ContractAddr: "0x4a8bc80Ed5a4067f1CCf107057b8270E0cC11A78"},
 		vaa.ChainIDArbitrumSepolia: {Finalized: true, Safe: true, EvmChainID: 421614, PublicRPC: "https://arbitrum-sepolia-rpc.publicnode.com", ContractAddr: "0x6b9C8671cdDC8dEab9c719bB87cBd3e782bA6a35"},
 		vaa.ChainIDBaseSepolia:     {Finalized: true, Safe: true, EvmChainID: 84532, PublicRPC: "https://base-sepolia-rpc.publicnode.com", ContractAddr: "0x79A1027a6A159502049F10906D333EC57E95F083"},

sdk/vaa/structs.go

@@ -243,6 +243,8 @@ func (c ChainID) String() string {
 		return "fogo"
 	case ChainIDSonic:
 		return "sonic"
+	case ChainIDConverge:
+		return "converge"
 	case ChainIDWormchain:
 		return "wormchain"
 	case ChainIDCosmoshub:
@@ -296,7 +298,6 @@ func ChainIDFromNumber[N number](n N) (ChainID, error) {
 	case int8, uint8, int16, uint16:
 		// Because these values have been checked to be non-negative, we can return early with a simple conversion.
 		return ChainID(n), nil
-
 	}
 	// Use intermediate uint64 to safely handle conversion and allow comparison with MaxUint16.
 	// This is safe to do because the negative case is already handled.
@@ -305,7 +306,6 @@ func ChainIDFromNumber[N number](n N) (ChainID, error) {
 		return ChainIDUnset, fmt.Errorf("chainID must be less than or equal to %d but got %d", math.MaxUint16, n)
 	}
 	return ChainID(n), nil
-
 }
 
 // KnownChainIDFromNumber converts an unsigned integer into a known ChainID. It is a wrapper function for ChainIDFromNumber
@@ -324,14 +324,12 @@ func KnownChainIDFromNumber[N number](n N) (ChainID, error) {
 	}
 
 	return ChainIDUnset, fmt.Errorf("no known ChainID for input %d", n)
-
 }
 
 // StringToKnownChainID converts from a string representation of a chain into a ChainID that is registered in the SDK.
 // The argument can be either a numeric string representation of a number or a known chain name such as "solana".
 // Inputs of unknown ChainIDs, including 0, will result in an error.
 func StringToKnownChainID(s string) (ChainID, error) {
-
 	// Try to convert from chain name first, and return early if it's found.
 	id, err := ChainIDFromString(s)
 	if err == nil {
@@ -453,6 +451,8 @@ func ChainIDFromString(s string) (ChainID, error) {
 		return ChainIDFogo, nil
 	case "sonic":
 		return ChainIDSonic, nil
+	case "converge":
+		return ChainIDConverge, nil
 	case "wormchain":
 		return ChainIDWormchain, nil
 	case "cosmoshub":
@@ -621,7 +621,7 @@ const (
 	// NOTE: 27 belongs to a chain that was never deployed.
 	// ChainIDXpla is the ChainID of Xpla
 	ChainIDXpla ChainID = 28
-	//ChainIDBtc is the ChainID of Bitcoin
+	// ChainIDBtc is the ChainID of Bitcoin
 	ChainIDBtc ChainID = 29
 	// ChainIDBase is the ChainID of Base
 	ChainIDBase ChainID = 30
@@ -669,9 +669,10 @@ const (
 	ChainIDFogo ChainID = 51
 	// ChainIDSonic is the ChainID of Sonic
 	ChainIDSonic ChainID = 52
-	//ChainIDWormchain is the ChainID of Wormchain
+	// ChainIDConverge is the ChainID of Converge
+	ChainIDConverge ChainID = 53
 
-	// Wormchain is in it's own range.
+	// ChainIDWormchain is the ChainID of Wormchain and is in its own range.
 	ChainIDWormchain ChainID = 3104
 
 	// The IBC chains start at 4000.
@@ -695,9 +696,9 @@ const (
 	ChainIDProvenance ChainID = 4008
 	// ChainIDNoble is the ChainID of Noble
 	ChainIDNoble ChainID = 4009
-	// ChainIDSepolia is the ChainID of Sepolia
 
 	// The Testnet only chains start at 10000.
+	// ChainIDSepolia is the ChainID of Sepolia
 	ChainIDSepolia ChainID = 10002
 	// ChainIDArbitrumSepolia is the ChainID of Arbitrum on Sepolia
 	ChainIDArbitrumSepolia ChainID = 10003
@@ -894,7 +895,6 @@ func verifySignature(vaa_digest []byte, signature *Signature, address common.Add
 // Should not be public as other message types should be verified using a message prefix.
 // Returns false when the signatures or addresses are empty.
 func verifySignatures(vaa_digest []byte, signatures []*Signature, addresses []common.Address) bool {
-
 	// An empty set is neither valid nor invalid, it's just specified incorrectly.
 	// To help with backward-compatibility, return false instead of changing the function
 	// signature to return an error.

sdk/vaa/structs_test.go

@@ -80,6 +80,7 @@ func TestChainIDFromString(t *testing.T) {
 		{input: "mezo", output: ChainIDMezo},
 		{input: "fogo", output: ChainIDFogo},
 		{input: "sonic", output: ChainIDSonic},
+		{input: "converge", output: ChainIDConverge},
 		{input: "wormchain", output: ChainIDWormchain},
 		{input: "cosmoshub", output: ChainIDCosmoshub},
 		{input: "evmos", output: ChainIDEvmos},
@@ -148,6 +149,7 @@ func TestChainIDFromString(t *testing.T) {
 		{input: "Mezo", output: ChainIDMezo},
 		{input: "Fogo", output: ChainIDFogo},
 		{input: "Sonic", output: ChainIDSonic},
+		{input: "Converge", output: ChainIDConverge},
 		{input: "Wormchain", output: ChainIDWormchain},
 		{input: "Cosmoshub", output: ChainIDCosmoshub},
 		{input: "Evmos", output: ChainIDEvmos},
@@ -358,6 +360,7 @@ func TestChainId_String(t *testing.T) {
 		{input: 50, output: "mezo"},
 		{input: 51, output: "fogo"},
 		{input: 52, output: "sonic"},
+		{input: 53, output: "converge"},
 		{input: 3104, output: "wormchain"},
 		{input: 4000, output: "cosmoshub"},
 		{input: 4001, output: "evmos"},
@@ -386,8 +389,8 @@ func TestChainId_String(t *testing.T) {
 }
 
 func getVaa() VAA {
-	var payload = []byte{97, 97, 97, 97, 97, 97}
-	var governanceEmitter = Address{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4}
+	payload := []byte{97, 97, 97, 97, 97, 97}
+	governanceEmitter := Address{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4}
 
 	return VAA{
 		Version:          uint8(1),
@@ -404,8 +407,8 @@ func getVaa() VAA {
 }
 
 func getEmptyPayloadVaa() VAA {
-	var payload = []byte{}
-	var governanceEmitter = Address{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4}
+	payload := []byte{}
+	governanceEmitter := Address{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4}
 
 	return VAA{
 		Version:          uint8(1),
@@ -553,85 +556,117 @@ func TestVerifySignatures(t *testing.T) {
 	}
 
 	tests := []test{
-		{label: "NoSignerZero",
+		{
+			label:      "NoSignerZero",
 			keyOrder:   []*ecdsa.PrivateKey{},
 			addrs:      addrs,
 			indexOrder: []uint8{0},
-			result:     false},
-		{label: "NoSignerOne",
+			result:     false,
+		},
+		{
+			label:      "NoSignerOne",
 			keyOrder:   []*ecdsa.PrivateKey{},
 			addrs:      addrs,
 			indexOrder: []uint8{1},
-			result:     false},
-		{label: "SingleZero",
+			result:     false,
+		},
+		{
+			label:      "SingleZero",
 			keyOrder:   []*ecdsa.PrivateKey{privKey1},
 			addrs:      addrs,
 			indexOrder: []uint8{0},
-			result:     true},
-		{label: "RogueSingleOne",
+			result:     true,
+		},
+		{
+			label:      "RogueSingleOne",
 			keyOrder:   []*ecdsa.PrivateKey{privKey4},
 			addrs:      addrs,
 			indexOrder: []uint8{0},
-			result:     false},
-		{label: "RogueSingleZero",
+			result:     false,
+		},
+		{
+			label:      "RogueSingleZero",
 			keyOrder:   []*ecdsa.PrivateKey{privKey4},
 			addrs:      addrs,
 			indexOrder: []uint8{0},
-			result:     false},
-		{label: "SingleOne",
+			result:     false,
+		},
+		{
+			label:      "SingleOne",
 			keyOrder:   []*ecdsa.PrivateKey{privKey1},
 			addrs:      addrs,
 			indexOrder: []uint8{0},
-			result:     true},
-		{label: "MultiUniqSignerMonotonicIndex",
+			result:     true,
+		},
+		{
+			label:      "MultiUniqSignerMonotonicIndex",
 			keyOrder:   []*ecdsa.PrivateKey{privKey1, privKey2, privKey3},
 			addrs:      addrs,
 			indexOrder: []uint8{0, 1, 2},
-			result:     true},
-		{label: "MultiMisOrderedSignerMonotonicIndex",
+			result:     true,
+		},
+		{
+			label:      "MultiMisOrderedSignerMonotonicIndex",
 			keyOrder:   []*ecdsa.PrivateKey{privKey3, privKey2, privKey1},
 			addrs:      addrs,
-			indexOrder: []uint8{0, 1, 2}, result: false},
-		{label: "MultiUniqSignerNonMonotonic",
+			indexOrder: []uint8{0, 1, 2}, result: false,
+		},
+		{
+			label:      "MultiUniqSignerNonMonotonic",
 			keyOrder:   []*ecdsa.PrivateKey{privKey1, privKey2, privKey3},
 			addrs:      addrs,
 			indexOrder: []uint8{0, 2, 1},
-			result:     false},
-		{label: "MultiUniqSignerFullSameIndex0",
+			result:     false,
+		},
+		{
+			label:      "MultiUniqSignerFullSameIndex0",
 			keyOrder:   []*ecdsa.PrivateKey{privKey1, privKey2, privKey3},
 			addrs:      addrs,
 			indexOrder: []uint8{0, 0, 0},
-			result:     false},
-		{label: "MultiUniqSignerFullSameIndex1",
+			result:     false,
+		},
+		{
+			label:      "MultiUniqSignerFullSameIndex1",
 			keyOrder:   []*ecdsa.PrivateKey{privKey1, privKey2, privKey3},
 			addrs:      addrs,
 			indexOrder: []uint8{0, 0, 0},
-			result:     false},
-		{label: "MultiUniqSignerPartialSameIndex",
+			result:     false,
+		},
+		{
+			label:      "MultiUniqSignerPartialSameIndex",
 			keyOrder:   []*ecdsa.PrivateKey{privKey1, privKey2, privKey3},
 			addrs:      addrs,
 			indexOrder: []uint8{0, 1, 1},
-			result:     false},
-		{label: "MultiSameSignerPartialSameIndex",
+			result:     false,
+		},
+		{
+			label:      "MultiSameSignerPartialSameIndex",
 			keyOrder:   []*ecdsa.PrivateKey{privKey1, privKey2, privKey2},
 			addrs:      addrs,
 			indexOrder: []uint8{0, 1, 1},
-			result:     false},
-		{label: "MultiSameSignerNonMonotonic",
+			result:     false,
+		},
+		{
+			label:      "MultiSameSignerNonMonotonic",
 			keyOrder:   []*ecdsa.PrivateKey{privKey1, privKey2, privKey2},
 			addrs:      addrs,
 			indexOrder: []uint8{0, 2, 1},
-			result:     false},
-		{label: "MultiSameSignerFullSameIndex",
+			result:     false,
+		},
+		{
+			label:      "MultiSameSignerFullSameIndex",
 			keyOrder:   []*ecdsa.PrivateKey{privKey1, privKey1, privKey1},
 			addrs:      addrs,
 			indexOrder: []uint8{0, 0, 0},
-			result:     false},
-		{label: "MultiSameSignerMonotonic",
+			result:     false,
+		},
+		{
+			label:      "MultiSameSignerMonotonic",
 			keyOrder:   []*ecdsa.PrivateKey{privKey1, privKey1, privKey1},
 			addrs:      addrs,
 			indexOrder: []uint8{0, 1, 2},
-			result:     false},
+			result:     false,
+		},
 	}
 
 	for _, tc := range tests {
@@ -807,7 +842,6 @@ func TestVerifySignaturesFuzz(t *testing.T) {
 }
 
 func TestStringToAddress(t *testing.T) {
-
 	type Test struct {
 		label     string
 		rawAddr   string
@@ -816,29 +850,43 @@ func TestStringToAddress(t *testing.T) {
 	}
 
 	tests := []Test{
-		{label: "simple",
+		{
+			label:     "simple",
 			rawAddr:   "0000000000000000000000000000000000000000000000000000000000000004",
 			addr:      Address{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
-			errString: ""},
-		{label: "zero-padding",
+			errString: "",
+		},
+		{
+			label:     "zero-padding",
 			rawAddr:   "04",
 			addr:      Address{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
-			errString: ""},
-		{label: "trim-0x", rawAddr: "0x04",
+			errString: "",
+		},
+		{
+			label: "trim-0x", rawAddr: "0x04",
 			addr:      Address{0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4},
-			errString: ""},
-		{label: "20byte eth-style address", rawAddr: "0x0290FB167208Af455bB137780163b7B7a9a10C16",
+			errString: "",
+		},
+		{
+			label: "20byte eth-style address", rawAddr: "0x0290FB167208Af455bB137780163b7B7a9a10C16",
 			addr:      Address{0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x2, 0x90, 0xfb, 0x16, 0x72, 0x8, 0xaf, 0x45, 0x5b, 0xb1, 0x37, 0x78, 0x1, 0x63, 0xb7, 0xb7, 0xa9, 0xa1, 0xc, 0x16},
-			errString: ""},
-		{label: "too long",
+			errString: "",
+		},
+		{
+			label:     "too long",
 			rawAddr:   "0x0000000000000000000000000000000000000000000000000000000000000000000004",
-			errString: "value must be no more than 32 bytes"},
-		{label: "too short",
+			errString: "value must be no more than 32 bytes",
+		},
+		{
+			label:     "too short",
 			rawAddr:   "4",
-			errString: "value must be at least 1 byte"},
-		{label: "empty string",
+			errString: "value must be at least 1 byte",
+		},
+		{
+			label:     "empty string",
 			rawAddr:   "",
-			errString: "value must be at least 1 byte"},
+			errString: "value must be at least 1 byte",
+		},
 	}
 
 	for _, tc := range tests {
@@ -896,7 +944,8 @@ func TestDecodeTransferPayloadHdr(t *testing.T) {
 	}
 
 	tests := []Test{
-		{label: "valid vaa",
+		{
+			label:          "valid vaa",
 			vaa:            "01000000000100e424aef95296cb0f2185f351086c7c0b9cd031d1288f0537d04ab20d5fc709416224b2bd9a8010a81988aa9cb38b378eb915f88b67e32a765928d948dc02077e00000102584a8d000000020000000000000000000000000290fb167208af455bb137780163b7b7a9a10c16000000000000000f0f01000000000000000000000000000000000000000000000000000000002b369f40000000000000000000000000ddb64fe46a91d46ee29420539fc25fd07c5fea3e000221c175fcd8e3a19fe2e0deae96534f0f4e6a896f4df0e3ec5345fe27ac3f63f000010000000000000000000000000000000000000000000000000000000000000000",
 			payloadType:    1,
 			emitterChainId: ChainIDEthereum,
@@ -908,15 +957,18 @@ func TestDecodeTransferPayloadHdr(t *testing.T) {
 			amount:         725000000,
 			errString:      "",
 		},
-		{label: "unsupported payload type",
+		{
+			label:     "unsupported payload type",
 			vaa:       "01000000000100e424aef95296cb0f2185f351086c7c0b9cd031d1288f0537d04ab20d5fc709416224b2bd9a8010a81988aa9cb38b378eb915f88b67e32a765928d948dc02077e00000102584a8d000000020000000000000000000000000290fb167208af455bb137780163b7b7a9a10c16000000000000000f0f02000000000000000000000000000000000000000000000000000000002b369f40000000000000000000000000ddb64fe46a91d46ee29420539fc25fd07c5fea3e000221c175fcd8e3a19fe2e0deae96534f0f4e6a896f4df0e3ec5345fe27ac3f63f000010000000000000000000000000000000000000000000000000000000000000000",
 			errString: "unsupported payload type",
 		},
-		{label: "buffer too short",
+		{
+			label:     "buffer too short",
 			vaa:       "01000000000100e424aef95296cb0f2185f351086c7c0b9cd031d1288f0537d04ab20d5fc709416224b2bd9a8010a81988aa9cb38b378eb915f88b67e32a765928d948dc02077e00000102584a8d000000020000000000000000000000000290fb167208af455bb137780163b7b7a9a10c16000000000000000f0f01",
 			errString: "buffer too short",
 		},
-		{label: "empty string",
+		{
+			label:     "empty string",
 			vaa:       "",
 			errString: "VAA is too short",
 		},
@@ -964,7 +1016,6 @@ func TestDecodeTransferPayloadHdr(t *testing.T) {
 					assert.Equal(t, tc.errString, err.Error())
 				}
 			}
-
 		})
 	}
 }
@@ -1191,7 +1242,6 @@ func TestChainIDFromNumber(t *testing.T) {
 }
 
 func TestStringToKnownChainID(t *testing.T) {
-
 	happy := []struct {
 		name     string
 		input    string