diff --git a/blssig/aggregation.go b/blssig/aggregation.go
index a2e60a09..09b390c1 100644
--- a/blssig/aggregation.go
+++ b/blssig/aggregation.go
@@ -7,7 +7,6 @@ import (
 
 	"github.com/drand/kyber"
 	"github.com/drand/kyber/sign"
-	"github.com/drand/kyber/sign/bdn"
 	"golang.org/x/xerrors"
 )
 
@@ -22,7 +21,7 @@ func (v Verifier) Aggregate(pubkeys []gpbft.PubKey, signatures [][]byte) ([]byte
 		return nil, xerrors.Errorf("converting public keys to mask: %w", err)
 	}
 
-	aggSigPoint, err := bdn.AggregateSignatures(v.suite, signatures, mask)
+	aggSigPoint, err := v.scheme.AggregateSignatures(signatures, mask)
 	if err != nil {
 		return nil, xerrors.Errorf("computing aggregate signature: %w", err)
 	}
@@ -40,12 +39,12 @@ func (v Verifier) VerifyAggregate(msg []byte, signature []byte, pubkeys []gpbft.
 		return xerrors.Errorf("converting public keys to mask: %w", err)
 	}
 
-	aggPubKey, err := bdn.AggregatePublicKeys(v.suite, mask)
+	aggPubKey, err := v.scheme.AggregatePublicKeys(mask)
 	if err != nil {
 		return xerrors.Errorf("aggregating public keys: %w", err)
 	}
 
-	return bdn.Verify(v.suite, aggPubKey, msg, signature)
+	return v.scheme.Verify(aggPubKey, msg, signature)
 }
 
 func (v Verifier) pubkeysToMask(pubkeys []gpbft.PubKey) (*sign.Mask, error) {
diff --git a/blssig/signer.go b/blssig/signer.go
index 56120da0..aabdb8f8 100644
--- a/blssig/signer.go
+++ b/blssig/signer.go
@@ -21,9 +21,9 @@ type Signer struct {
 	privKey kyber.Scalar
 }
 
-func SignerWithKeyOnG2(pub gpbft.PubKey, privKey kyber.Scalar) *Signer {
+func SignerWithKeyOnG1(pub gpbft.PubKey, privKey kyber.Scalar) *Signer {
 	return &Signer{
-		scheme:  bls.NewSchemeOnG1(bls12381.NewBLS12381Suite()),
+		scheme:  bls.NewSchemeOnG2(bls12381.NewBLS12381Suite()),
 		pubKey:  pub,
 		privKey: privKey,
 	}
diff --git a/blssig/verifier.go b/blssig/verifier.go
index 46b58fc5..f274e3ac 100644
--- a/blssig/verifier.go
+++ b/blssig/verifier.go
@@ -11,14 +11,16 @@ import (
 
 type Verifier struct {
 	suite    pairing.Suite
+	scheme   *bdn.Scheme
 	keyGroup kyber.Group
 }
 
-func VerifierWithKeyOnG2() Verifier {
+func VerifierWithKeyOnG1() Verifier {
 	suite := bls12381.NewBLS12381Suite()
 	return Verifier{
 		suite:    suite,
-		keyGroup: suite.G2(),
+		scheme:   bdn.NewSchemeOnG2(suite),
+		keyGroup: suite.G1(),
 	}
 }
 
@@ -32,5 +34,5 @@ func (v Verifier) Verify(pubKey gpbft.PubKey, msg, sig []byte) error {
 		return xerrors.Errorf("the public key is a null point")
 	}
 
-	return bdn.Verify(v.suite, pubKeyPoint, msg, sig)
+	return v.scheme.Verify(pubKeyPoint, msg, sig)
 }
diff --git a/sim/blssig.go b/sim/blssig.go
index 2c395ec8..798ab04e 100644
--- a/sim/blssig.go
+++ b/sim/blssig.go
@@ -30,10 +30,10 @@ func (b *BLSSigningBackend) Sign(sender gpbft.PubKey, msg []byte) ([]byte, error
 func NewBLSSigningBackend() *BLSSigningBackend {
 	suite := bls12381.NewBLS12381Suite()
 	return &BLSSigningBackend{
-		Verifier:        blssig.VerifierWithKeyOnG2(),
+		Verifier:        blssig.VerifierWithKeyOnG1(),
 		signersByPubKey: make(map[string]*blssig.Signer),
 		suite:           suite,
-		scheme:          bdn.NewSchemeOnG1(suite),
+		scheme:          bdn.NewSchemeOnG2(suite),
 	}
 }
 
@@ -43,6 +43,6 @@ func (b *BLSSigningBackend) GenerateKey() (gpbft.PubKey, any) {
 	if err != nil {
 		panic(err)
 	}
-	b.signersByPubKey[string(pubKeyB)] = blssig.SignerWithKeyOnG2(pubKeyB, priv)
+	b.signersByPubKey[string(pubKeyB)] = blssig.SignerWithKeyOnG1(pubKeyB, priv)
 	return pubKeyB, priv
 }
diff --git a/test/signing_suite_test.go b/test/signing_suite_test.go
index c87c4e07..73ebf8be 100644
--- a/test/signing_suite_test.go
+++ b/test/signing_suite_test.go
@@ -24,14 +24,14 @@ type (
 func TestBLSSigning(t *testing.T) {
 	var (
 		blsSuit   = bls12381.NewBLS12381Suite()
-		blsSchema = bdn.NewSchemeOnG1(blsSuit)
+		blsSchema = bdn.NewSchemeOnG2(blsSuit)
 	)
 	suite.Run(t, NewSigningSuite(func(t *testing.T) (gpbft.PubKey, gpbft.Signer) {
 		privKey, pubKey := blsSchema.NewKeyPair(blsSuit.RandomStream())
 		pubKeyB, err := pubKey.MarshalBinary()
 		require.NoError(t, err)
-		return pubKeyB, blssig.SignerWithKeyOnG2(pubKeyB, privKey)
-	}, blssig.VerifierWithKeyOnG2()))
+		return pubKeyB, blssig.SignerWithKeyOnG1(pubKeyB, privKey)
+	}, blssig.VerifierWithKeyOnG1()))
 }
 
 func TestFakeSigning(t *testing.T) {