Delete the SECP256K1 global context

Delete the old global context, make the new ones `pub`, and re-export
them in the `context` modulue (implies they are also re-exported at
crate root). Exactly which one is re-exported depends on whether the
crate is built with `std` or not.

Author: tcharding

src/context/internal_nostd.rs

@@ -73,7 +73,8 @@ mod self_contained_context {
 // because we need a const constructor.)
 pub(super) use self_contained_context::SelfContainedContext;
 
-static SECP256K1: SpinLock<SelfContainedContext> = SpinLock::<SelfContainedContext>::new();
+/// A global static context to avoid repeatedly creating contexts.
+pub static SECP256K1: SpinLock<SelfContainedContext> = SpinLock::<SelfContainedContext>::new();
 
 /// Borrows the global context and does some operation on it.
 ///

src/context/internal_std.rs

@@ -10,7 +10,10 @@ use secp256k1_sys as ffi;
 use crate::{All, Context, Secp256k1};
 
 thread_local! {
-    static SECP256K1: RefCell<Secp256k1<All>> = RefCell::new(Secp256k1::new());
+    /// A global static context to avoid repeatedly creating contexts.
+    ///
+    /// If `rand` feature is enabled, context will have been randomized using `rng`.
+    pub static SECP256K1: RefCell<Secp256k1<All>> = RefCell::new(Secp256k1::new());
 }
 
 /// Borrows the global context and does some operation on it.

src/context/mod.rs

@@ -17,45 +17,7 @@ mod internal;
 #[cfg(not(feature = "std"))]
 mod spinlock;
 
-pub use internal::{rerandomize_global_context, with_global_context, with_raw_global_context};
-
-#[cfg(all(feature = "global-context", feature = "std"))]
-/// Module implementing a singleton pattern for a global `Secp256k1` context.
-pub mod global {
-
-    use std::ops::Deref;
-    use std::sync::Once;
-
-    use crate::{All, Secp256k1};
-
-    /// Proxy struct for global `SECP256K1` context.
-    #[derive(Debug, Copy, Clone)]
-    pub struct GlobalContext {
-        __private: (),
-    }
-
-    /// A global static context to avoid repeatedly creating contexts.
-    ///
-    /// If `rand` and `std` feature is enabled, context will have been randomized using
-    /// `rng`.
-    pub static SECP256K1: &GlobalContext = &GlobalContext { __private: () };
-
-    impl Deref for GlobalContext {
-        type Target = Secp256k1<All>;
-
-        #[allow(unused_mut)] // Unused when `rand` + `std` is not enabled.
-        #[allow(static_mut_refs)] // The "proper" way to do this is with OnceLock (MSRV 1.70) or LazyLock (MSRV 1.80)
-                                  // See https://doc.rust-lang.org/nightly/edition-guide/rust-2024/static-mut-references.html
-        fn deref(&self) -> &Self::Target {
-            static ONCE: Once = Once::new();
-            static mut CONTEXT: Option<Secp256k1<All>> = None;
-            ONCE.call_once(|| unsafe {
-                CONTEXT = Some(Secp256k1::new());
-            });
-            unsafe { CONTEXT.as_ref().unwrap() }
-        }
-    }
-}
+pub use internal::{rerandomize_global_context, with_global_context, with_raw_global_context, SECP256K1};
 
 /// A trait for all kinds of contexts that lets you define the exact flags and a function to
 /// deallocate memory. It isn't possible to implement this for types outside this crate.

src/key/mod.rs

@@ -1940,7 +1940,6 @@ mod test {
         use serde_test::{assert_tokens, Configure, Token};
 
         use crate::key::Keypair;
-        use crate::SECP256K1;
 
         #[rustfmt::skip]
         static SK_BYTES: [u8; 32] = [

src/lib.rs

@@ -191,8 +191,7 @@ use crate::ffi::CPtr;
 #[rustfmt::skip]                // Keep public re-exports separate.
 pub use secp256k1_sys as ffi;
 
-#[cfg(all(feature = "global-context", feature = "std"))]
-pub use crate::context::global::{self, SECP256K1};
+pub use crate::context::SECP256K1;
 #[cfg(feature = "alloc")]
 pub use crate::context::{All, SignOnly, VerifyOnly};
 #[doc(inline)]