feat: integrate ECDSA registration for KeyRegistrar (#269)

<!-- 
    🚨 ATTENTION! 🚨 
    
This PR template is REQUIRED. PRs not following this format will be
closed without review.
    
    Requirements:
- PR title must follow commit conventions:
https://www.conventionalcommits.org/en/v1.0.0/
- Label your PR with the correct type (e.g., 🐛 Bug, ✨ Enhancement, 🧪
Test, etc.)
    - Provide clear and specific details in each section
-->

**Motivation:**
<!--
Explain here the context, and why you're making that change. What is the
problem you're trying to solve.
-->
As a devkit user, I want to be able to register either BN254 or ECDSA
keys for my Operator to the KeyRegsitrar

**Modifications:**
<!--
Describe the modifications you've done from a high level. What are the
key technical decisions and why were they made?
-->
- Allows either curveType to be registered to the KeyRegistrar

**Result:**
<!--
*After your change, what will change.
-->
- Can setup and register ECDSA or BN254 keys in the
`RegisterKeyInKeyRegistrarAction` deploy step

Author: grezle

pkg/commands/deploy_actions.go

@@ -14,14 +14,15 @@ import (
 	"strings"
 	"time"
 
-	"github.com/Layr-Labs/crypto-libs/pkg/bn254"
 	"github.com/Layr-Labs/crypto-libs/pkg/keystore"
 	"github.com/Layr-Labs/devkit-cli/config/configs"
 	"github.com/Layr-Labs/devkit-cli/config/contexts"
 	"github.com/Layr-Labs/devkit-cli/pkg/common"
 	"github.com/Layr-Labs/devkit-cli/pkg/common/iface"
 	allocationmanager "github.com/Layr-Labs/eigenlayer-contracts/pkg/bindings/AllocationManager"
+	keyregistrar "github.com/Layr-Labs/eigenlayer-contracts/pkg/bindings/KeyRegistrar"
 	ethcommon "github.com/ethereum/go-ethereum/common"
+	"github.com/ethereum/go-ethereum/crypto"
 	"github.com/ethereum/go-ethereum/ethclient"
 	"github.com/urfave/cli/v2"
 	"golang.org/x/text/cases"
@@ -1146,86 +1147,149 @@ func RegisterKeyInKeyRegistrarAction(cCtx *cli.Context, logger iface.Logger) err
 		return fmt.Errorf("failed to connect to L1 RPC: %w", err)
 	}
 
+	// Bind to keyRegistrar
 	avsAddress := ethcommon.HexToAddress(envCtx.Avs.Address)
-	_, _, _, keyRegistrarAddr, _, _, _, _ := common.GetEigenLayerAddresses(contextName, cfg)
+	_, _, _, keyRegistrarAddrHex, _, _, _, _ := common.GetEigenLayerAddresses(contextName, cfg)
+	krAddr := ethcommon.HexToAddress(keyRegistrarAddrHex)
+	kr, err := keyregistrar.NewKeyRegistrar(krAddr, client)
+	if err != nil {
+		return fmt.Errorf("failed to bind KeyRegistrar at %s: %w", krAddr.Hex(), err)
+	}
 
 	for _, op := range envCtx.OperatorRegistrations {
-
 		for _, operator := range envCtx.Operators {
+			if op.Address != operator.Address {
+				continue
+			}
+
+			// Tx signer (EOA): hex string private key
+			operatorPrivHex, err := loadOperatorECDSAKey(operator)
+			if err != nil {
+				return fmt.Errorf("failed to load ECDSA key for operator %s: %w", operator.Address, err)
+			}
+			operatorAddress := ethcommon.HexToAddress(op.Address)
+
+			// Build the caller
+			contractCaller, err := common.NewContractCaller(
+				operatorPrivHex,
+				big.NewInt(int64(l1Cfg.ChainID)),
+				client,
+				ethcommon.HexToAddress(""),
+				ethcommon.HexToAddress(""),
+				ethcommon.HexToAddress(""),
+				krAddr, // key registrar
+				ethcommon.HexToAddress(""),
+				ethcommon.HexToAddress(""),
+				ethcommon.HexToAddress(""),
+				logger,
+			)
+			if err != nil {
+				return fmt.Errorf("failed to create contract caller: %w", err)
+			}
 
-			if op.Address == operator.Address {
-				operatorPrivateKey, err := loadOperatorECDSAKey(operator)
+			// We need the parsed *ecdsa.PrivateKey for ECDSA signing and address derivation
+			operatorECDSA, err := crypto.HexToECDSA(strings.TrimPrefix(operatorPrivHex, "0x"))
+			if err != nil {
+				return fmt.Errorf("invalid operator ECDSA key hex: %w", err)
+			}
+
+			// Discover curve type
+			operatorSet := keyregistrar.OperatorSet{Avs: avsAddress, Id: uint32(op.OperatorSetID)}
+			curveType, err := kr.GetOperatorSetCurveType(nil, operatorSet)
+			if err != nil {
+				return fmt.Errorf("failed to get operator set curve type: %w", err)
+			}
+
+			switch curveType {
+			case common.CURVE_TYPE_KEY_REGISTRAR_ECDSA:
+				// keyData = 20-byte address
+				keyAddr := crypto.PubkeyToAddress(operatorECDSA.PublicKey)
+				keyData := keyAddr.Bytes()
+
+				// EIP-712 digest from contract
+				msgHash, err := kr.GetECDSAKeyRegistrationMessageHash(nil, operatorAddress, operatorSet, keyAddr)
 				if err != nil {
-					return fmt.Errorf("failed to load ECDSA key for operator %s: %w", operator.Address, err)
+					return fmt.Errorf("failed to get ECDSA hash: %w", err)
 				}
-				operatorAddress := ethcommon.HexToAddress(op.Address)
-				contractCaller, err := common.NewContractCaller(
-					operatorPrivateKey,
-					big.NewInt(int64(l1Cfg.ChainID)),
-					client,
-					ethcommon.HexToAddress(""),
-					ethcommon.HexToAddress(""),
-					ethcommon.HexToAddress(""),
-					ethcommon.HexToAddress(keyRegistrarAddr),
-					ethcommon.HexToAddress(""),
-					ethcommon.HexToAddress(""),
-					ethcommon.HexToAddress(""),
-					logger,
-				)
+
+				// 65-byte r||s||v with v in {27,28}
+				sig, err := crypto.Sign(msgHash[:], operatorECDSA)
 				if err != nil {
-					return fmt.Errorf("failed to create contract caller: %w", err)
+					return fmt.Errorf("failed to sign ECDSA: %w", err)
+				}
+				if sig[64] < 27 {
+					sig[64] += 27
 				}
 
-				var blskeystorePath, blskeystorePassword string
+				if err := contractCaller.RegisterKeyInKeyRegistrar(
+					cCtx.Context, operatorAddress, avsAddress, uint32(op.OperatorSetID), keyData, sig,
+				); err != nil {
+					return fmt.Errorf("failed to register ECDSA key: %w", err)
+				}
+				logger.Info("Registered ECDSA key for operator %s", operator.Address)
+
+			case common.CURVE_TYPE_KEY_REGISTRAR_BN254:
+				// Load BN254 key for this set
+				var blsKeystorePath, blsKeystorePassword string
 				for _, ks := range operator.Keystores {
 					if ks.OperatorSet == op.OperatorSetID {
-						blskeystorePath = ks.BlsKeystorePath
-						blskeystorePassword = ks.BlsKeystorePassword
+						blsKeystorePath = ks.BlsKeystorePath
+						blsKeystorePassword = ks.BlsKeystorePassword
 						break
 					}
 				}
-
-				if blskeystorePath == "" {
-					return fmt.Errorf("no bls keystore found for OperatorSet %d", op.OperatorSetID)
+				if blsKeystorePath == "" {
+					return fmt.Errorf("no BLS keystore found for OperatorSet %d", op.OperatorSetID)
 				}
 
-				keystoreData, err := keystore.LoadKeystoreFile(blskeystorePath)
+				ksData, err := keystore.LoadKeystoreFile(blsKeystorePath)
 				if err != nil {
-					return fmt.Errorf("failed to load the keystore file from given path %s error %w", blskeystorePath, err)
+					return fmt.Errorf("failed to load the keystore file from given path %s error %w", blsKeystorePath, err)
 				}
-
-				privateKey, err := keystoreData.GetBN254PrivateKey(blskeystorePassword)
+				blsPriv, err := ksData.GetBN254PrivateKey(blsKeystorePassword)
 				if err != nil {
-					return fmt.Errorf("failed to extract the private key from the keystore file")
-
+					return fmt.Errorf("failed to extract BN254 private key from keystore: %w", err)
 				}
 
-				keyData, err := contractCaller.EncodeBN254KeyData(privateKey.Public())
+				keyData, err := contractCaller.EncodeBN254KeyData(blsPriv.Public())
 				if err != nil {
-					return fmt.Errorf("failed to encode key data: %w", err)
+					return fmt.Errorf("failed to encode BN254 key data: %w", err)
 				}
 
-				messageHash, err := contractCaller.GetOperatorRegistrationMessageHash(cCtx.Context, operatorAddress, avsAddress, uint32(op.OperatorSetID), keyData)
+				// EIP-712 digest from contract
+				msgHash, err := kr.GetBN254KeyRegistrationMessageHash(nil, operatorAddress, operatorSet, keyData)
 				if err != nil {
 					return fmt.Errorf("failed to get operator registration message hash: %w", err)
 				}
 
-				signature, err := privateKey.SignSolidityCompatible(messageHash)
+				// Ensure [32]byte for the BLS signer
+				var digest [32]byte
+				copy(digest[:], msgHash[:])
+
+				blsSig, err := blsPriv.SignSolidityCompatible(digest)
 				if err != nil {
-					return fmt.Errorf("failed to sign message hash: %w", err)
+					return fmt.Errorf("failed to sign BN254 message hash: %w", err)
 				}
-
-				bn254Signature := bn254.Signature(*signature)
-
-				err = contractCaller.RegisterKeyInKeyRegistrar(cCtx.Context, operatorAddress, avsAddress, uint32(op.OperatorSetID), keyData, bn254Signature)
+				x := blsSig.GetG1Point().X.BigInt(new(big.Int))
+				y := blsSig.GetG1Point().Y.BigInt(new(big.Int))
+				sigBytes, err := contractCaller.PackUint256Pair(x, y)
 				if err != nil {
-					return fmt.Errorf("failed to register key in key registrar: %w", err)
+					return fmt.Errorf("failed to pack BN254 signature: %w", err)
 				}
-				logger.Info("Successfully registered key in key registrar for operator %s", operator.Address)
+
+				if err := contractCaller.RegisterKeyInKeyRegistrar(
+					cCtx.Context, operatorAddress, avsAddress, uint32(op.OperatorSetID), keyData, sigBytes,
+				); err != nil {
+					return fmt.Errorf("failed to register BN254 key: %w", err)
+				}
+				logger.Info("Registered BN254 key for operator %s", operator.Address)
+
+			default:
+				return fmt.Errorf("unsupported curve type %d for operatorSet %d", curveType, op.OperatorSetID)
 			}
 		}
-
 	}
+
 	logger.Info("Successfully registered keys in key registrar")
 	return nil
 }

pkg/commands/transporter.go

@@ -405,21 +405,33 @@ func Transport(cCtx *cli.Context, initialRun bool) error {
 				return fmt.Errorf("registration hash: %w", err)
 			}
 
-			// Sign the message hash with BLS key
-			sig, err := blsPriv.SignSolidityCompatible(msgHash)
+			// Ensure [32]byte input to the signer
+			var digest [32]byte
+			copy(digest[:], msgHash[:])
+
+			// Sign with BN254 key
+			sig, err := blsPriv.SignSolidityCompatible(digest)
 			if err != nil {
 				return fmt.Errorf("BLS sign: %w", err)
 			}
-			bn254Signature := bn254.Signature(*sig)
 
-			// Register in KeyRegistrar
+			// Convert G1 point to abi.encode(uint256 x, uint256 y)
+			x := sig.GetG1Point().X.BigInt(new(big.Int))
+			y := sig.GetG1Point().Y.BigInt(new(big.Int))
+
+			sigBytes, err := contractCaller.PackUint256Pair(x, y)
+			if err != nil {
+				return fmt.Errorf("pack BN254 signature: %w", err)
+			}
+
+			// Register BLS key in KeyRegistrar with raw bytes
 			if err := contractCaller.RegisterKeyInKeyRegistrar(
 				cCtx.Context,
 				operatorAddress,
 				gen.Avs,
 				uint32(gen.Id),
 				keyData,
-				bn254Signature,
+				sigBytes,
 			); err != nil {
 				return fmt.Errorf("register key in key registrar: %w", err)
 			}

pkg/common/contract_caller.go

@@ -10,7 +10,6 @@ import (
 	"math/big"
 	"strings"
 
-	"github.com/Layr-Labs/crypto-libs/pkg/bn254"
 	"github.com/Layr-Labs/devkit-cli/pkg/common/contracts"
 	"github.com/Layr-Labs/devkit-cli/pkg/common/iface"
 	allocationmanager "github.com/Layr-Labs/eigenlayer-contracts/pkg/bindings/AllocationManager"
@@ -736,7 +735,14 @@ func (cc *ContractCaller) WhitelistChainIdInCrossRegistry(ctx context.Context, o
 	return nil
 }
 
-func (cc *ContractCaller) RegisterKeyInKeyRegistrar(ctx context.Context, operatorAddress common.Address, avsAddress common.Address, opSetId uint32, keyData []byte, signature bn254.Signature) error {
+func (cc *ContractCaller) RegisterKeyInKeyRegistrar(
+	ctx context.Context,
+	operatorAddress common.Address,
+	avsAddress common.Address,
+	opSetId uint32,
+	keyData []byte,
+	signature []byte,
+) error {
 	opts, err := cc.buildTxOpts()
 	if err != nil {
 		return fmt.Errorf("failed to build transaction options: %w", err)
@@ -746,13 +752,6 @@ func (cc *ContractCaller) RegisterKeyInKeyRegistrar(ctx context.Context, operato
 	if err != nil {
 		return fmt.Errorf("failed to get KeyRegistrar: %w", err)
 	}
-	g1Point := &bn254.G1Point{
-		G1Affine: signature.GetG1Point(),
-	}
-	g1Bytes, err := g1Point.ToPrecompileFormat()
-	if err != nil {
-		return fmt.Errorf("signature not in correct subgroup: %w", err)
-	}
 
 	operatorSet := keyregistrar.OperatorSet{Avs: avsAddress, Id: opSetId}
 
@@ -767,8 +766,7 @@ func (cc *ContractCaller) RegisterKeyInKeyRegistrar(ctx context.Context, operato
 	}
 
 	err = cc.SendAndWaitForTransaction(ctx, "RegisterKeyInKeyRegistrar", func() (*types.Transaction, error) {
-		tx, err := keyRegistrar.RegisterKey(opts, operatorAddress, operatorSet, keyData, g1Bytes)
-		return tx, err
+		return keyRegistrar.RegisterKey(opts, operatorAddress, operatorSet, keyData, signature)
 	})
 	return err
 }
@@ -844,3 +842,16 @@ func (cc *ContractCaller) SetReleaseMetadata(
 		return tx, err
 	})
 }
+
+// abi.encode(uint256 x, uint256 y)
+func (cc *ContractCaller) PackUint256Pair(x, y *big.Int) ([]byte, error) {
+	t, err := abi.NewType("uint256", "", nil)
+	if err != nil {
+		return nil, err
+	}
+	args := abi.Arguments{
+		{Type: t},
+		{Type: t},
+	}
+	return args.Pack(x, y)
+}