Skip to content

Commit 020e2f7

Browse files
webmaster128aumetra
webmaster128
authored and
aumetra
committed
Rename aggregate_pairing_equality -> pairing_equality
1 parent bd7018a commit 020e2f7

File tree

19 files changed

+161
-183
lines changed

19 files changed

+161
-183
lines changed

‎CHANGELOG.md

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -38,7 +38,7 @@ and this project adheres to
3838
- cosmwasm-vm: Read the state version from Wasm modules and return them as part
3939
of `AnalyzeReport` ([#2129])
4040
- cosmwasm-vm: Add `bls12_381_aggregate_g1`, `bls12_381_aggregate_g2`,
41-
`bls12_381_aggregate_pairing_equality`, `bls12_381_hash_to_g1`, and
41+
`bls12_381_pairing_equality`, `bls12_381_hash_to_g1`, and
4242
`bls12_381_hash_to_g1` to enable BLS12-381 curve operations, such as verifying
4343
pairing equalities ([#2106])
4444

‎contracts/crypto-verify/src/bls12_381.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -9,6 +9,6 @@ pub fn verify(
99
dst: &[u8],
1010
) -> StdResult<bool> {
1111
let s = api.bls12_381_hash_to_g2(HashFunction::Sha256, msg, dst)?;
12-
api.bls12_381_aggregate_pairing_equality(p, q, r, &s)
12+
api.bls12_381_pairing_equality(p, q, r, &s)
1313
.map_err(Into::into)
1414
}

‎packages/core/src/errors/mod.rs

Lines changed: 1 addition & 3 deletions
Original file line numberDiff line numberDiff line change
@@ -13,6 +13,4 @@ pub use core_error::{
1313
};
1414
pub use recover_pubkey_error::RecoverPubkeyError;
1515
pub use system_error::SystemError;
16-
pub use verification_error::{
17-
AggregationError, AggregationPairingEqualityError, VerificationError,
18-
};
16+
pub use verification_error::{AggregationError, PairingEqualityError, VerificationError};

‎packages/core/src/errors/recover_pubkey_error.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -66,7 +66,7 @@ impl From<CryptoError> for RecoverPubkeyError {
6666
CryptoError::GenericErr { .. } => RecoverPubkeyError::unknown_err(original.code()),
6767
CryptoError::InvalidRecoveryParam { .. } => RecoverPubkeyError::InvalidRecoveryParam,
6868
CryptoError::Aggregation { .. }
69-
| CryptoError::AggregationPairingEquality { .. }
69+
| CryptoError::PairingEquality { .. }
7070
| CryptoError::BatchErr { .. }
7171
| CryptoError::InvalidPubkeyFormat { .. }
7272
| CryptoError::InvalidPoint { .. }

‎packages/core/src/errors/verification_error.rs

Lines changed: 25 additions & 27 deletions
Original file line numberDiff line numberDiff line change
@@ -17,7 +17,7 @@ pub enum AggregationError {
1717

1818
#[derive(Display, Debug, PartialEq)]
1919
#[cfg_attr(feature = "std", derive(thiserror::Error))]
20-
pub enum AggregationPairingEqualityError {
20+
pub enum PairingEqualityError {
2121
#[display("List of G1 points is empty")]
2222
EmptyG1,
2323
#[display("List of G2 points is empty")]
@@ -35,10 +35,6 @@ pub enum AggregationPairingEqualityError {
3535
pub enum VerificationError {
3636
#[display("Aggregation error: {source}")]
3737
Aggregation { source: AggregationError },
38-
#[display("Aggregation pairing equality error: {source}")]
39-
AggregationPairingEquality {
40-
source: AggregationPairingEqualityError,
41-
},
4238
#[display("Batch error")]
4339
BatchErr,
4440
#[display("Generic error")]
@@ -55,6 +51,8 @@ pub enum VerificationError {
5551
InvalidPoint,
5652
#[display("Unknown hash function")]
5753
UnknownHashFunction,
54+
#[display("Aggregation pairing equality error: {source}")]
55+
PairingEquality { source: PairingEqualityError },
5856
#[display("Unknown error: {error_code}")]
5957
UnknownErr { error_code: u32, backtrace: BT },
6058
}
@@ -75,8 +73,8 @@ impl PartialEq<VerificationError> for VerificationError {
7573
VerificationError::Aggregation { source: lhs_source } => {
7674
matches!(rhs, VerificationError::Aggregation { source: rhs_source } if rhs_source == lhs_source)
7775
}
78-
VerificationError::AggregationPairingEquality { source: lhs_source } => {
79-
matches!(rhs, VerificationError::AggregationPairingEquality { source: rhs_source } if rhs_source == lhs_source)
76+
VerificationError::PairingEquality { source: lhs_source } => {
77+
matches!(rhs, VerificationError::PairingEquality { source: rhs_source } if rhs_source == lhs_source)
8078
}
8179
VerificationError::BatchErr => matches!(rhs, VerificationError::BatchErr),
8280
VerificationError::GenericErr => matches!(rhs, VerificationError::GenericErr),
@@ -127,35 +125,35 @@ impl From<CryptoError> for VerificationError {
127125
} => VerificationError::Aggregation {
128126
source: AggregationError::NotMultiple,
129127
},
130-
CryptoError::AggregationPairingEquality {
131-
source: cosmwasm_crypto::AggregationPairingEqualityError::EmptyG1,
128+
CryptoError::PairingEquality {
129+
source: cosmwasm_crypto::PairingEqualityError::EmptyG1,
132130
..
133-
} => VerificationError::AggregationPairingEquality {
134-
source: AggregationPairingEqualityError::EmptyG1,
131+
} => VerificationError::PairingEquality {
132+
source: PairingEqualityError::EmptyG1,
135133
},
136-
CryptoError::AggregationPairingEquality {
137-
source: cosmwasm_crypto::AggregationPairingEqualityError::EmptyG2,
134+
CryptoError::PairingEquality {
135+
source: cosmwasm_crypto::PairingEqualityError::EmptyG2,
138136
..
139-
} => VerificationError::AggregationPairingEquality {
140-
source: AggregationPairingEqualityError::EmptyG2,
137+
} => VerificationError::PairingEquality {
138+
source: PairingEqualityError::EmptyG2,
141139
},
142-
CryptoError::AggregationPairingEquality {
143-
source: cosmwasm_crypto::AggregationPairingEqualityError::NotMultipleG1 { .. },
140+
CryptoError::PairingEquality {
141+
source: cosmwasm_crypto::PairingEqualityError::NotMultipleG1 { .. },
144142
..
145-
} => VerificationError::AggregationPairingEquality {
146-
source: AggregationPairingEqualityError::NotMultipleG1,
143+
} => VerificationError::PairingEquality {
144+
source: PairingEqualityError::NotMultipleG1,
147145
},
148-
CryptoError::AggregationPairingEquality {
149-
source: cosmwasm_crypto::AggregationPairingEqualityError::NotMultipleG2 { .. },
146+
CryptoError::PairingEquality {
147+
source: cosmwasm_crypto::PairingEqualityError::NotMultipleG2 { .. },
150148
..
151-
} => VerificationError::AggregationPairingEquality {
152-
source: AggregationPairingEqualityError::NotMultipleG2,
149+
} => VerificationError::PairingEquality {
150+
source: PairingEqualityError::NotMultipleG2,
153151
},
154-
CryptoError::AggregationPairingEquality {
155-
source: cosmwasm_crypto::AggregationPairingEqualityError::UnequalPointAmount { .. },
152+
CryptoError::PairingEquality {
153+
source: cosmwasm_crypto::PairingEqualityError::UnequalPointAmount { .. },
156154
..
157-
} => VerificationError::AggregationPairingEquality {
158-
source: AggregationPairingEqualityError::UnequalPointAmount,
155+
} => VerificationError::PairingEquality {
156+
source: PairingEqualityError::UnequalPointAmount,
159157
},
160158
CryptoError::InvalidHashFormat { .. } => VerificationError::InvalidHashFormat,
161159
CryptoError::InvalidPubkeyFormat { .. } => VerificationError::InvalidPubkeyFormat,

‎packages/core/src/lib.rs

Lines changed: 5 additions & 5 deletions
Original file line numberDiff line numberDiff line change
@@ -28,11 +28,11 @@ pub use crate::addresses::{instantiate2_address, Addr, CanonicalAddr, Instantiat
2828
pub use crate::binary::Binary;
2929
pub use crate::encoding::{from_base64, from_hex, to_base64, to_hex};
3030
pub use crate::errors::{
31-
AggregationError, AggregationPairingEqualityError, CheckedFromRatioError,
32-
CheckedMultiplyFractionError, CheckedMultiplyRatioError, CoinFromStrError, CoinsError,
33-
ConversionOverflowError, CoreError, CoreResult, DivideByZeroError, DivisionError,
34-
OverflowError, OverflowOperation, RecoverPubkeyError, RoundDownOverflowError,
35-
RoundUpOverflowError, SystemError, VerificationError,
31+
AggregationError, CheckedFromRatioError, CheckedMultiplyFractionError,
32+
CheckedMultiplyRatioError, CoinFromStrError, CoinsError, ConversionOverflowError, CoreError,
33+
CoreResult, DivideByZeroError, DivisionError, OverflowError, OverflowOperation,
34+
PairingEqualityError, RecoverPubkeyError, RoundDownOverflowError, RoundUpOverflowError,
35+
SystemError, VerificationError,
3636
};
3737
pub use crate::hex_binary::HexBinary;
3838
pub use crate::math::{

‎packages/crypto/benches/main.rs

Lines changed: 18 additions & 21 deletions
Original file line numberDiff line numberDiff line change
@@ -16,10 +16,10 @@ use k256::ecdsa::SigningKey; // type alias
1616
use sha2::Sha256;
1717

1818
use cosmwasm_crypto::{
19-
bls12_381_aggregate_g1, bls12_381_aggregate_g2, bls12_381_aggregate_pairing_equality,
20-
bls12_381_g1_generator, bls12_381_hash_to_g1, bls12_381_hash_to_g2, ed25519_batch_verify,
21-
ed25519_verify, secp256k1_recover_pubkey, secp256k1_verify, secp256r1_recover_pubkey,
22-
secp256r1_verify, HashFunction, BLS12_381_G1_POINT_LEN, BLS12_381_G2_POINT_LEN,
19+
bls12_381_aggregate_g1, bls12_381_aggregate_g2, bls12_381_g1_generator, bls12_381_hash_to_g1,
20+
bls12_381_hash_to_g2, bls12_381_pairing_equality, ed25519_batch_verify, ed25519_verify,
21+
secp256k1_recover_pubkey, secp256k1_verify, secp256r1_recover_pubkey, secp256r1_verify,
22+
HashFunction, BLS12_381_G1_POINT_LEN, BLS12_381_G2_POINT_LEN,
2323
};
2424
use std::cmp::min;
2525

@@ -187,22 +187,19 @@ where
187187
.serialize_compressed(&mut serialized_signature[..])
188188
.unwrap();
189189

190-
group.bench_function(
191-
format!("bls12_381_aggregate_pairing_equality_{num_points}"),
192-
|b| {
193-
b.iter(|| {
194-
let is_valid = black_box(bls12_381_aggregate_pairing_equality(
195-
&serialized_pubkeys,
196-
&serialized_messages,
197-
&bls12_381_g1_generator(),
198-
&serialized_signature,
199-
))
200-
.unwrap();
201-
202-
assert!(is_valid);
203-
});
204-
},
205-
);
190+
group.bench_function(format!("bls12_381_pairing_equality_{num_points}"), |b| {
191+
b.iter(|| {
192+
let is_valid = black_box(bls12_381_pairing_equality(
193+
&serialized_pubkeys,
194+
&serialized_messages,
195+
&bls12_381_g1_generator(),
196+
&serialized_signature,
197+
))
198+
.unwrap();
199+
200+
assert!(is_valid);
201+
});
202+
});
206203
}
207204
}
208205

@@ -231,7 +228,7 @@ where
231228
let message = bls12_381_hash_to_g2(HashFunction::Sha256, &BLS_MESSAGE, BLS_DST);
232229

233230
b.iter(|| {
234-
let is_equal = bls12_381_aggregate_pairing_equality(
231+
let is_equal = bls12_381_pairing_equality(
235232
black_box(&BLS_PUBKEY),
236233
&message,
237234
&generator,

‎packages/crypto/src/bls12_318/mod.rs

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -7,7 +7,7 @@ mod points;
77
pub use aggregate::{bls12_381_aggregate_g1, bls12_381_aggregate_g2};
88
pub use constants::{bls12_381_g1_generator, bls12_381_g2_generator};
99
pub use hash::{bls12_381_hash_to_g1, bls12_381_hash_to_g2, HashFunction};
10-
pub use pairing::bls12_381_aggregate_pairing_equality;
10+
pub use pairing::bls12_381_pairing_equality;
1111
pub use points::{bls12_381_g1_is_identity, bls12_381_g2_is_identity};
1212

1313
pub const BLS12_381_G1_POINT_LEN: usize = 48;

‎packages/crypto/src/bls12_318/pairing.rs

Lines changed: 28 additions & 30 deletions
Original file line numberDiff line numberDiff line change
@@ -1,8 +1,6 @@
11
use core::ops::Neg;
22

3-
use crate::{
4-
errors::AggregationPairingEquality, CryptoError, BLS12_381_G1_POINT_LEN, BLS12_381_G2_POINT_LEN,
5-
};
3+
use crate::{errors::PairingEquality, CryptoError, BLS12_381_G1_POINT_LEN, BLS12_381_G2_POINT_LEN};
64

75
use super::points::{g1_from_variable, g2_from_variable};
86
use ark_bls12_381::Bls12_381;
@@ -16,28 +14,28 @@ use rayon::{
1614
slice::ParallelSlice,
1715
};
1816

19-
pub fn bls12_381_aggregate_pairing_equality(
17+
pub fn bls12_381_pairing_equality(
2018
ps: &[u8],
2119
qs: &[u8],
2220
r: &[u8],
2321
s: &[u8],
2422
) -> Result<bool, CryptoError> {
2523
if ps.is_empty() {
26-
return Err(AggregationPairingEquality::EmptyG1.into());
24+
return Err(PairingEquality::EmptyG1.into());
2725
} else if qs.is_empty() {
28-
return Err(AggregationPairingEquality::EmptyG2.into());
26+
return Err(PairingEquality::EmptyG2.into());
2927
} else if ps.len() % BLS12_381_G1_POINT_LEN != 0 {
30-
return Err(AggregationPairingEquality::NotMultipleG1 {
28+
return Err(PairingEquality::NotMultipleG1 {
3129
remainder: ps.len() % BLS12_381_G1_POINT_LEN,
3230
}
3331
.into());
3432
} else if qs.len() % BLS12_381_G2_POINT_LEN != 0 {
35-
return Err(AggregationPairingEquality::NotMultipleG2 {
33+
return Err(PairingEquality::NotMultipleG2 {
3634
remainder: qs.len() % BLS12_381_G2_POINT_LEN,
3735
}
3836
.into());
3937
} else if (ps.len() / BLS12_381_G1_POINT_LEN) != (qs.len() / BLS12_381_G2_POINT_LEN) {
40-
return Err(AggregationPairingEquality::UnequalPointAmount {
38+
return Err(PairingEquality::UnequalPointAmount {
4139
left: ps.len() / BLS12_381_G1_POINT_LEN,
4240
right: qs.len() / BLS12_381_G2_POINT_LEN,
4341
}
@@ -73,8 +71,8 @@ mod test {
7371

7472
use crate::{
7573
bls12_318::points::{g1_from_fixed, g2_from_fixed, g2_from_variable, G1},
76-
bls12_381_aggregate_pairing_equality, bls12_381_hash_to_g2,
77-
AggregationPairingEqualityError, CryptoError, HashFunction,
74+
bls12_381_hash_to_g2, bls12_381_pairing_equality, CryptoError, HashFunction,
75+
PairingEqualityError,
7876
};
7977

8078
// Let's directly go for something really cool and advanced:
@@ -106,7 +104,7 @@ mod test {
106104
let msg = build_message(round, &previous_signature);
107105
let g2_msg = bls12_381_hash_to_g2(HashFunction::Sha256, msg.as_slice(), DOMAIN_HASH_TO_G2);
108106

109-
assert!(bls12_381_aggregate_pairing_equality(
107+
assert!(bls12_381_pairing_equality(
110108
&g1.to_compressed(),
111109
&sigma.to_compressed(),
112110
&PK_LEO_MAINNET,
@@ -122,7 +120,7 @@ mod test {
122120
let g2_msg =
123121
bls12_381_hash_to_g2(HashFunction::Sha256, msg.as_slice(), DOMAIN_HASH_TO_G2);
124122

125-
assert!(!bls12_381_aggregate_pairing_equality(
123+
assert!(!bls12_381_pairing_equality(
126124
&g1.to_compressed(),
127125
&sigma.to_compressed(),
128126
&PK_LEO_MAINNET,
@@ -150,7 +148,7 @@ mod test {
150148
))
151149
.unwrap();
152150

153-
assert!(bls12_381_aggregate_pairing_equality(
151+
assert!(bls12_381_pairing_equality(
154152
&aggregated_g1.to_compressed(),
155153
&aggregated_sigma.to_compressed(),
156154
&aggregated_key.to_compressed(),
@@ -160,48 +158,48 @@ mod test {
160158
}
161159

162160
#[test]
163-
fn aggregate_pairing_equality_error_cases_work() {
164-
let result = bls12_381_aggregate_pairing_equality(&[], &[12], &[12], &[12]);
161+
fn pairing_equality_error_cases_work() {
162+
let result = bls12_381_pairing_equality(&[], &[12], &[12], &[12]);
165163
assert!(matches!(
166164
result,
167-
Err(CryptoError::AggregationPairingEquality {
168-
source: AggregationPairingEqualityError::EmptyG1,
165+
Err(CryptoError::PairingEquality {
166+
source: PairingEqualityError::EmptyG1,
169167
..
170168
})
171169
));
172170

173-
let result = bls12_381_aggregate_pairing_equality(&[12], &[], &[12], &[12]);
171+
let result = bls12_381_pairing_equality(&[12], &[], &[12], &[12]);
174172
assert!(matches!(
175173
result,
176-
Err(CryptoError::AggregationPairingEquality {
177-
source: AggregationPairingEqualityError::EmptyG2,
174+
Err(CryptoError::PairingEquality {
175+
source: PairingEqualityError::EmptyG2,
178176
..
179177
})
180178
));
181179

182-
let result = bls12_381_aggregate_pairing_equality(&[12], &[0; 96], &[12], &[12]);
180+
let result = bls12_381_pairing_equality(&[12], &[0; 96], &[12], &[12]);
183181
assert!(matches!(
184182
result,
185-
Err(CryptoError::AggregationPairingEquality {
186-
source: AggregationPairingEqualityError::NotMultipleG1 { remainder: 1 },
183+
Err(CryptoError::PairingEquality {
184+
source: PairingEqualityError::NotMultipleG1 { remainder: 1 },
187185
..
188186
})
189187
));
190188

191-
let result = bls12_381_aggregate_pairing_equality(&[0; 48], &[12], &[12], &[12]);
189+
let result = bls12_381_pairing_equality(&[0; 48], &[12], &[12], &[12]);
192190
assert!(matches!(
193191
result,
194-
Err(CryptoError::AggregationPairingEquality {
195-
source: AggregationPairingEqualityError::NotMultipleG2 { remainder: 1 },
192+
Err(CryptoError::PairingEquality {
193+
source: PairingEqualityError::NotMultipleG2 { remainder: 1 },
196194
..
197195
})
198196
));
199197

200-
let result = bls12_381_aggregate_pairing_equality(&[0; 96], &[0; 96], &[12], &[12]);
198+
let result = bls12_381_pairing_equality(&[0; 96], &[0; 96], &[12], &[12]);
201199
assert!(matches!(
202200
result,
203-
Err(CryptoError::AggregationPairingEquality {
204-
source: AggregationPairingEqualityError::UnequalPointAmount { left: 2, right: 1 },
201+
Err(CryptoError::PairingEquality {
202+
source: PairingEqualityError::UnequalPointAmount { left: 2, right: 1 },
205203
..
206204
})
207205
));

0 commit comments

Comments
 (0)