adaptation for simple secp256k1 context

chain/tests/nrd_validation_rules.rs

@@ -115,8 +115,8 @@ fn process_block_nrd_validation() -> Result<(), Error> {
 	let msg = kernel.msg_to_sign().unwrap();
 
 	// // Generate a kernel with public excess and associated signature.
-	let excess = BlindingFactor::rand(&keychain.secp());
-	let skey = excess.secret_key(&keychain.secp()).unwrap();
+	let excess = BlindingFactor::rand();
+	let skey = excess.secret_key().unwrap();
 	kernel.excess = keychain.secp().commit(0, skey).unwrap();
 	let pubkey = &kernel.excess.to_pubkey(&keychain.secp()).unwrap();
 	kernel.excess_sig =
@@ -231,8 +231,8 @@ fn process_block_nrd_validation_relative_height_1() -> Result<(), Error> {
 	let msg = kernel.msg_to_sign().unwrap();
 
 	// // Generate a kernel with public excess and associated signature.
-	let excess = BlindingFactor::rand(&keychain.secp());
-	let skey = excess.secret_key(&keychain.secp()).unwrap();
+	let excess = BlindingFactor::rand();
+	let skey = excess.secret_key().unwrap();
 	kernel.excess = keychain.secp().commit(0, skey).unwrap();
 	let pubkey = &kernel.excess.to_pubkey(&keychain.secp()).unwrap();
 	kernel.excess_sig =
@@ -330,8 +330,8 @@ fn process_block_nrd_validation_fork() -> Result<(), Error> {
 	let msg = kernel.msg_to_sign().unwrap();
 
 	// // Generate a kernel with public excess and associated signature.
-	let excess = BlindingFactor::rand(&keychain.secp());
-	let skey = excess.secret_key(&keychain.secp()).unwrap();
+	let excess = BlindingFactor::rand();
+	let skey = excess.secret_key().unwrap();
 	kernel.excess = keychain.secp().commit(0, skey).unwrap();
 	let pubkey = &kernel.excess.to_pubkey(&keychain.secp()).unwrap();
 	kernel.excess_sig =

core/src/core/committed.rs

@@ -73,7 +73,7 @@ pub trait Committed {
 			let secp = secp.lock();
 			let mut commits = vec![kernel_sum];
 			if *offset != BlindingFactor::zero() {
-				let key = offset.secret_key(&secp)?;
+				let key = offset.secret_key()?;
 				let offset_commit = secp.commit(0, key)?;
 				commits.push(offset_commit);
 			}
@@ -161,8 +161,8 @@ pub fn sum_kernel_offsets(
 ) -> Result<BlindingFactor, Error> {
 	let secp = static_secp_instance();
 	let secp = secp.lock();
-	let positive = to_secrets(positive, &secp);
-	let negative = to_secrets(negative, &secp);
+	let positive = to_secrets(positive);
+	let negative = to_secrets(negative);
 
 	if positive.is_empty() {
 		Ok(BlindingFactor::zero())
@@ -172,9 +172,9 @@ pub fn sum_kernel_offsets(
 	}
 }
 
-fn to_secrets(bf: Vec<BlindingFactor>, secp: &secp::Secp256k1) -> Vec<SecretKey> {
+fn to_secrets(bf: Vec<BlindingFactor>) -> Vec<SecretKey> {
 	bf.into_iter()
 		.filter(|x| *x != BlindingFactor::zero())
-		.filter_map(|x| x.secret_key(&secp).ok())
+		.filter_map(|x| x.secret_key().ok())
 		.collect::<Vec<_>>()
 }

core/src/core/transaction.rs

@@ -1530,12 +1530,12 @@ pub fn deaggregate(mk_tx: Transaction, txs: &[Transaction]) -> Result<Transactio
 		let positive_key = vec![mk_tx.offset]
 			.into_iter()
 			.filter(|x| *x != BlindingFactor::zero())
-			.filter_map(|x| x.secret_key(&secp).ok())
+			.filter_map(|x| x.secret_key().ok())
 			.collect::<Vec<_>>();
 		let negative_keys = kernel_offsets
 			.into_iter()
 			.filter(|x| *x != BlindingFactor::zero())
-			.filter_map(|x| x.secret_key(&secp).ok())
+			.filter_map(|x| x.secret_key().ok())
 			.collect::<Vec<_>>();
 
 		if positive_key.is_empty() && negative_keys.is_empty() {

core/src/libtx/aggsig.rs

@@ -74,7 +74,7 @@ pub fn create_secnonce(secp: &Secp256k1) -> Result<SecretKey, Error> {
 ///
 /// let secp = Secp256k1::with_caps(ContextFlag::SignOnly);
 /// let secret_nonce = aggsig::create_secnonce(&secp).unwrap();
-/// let secret_key = SecretKey::new(&secp, &mut thread_rng());
+/// let secret_key = SecretKey::new(&mut thread_rng());
 /// let pub_nonce_sum = PublicKey::from_secret_key(&secp, &secret_nonce).unwrap();
 /// // ... Add all other participating nonces
 /// let pub_key_sum = PublicKey::from_secret_key(&secp, &secret_key).unwrap();
@@ -144,7 +144,7 @@ pub fn calculate_partial_sig(
 ///
 /// let secp = Secp256k1::with_caps(ContextFlag::Full);
 /// let secret_nonce = aggsig::create_secnonce(&secp).unwrap();
-/// let secret_key = SecretKey::new(&secp, &mut thread_rng());
+/// let secret_key = SecretKey::new(&mut thread_rng());
 /// let pub_nonce_sum = PublicKey::from_secret_key(&secp, &secret_nonce).unwrap();
 /// // ... Add all other participating nonces
 /// let pub_key_sum = PublicKey::from_secret_key(&secp, &secret_key).unwrap();
@@ -359,7 +359,7 @@ pub fn verify_single_from_commit(
 ///
 /// let secp = Secp256k1::with_caps(ContextFlag::Full);
 /// let secret_nonce = aggsig::create_secnonce(&secp).unwrap();
-/// let secret_key = SecretKey::new(&secp, &mut thread_rng());
+/// let secret_key = SecretKey::new(&mut thread_rng());
 /// let pub_nonce_sum = PublicKey::from_secret_key(&secp, &secret_nonce).unwrap();
 /// // ... Add all other participating nonces
 /// let pub_key_sum = PublicKey::from_secret_key(&secp, &secret_key).unwrap();
@@ -454,7 +454,7 @@ pub fn sign_with_blinding(
 	blinding: &BlindingFactor,
 	pubkey_sum: Option<&PublicKey>,
 ) -> Result<Signature, Error> {
-	let skey = &blinding.secret_key(&secp)?;
+	let skey = &blinding.secret_key()?;
 	let sig = aggsig::sign_single(secp, &msg, skey, None, None, None, pubkey_sum, None)?;
 	Ok(sig)
 }

core/src/libtx/build.rs

@@ -213,8 +213,8 @@ where
 	let msg = kernel.msg_to_sign()?;
 
 	// Generate kernel public excess and associated signature.
-	let excess = BlindingFactor::rand(&keychain.secp());
-	let skey = excess.secret_key(&keychain.secp())?;
+	let excess = BlindingFactor::rand();
+	let skey = excess.secret_key()?;
 	kernel.excess = keychain.secp().commit(0, skey)?;
 	let pubkey = &kernel.excess.to_pubkey(&keychain.secp())?;
 	kernel.excess_sig = aggsig::sign_with_blinding(&keychain.secp(), &msg, &excess, Some(&pubkey))?;

core/src/libtx/proof.rs

@@ -146,9 +146,7 @@ where
 
 		let private_hash = blake2b(32, &[], &private_root_key.0).as_bytes().to_vec();
 
-		let public_root_key = keychain
-			.public_root_key()
-			.serialize_vec(keychain.secp(), true);
+		let public_root_key = keychain.public_root_key().serialize_vec(true);
 		let rewind_hash = blake2b(32, &[], &public_root_key[..]).as_bytes().to_vec();
 
 		Self {
@@ -165,7 +163,7 @@ where
 			&self.rewind_hash
 		};
 		let res = blake2b(32, &commit.0, hash);
-		SecretKey::from_slice(self.keychain.secp(), res.as_bytes()).map_err(|e| {
+		SecretKey::from_slice(res.as_bytes()).map_err(|e| {
 			ErrorKind::RangeProof(format!(
 				"Unable to extract nonce from commit {:?}, {}",
 				commit, e
@@ -283,7 +281,7 @@ where
 
 	fn nonce(&self, commit: &Commitment) -> Result<SecretKey, Error> {
 		let res = blake2b(32, &commit.0, &self.root_hash);
-		SecretKey::from_slice(self.keychain.secp(), res.as_bytes()).map_err(|e| {
+		SecretKey::from_slice(res.as_bytes()).map_err(|e| {
 			ErrorKind::RangeProof(format!(
 				"Unable to extract nonce from commit {:?}, {}",
 				commit, e
@@ -369,9 +367,9 @@ where
 }
 
 impl ProofBuild for ViewKey {
-	fn rewind_nonce(&self, secp: &Secp256k1, commit: &Commitment) -> Result<SecretKey, Error> {
+	fn rewind_nonce(&self, _secp: &Secp256k1, commit: &Commitment) -> Result<SecretKey, Error> {
 		let res = blake2b(32, &commit.0, &self.rewind_hash);
-		SecretKey::from_slice(secp, res.as_bytes()).map_err(|e| {
+		SecretKey::from_slice(res.as_bytes()).map_err(|e| {
 			ErrorKind::RangeProof(format!(
 				"Unable to rewind nonce for commit {:?}, {}",
 				commit, e

core/src/libtx/reward.rs

@@ -59,7 +59,7 @@ where
 	let msg = features.kernel_sig_msg()?;
 	let sig = match test_mode {
 		true => {
-			let test_nonce = secp::key::SecretKey::from_slice(&secp, &[1; 32])?;
+			let test_nonce = secp::key::SecretKey::from_slice(&[1; 32])?;
 			aggsig::sign_from_key_id(
 				&secp,
 				keychain,

core/src/libtx/secp_ser.rs

@@ -23,16 +23,14 @@ use util::{from_hex, ToHex};
 pub mod pubkey_serde {
 	use serde::{Deserialize, Deserializer, Serializer};
 	use util::secp::key::PublicKey;
-	use util::{from_hex, static_secp_instance, ToHex};
+	use util::{from_hex, ToHex};
 
 	///
 	pub fn serialize<S>(key: &PublicKey, serializer: S) -> Result<S::Ok, S::Error>
 	where
 		S: Serializer,
 	{
-		let static_secp = static_secp_instance();
-		let static_secp = static_secp.lock();
-		serializer.serialize_str(&key.serialize_vec(&static_secp, true).to_hex())
+		serializer.serialize_str(&key.serialize_vec(true).to_hex())
 	}
 
 	///
@@ -41,16 +39,14 @@ pub mod pubkey_serde {
 		D: Deserializer<'de>,
 	{
 		use serde::de::Error;
-		let static_secp = static_secp_instance();
-		let static_secp = static_secp.lock();
 		String::deserialize(deserializer)
 			.and_then(|string| {
 				from_hex(&string).map_err(|err| {
 					Error::custom(format!("Unable to decode pub key HEX {}, {}", string, err))
 				})
 			})
 			.and_then(|bytes: Vec<u8>| {
-				PublicKey::from_slice(&static_secp, &bytes).map_err(|err| {
+				PublicKey::from_slice(&bytes).map_err(|err| {
 					Error::custom(format!("Unable to build Pub Key from {:?}, {}", bytes, err))
 				})
 			})
@@ -106,7 +102,7 @@ pub mod option_sig_serde {
 pub mod option_seckey_serde {
 	use crate::serde::{Deserialize, Deserializer, Serializer};
 	use serde::de::Error;
-	use util::{from_hex, secp, static_secp_instance, ToHex};
+	use util::{from_hex, secp, ToHex};
 
 	///
 	pub fn serialize<S>(
@@ -127,8 +123,6 @@ pub mod option_seckey_serde {
 	where
 		D: Deserializer<'de>,
 	{
-		let static_secp = static_secp_instance();
-		let static_secp = static_secp.lock();
 		Option::<String>::deserialize(deserializer).and_then(|res| match res {
 			Some(string) => from_hex(&string)
 				.map_err(|err| {
@@ -137,7 +131,7 @@ pub mod option_seckey_serde {
 				.and_then(|bytes: Vec<u8>| {
 					let mut b = [0u8; 32];
 					b.copy_from_slice(&bytes[0..32]);
-					secp::key::SecretKey::from_slice(&static_secp, &b)
+					secp::key::SecretKey::from_slice(&b)
 						.map(Some)
 						.map_err(|err| Error::custom(format!("Fail to decode key, {}", err)))
 				}),
@@ -408,7 +402,7 @@ mod test {
 		pub fn random() -> SerTest {
 			let static_secp = static_secp_instance();
 			let secp = static_secp.lock();
-			let sk = SecretKey::new(&secp, &mut thread_rng());
+			let sk = SecretKey::new(&mut thread_rng());
 			let mut msg = [0u8; 32];
 			thread_rng().fill(&mut msg);
 			let msg = Message::from_slice(&msg).unwrap();

core/src/ser.rs

@@ -34,7 +34,6 @@ use util::secp::constants::{
 use util::secp::key::PublicKey;
 use util::secp::pedersen::{Commitment, RangeProof};
 use util::secp::Signature;
-use util::secp::{ContextFlag, Secp256k1};
 
 /// Serialization size limit for a single chunk/object or array.
 /// WARNING!!! You can increase the number, but never decrease
@@ -674,8 +673,7 @@ impl Writeable for Signature {
 impl Writeable for PublicKey {
 	// Write the public key in compressed form
 	fn write<W: Writer>(&self, writer: &mut W) -> Result<(), Error> {
-		let secp = Secp256k1::with_caps(ContextFlag::None);
-		writer.write_fixed_bytes(self.serialize_vec(&secp, true))?;
+		writer.write_fixed_bytes(self.serialize_vec(true))?;
 		Ok(())
 	}
 }
@@ -684,8 +682,7 @@ impl Readable for PublicKey {
 	// Read the public key in compressed form
 	fn read<R: Reader>(reader: &mut R) -> Result<Self, Error> {
 		let buf = reader.read_fixed_bytes(COMPRESSED_PUBLIC_KEY_SIZE)?;
-		let secp = Secp256k1::with_caps(ContextFlag::None);
-		let pk = PublicKey::from_slice(&secp, &buf)
+		let pk = PublicKey::from_slice(&buf)
 			.map_err(|e| Error::CorruptedData(format!("Unable to read public key, {}", e)))?;
 		Ok(pk)
 	}

core/tests/core.rs

@@ -198,8 +198,8 @@ fn build_two_half_kernels() {
 	let msg = kernel.msg_to_sign().unwrap();
 
 	// Generate a kernel with public excess and associated signature.
-	let excess = BlindingFactor::rand(&keychain.secp());
-	let skey = excess.secret_key(&keychain.secp()).unwrap();
+	let excess = BlindingFactor::rand();
+	let skey = excess.secret_key().unwrap();
 	kernel.excess = keychain.secp().commit(0, skey).unwrap();
 	let pubkey = &kernel.excess.to_pubkey(&keychain.secp()).unwrap();
 	kernel.excess_sig =