diff --git a/CHANGELOG.md b/CHANGELOG.md
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -4,6 +4,79 @@
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
+## [3.0.0] - 2026-11-15
+
+The context is now global and no longer part of the API. This breaks every
+program that uses the package, on purpose: see Migrating.
+
+### Removed
+
+- `Ctx`, `createContext`, `withContext`, `cloneContext` and `randomizeContext`
+  are gone from `Crypto.Secp256k1`.
+- The `Ctx` argument is gone from every function of `Crypto.Secp256k1` and
+  `Crypto.Secp256k1.Recovery` that took one: `derivePubKey`, `importPubKey`,
+  `exportPubKey`, `signMsg`, `signMsgLowR`, `verifySig`, `normalizeSig`,
+  `isLowS`, `isLowR`, `importSig`, `exportSig`, `importCompactSig`,
+  `exportCompactSig`, `tweakAddSecKey`, `tweakMulSecKey`, `tweakAddPubKey`,
+  `tweakMulPubKey`, `combinePubKeys`, `tweakNegate`, `signSchnorr`,
+  `signSchnorrWithAux`, `signSchnorrIO`, `verifySchnorr`,
+  `importXOnlyPubKey`, `exportXOnlyPubKey`, `tweakAddXOnlyPubKey`,
+  `tweakAddXOnlySecKey`, `signRecMsg`, `recover`, `convertRecSig`,
+  `importCompactRecSig` and `exportCompactRecSig`. The other arguments keep
+  their order, for example `signMsg :: SecKey -> Msg -> Sig` and
+  `exportPubKey :: Bool -> PubKey -> ByteString`.
+- The package no longer exposes anything that makes, takes or names a
+  context. `Crypto.Secp256k1.Internal.Context`, `Crypto.Secp256k1.Internal.BaseOps`
+  and `Crypto.Secp256k1.Internal.RecoveryOps` are hidden modules now, so the
+  raw foreign imports and the bindings that create, clone, randomize and
+  destroy contexts cannot be imported. `LCtx` and `CtxFlags` are gone from
+  `Crypto.Secp256k1.Internal.ForeignTypes`. `Ctx`, `wrapContext` and
+  `validationContext` no longer exist. There is no replacement: code that
+  called the raw bindings with its own context uses the functions of
+  `Crypto.Secp256k1` and `Crypto.Secp256k1.Recovery`.
+- The functions of
+  `Crypto.Secp256k1.Internal.Base` and `Crypto.Secp256k1.Internal.Recovery`
+  lost their context argument too, including the helpers `signMsgWith`,
+  `signSchnorrInternal`, `withXOnlyPubKey`, `withKeyPair` and
+  `verifyFreshSignature`.
+
+### Changed
+
+- The package creates a single libsecp256k1 context the first time a function
+  needs one, randomizes it once, and uses it for every call in the process.
+  After its creation it is only read, so it is safe to use from any number of
+  threads. It is never randomized again, because that modifies the context
+  and is a data race with any thread that is using it, and it is never
+  destroyed. It is kept in a hidden module, so no code outside the package
+  can reach it.
+- `Show`, `Read` and `IsString`, and `pubKey`, `sig` and `recSig`, use the
+  global context instead of a separate one for validation.
+- The test suite compiles the sources of the library itself instead of
+  depending on the library, so that it can still test the raw bindings in the
+  hidden modules.
+
+### Migrating
+
+- Delete the code that made a context: `createContext`, `withContext` and
+  `cloneContext`, and any `Ctx` you kept in a record, a reader environment or
+  a function argument.
+- Delete the context argument from every call: `signMsg ctx key m` becomes
+  `signMsg key m`.
+- Delete calls to `randomizeContext`. There is no replacement: the context is
+  randomized once, when it is created.
+- What is no longer possible: a context per thread or per use, and
+  re-randomizing during a long run. Results do not depend on either.
+
+## [2.1.0] - 2026-11-07
+
+### Changed
+
+- `show` of a `SecKey` prints `SecKey <redacted>` instead of the key in hex,
+  so that a record which holds a key and derives `Show` can be logged or put
+  in an error message without revealing it. `Read` and `IsString` still parse
+  hex, so `read (show key)` no longer gives the key back. Use `get` to write
+  a key out.
+
 ## [2.0.1] - 2026-11-07
 
 ### Changed
diff --git a/README.md b/README.md
--- a/README.md
+++ b/README.md
@@ -58,9 +58,12 @@
   computation.
 - **Never abort the process.** By default libsecp256k1 calls `abort()` on an
   illegal argument, which kills the whole Haskell program and cannot be caught.
-  Every context this package creates installs a callback that makes the C
-  function fail instead, so a bad argument becomes `Nothing`, `False` or an
-  exception.
+  The context of this package installs a callback that makes the C function
+  fail instead, so a bad argument becomes `Nothing`, `False` or an exception.
+- **No context to carry.** libsecp256k1 wants a context object in every call.
+  The package keeps one for the whole process, randomized once and never
+  modified again, and passes it itself. No function takes a context. See
+  [Contexts](#contexts).
 - **Pure where the mathematics is pure.** Signing with deterministic nonces,
   verifying, deriving and tweaking keys are pure functions. Only operations
   that need fresh randomness run in `IO`.
@@ -84,7 +87,7 @@
 | Taproot (BIP-341)    | Tweaking an x-only public key and its secret key                                               |
 | Key arithmetic       | Add or multiply secret and public keys by a tweak, negate, combine public keys                 |
 | Recovery             | Recoverable ECDSA signatures and public key recovery, as Bitcoin signed messages use           |
-| Safety               | Validated values, no aborts, length checks before every C call, contexts shared across threads |
+| Safety               | Validated values, no aborts, length checks before every C call, one read-only context for all threads |
 | Testing              | QuickCheck `Arbitrary` instances for secret keys, hashes and tweaks                            |
 
 ### What is not included
@@ -155,7 +158,7 @@
 
    ```yaml
    extra-deps:
-     - secp256k1-haskell-2.0.1
+     - secp256k1-haskell-3.0.0
      - base16-2.0
    ```
 
@@ -182,23 +185,21 @@
 
 main :: IO ()
 main = do
-  ctx <- createContext
-
   -- Hex literals go through IsString, which validates them.
   let key = "c7e5a2b4f4c5d7e8a9b0c1d2e3f405162738495a6b7c8d9e0f1a2b3c4d5e6f70" :: SecKey
       hash = "4b688df40bcedbe641ddb16ff0a1842d9c67ea1c3bf63f3e0471baa664531d1a" :: Msg
-      pub = derivePubKey ctx key
+      pub = derivePubKey key
 
   -- ECDSA
-  let s = signMsg ctx key hash
-  print (verifySig ctx pub s hash)
+  let s = signMsg key hash
+  print (verifySig pub s hash)
 
   -- BIP-340 Schnorr, with fresh auxiliary randomness
-  schnorr <- signSchnorrIO ctx key hash
-  print (verifySchnorr ctx pub schnorr hash)
+  schnorr <- signSchnorrIO key hash
+  print (verifySchnorr pub schnorr hash)
 
   -- Round trip through the standard encodings
-  let Just pub' = importPubKey ctx (exportPubKey ctx True pub)
+  let Just pub' = importPubKey (exportPubKey True pub)
   print (pub == pub')
 ```
 
@@ -207,16 +208,16 @@
 This walks through what a wallet or a protocol implementation typically does,
 and why each step looks the way it does.
 
-### 1. Create one context and share it
+### 1. Nothing to set up
 
 ```haskell
-ctx <- createContext
+import Crypto.Secp256k1
 ```
 
-A context holds precomputed tables and random blinding values. Creating one is
-relatively expensive, and one context can be used by every thread for the life
-of the program. `createContext` randomizes it once, which is what libsecp256k1
-recommends.
+libsecp256k1 needs a context, which holds random blinding values, but there is
+none to create here. The package makes one the first time a function needs it,
+randomizes it, and uses it for every call from every thread. See
+[Contexts](#contexts).
 
 ### 2. Get keys from bytes
 
@@ -239,7 +240,7 @@
 
 ```haskell
 let Just m = msg hashBytes
-    s = signMsgLowR ctx key m -- or signMsg for plain RFC 6979
+    s = signMsgLowR key m -- or signMsg for plain RFC 6979
 ```
 
 Signing is deterministic: the same key and hash give the same signature, so
@@ -251,19 +252,19 @@
 internal layout. Use the standard encodings:
 
 ```haskell
-let pubBytes = exportPubKey ctx True pub -- 33-byte compressed SEC1
-    derBytes = exportSig ctx s -- DER, as in Bitcoin transactions
-    compactBytes = exportCompactSig ctx s -- 64 bytes r || s
+let pubBytes = exportPubKey True pub -- 33-byte compressed SEC1
+    derBytes = exportSig s -- DER, as in Bitcoin transactions
+    compactBytes = exportCompactSig s -- 64 bytes r || s
 ```
 
 ### 5. Parse and verify what you receive
 
 ```haskell
 verified = fromMaybe False $ do
-  pub <- importPubKey ctx pubBytes
-  s <- importSig ctx derBytes
+  pub <- importPubKey pubBytes
+  s <- importSig derBytes
   m <- msg hashBytes
-  return (verifySig ctx pub (normalizeSig ctx s) m)
+  return (verifySig pub (normalizeSig s) m)
 ```
 
 Every import returns `Maybe`, so malformed input is handled in one place.
@@ -275,9 +276,9 @@
 ### 6. Move to Schnorr where the protocol allows
 
 ```haskell
-sig <- signSchnorrIO ctx key m
-let ok = verifySchnorr ctx pub sig m
-    xonly = exportXOnlyPubKey ctx pub -- 32 bytes, as BIP-340 publishes keys
+sig <- signSchnorrIO key m
+let ok = verifySchnorr pub sig m
+    xonly = exportXOnlyPubKey pub -- 32 bytes, as BIP-340 publishes keys
 ```
 
 Schnorr signatures are always 64 bytes, are not malleable, and are what Taproot
@@ -301,14 +302,37 @@
 
 Here n is the order of the curve. The raw constructors are hidden, so these
 are the only ways to build values. Each type has a `get` field with its bytes.
+`Show` prints hex, except for `SecKey`, which it redacts. See
+[Security notes](#security-notes).
 
 ### Contexts
 
-Every operation takes a `Ctx`. It is created once, shared freely between
-threads, and destroyed by the garbage collector. The only operation that
-modifies a context is `randomizeContext`, which needs exclusive access; most
-programs never call it.
+There is no context in the API. libsecp256k1 needs a context object for every
+call, which holds its error callbacks and the random blinding values that
+protect secret key operations against side channels. The package keeps a
+single global one:
 
+- **Created on first use.** The first call that needs it creates it, once per
+  process, even when several threads arrive together. That call is slower
+  than the following ones by the time it takes to create the context and
+  read 32 bytes from the operating system's secure random source.
+- **Randomized once.** It is seeded with those bytes before it is used, as
+  libsecp256k1 recommends. Blinding changes how the computation runs, not its
+  results.
+- **Never re-randomized.** After its creation the context is only read, so
+  any number of threads can use it without a lock. Randomizing again writes
+  to it, and doing that while another thread signs is a data race in the C
+  library. So there is no function for it, and the context is in a hidden
+  module where no other code can reach it. The package exposes no way to
+  create another context either.
+- **Never destroyed.** It lives as long as the process.
+
+What was given up: before version 3.0.0 the caller created contexts and
+passed one to every function, which allowed a context per thread or per use
+and re-randomizing during a long run. Neither is possible now. See the
+[changelog](https://github.com/jprupp/secp256k1-haskell/blob/master/CHANGELOG.md)
+for how to migrate.
+
 ### Errors
 
 Parsing and constructing return `Maybe`. Arithmetic that can produce an
@@ -322,18 +346,18 @@
 ### Lower-S and low-R
 
 ```haskell
-isLowS ctx s -- the form verifySig accepts
-isLowR ctx s -- r below 2^255, so DER is at most 70 bytes
-normalizeSig ctx s -- the lower-S form of any signature
+isLowS s -- the form verifySig accepts
+isLowR s -- r below 2^255, so DER is at most 70 bytes
+normalizeSig s -- the lower-S form of any signature
 ```
 
 ### Key tweaking
 
 ```haskell
 let Just t = tweak tweakBytes
-    Just childKey = tweakAddSecKey ctx parentKey t
-    Just childPub = tweakAddPubKey ctx parentPub t
--- derivePubKey ctx childKey == childPub
+    Just childKey = tweakAddSecKey parentKey t
+    Just childPub = tweakAddPubKey parentPub t
+-- derivePubKey childKey == childPub
 ```
 
 This is the operation behind BIP-32 derivation; the tweak itself comes from an
@@ -345,8 +369,8 @@
 
 ```haskell
 let Just t = tweak taprootTweakBytes -- tagged hash of key and script tree
-    Just outputKey = tweakAddXOnlyPubKey ctx internalKey t
-    Just outputSecKey = tweakAddXOnlySecKey ctx internalSecKey t
+    Just outputKey = tweakAddXOnlyPubKey internalKey t
+    Just outputSecKey = tweakAddXOnlySecKey internalSecKey t
 ```
 
 Computing the tweak, a BIP-341 tagged hash, is left to the caller.
@@ -356,22 +380,22 @@
 ```haskell
 import Crypto.Secp256k1.Recovery
 
-let r = signRecMsg ctx key m
-    (compact, recId) = exportCompactRecSig ctx r
+let r = signRecMsg key m
+    (compact, recId) = exportCompactRecSig r
 -- the 65-byte message signature is a header byte (27 + recId, + 4 if the key
 -- is compressed) followed by the 64 compact bytes
-recover ctx r m -- Just the signer's PubKey
+recover r m -- Just the signer's PubKey
 ```
 
 ### Testing with QuickCheck
 
 `SecKey`, `Msg` and `Tweak` have `Arbitrary` instances, so properties can
-range over them directly. With a context `ctx` created once for the test suite:
+range over them directly:
 
 ```haskell
 prop_roundTrip :: SecKey -> Msg -> Bool
 prop_roundTrip key m =
-  verifySig ctx (derivePubKey ctx key) (signMsg ctx key m) m
+  verifySig (derivePubKey key) (signMsg key m) m
 ```
 
 ## Differences from Bitcoin Core
@@ -389,18 +413,29 @@
 
 | Module                                  | Contents                                                  |
 | --------------------------------------- | --------------------------------------------------------- |
-| `Crypto.Secp256k1`                      | The public API: contexts, keys, ECDSA, Schnorr, tweaks    |
+| `Crypto.Secp256k1`                      | The public API: keys, ECDSA, Schnorr, tweaks              |
 | `Crypto.Secp256k1.Recovery`             | Recoverable signatures and public key recovery            |
-| `Crypto.Secp256k1.Internal.*`           | Raw constructors and foreign imports; no stability promise |
+| `Crypto.Secp256k1.Internal.*`           | Raw constructors and helpers; no stability promise        |
 
+The exposed internal modules are `Base`, `Recovery`, `ForeignTypes` and
+`Util`. The modules that hold the global context (`Context`), create contexts
+(`ContextOps`) or bind the C functions, which all take a context (`BaseOps`,
+`RecoveryOps`), are hidden. Nothing a program can import makes, takes or names
+a context, so the raw foreign imports cannot be called from outside the
+package. The tests reach them by compiling the sources of the library
+themselves.
+
 ## Security notes
 
 - **Secret keys stay in memory.** A `SecKey` is an ordinary `ByteString`. The
   garbage collector may copy it, and nothing clears it when it is no longer
   used. If your threat model includes an attacker reading process memory,
   keep keys in a hardware device instead.
-- **`Show` prints secret keys.** Showing a record that holds a `SecKey`, in a
-  log line or an error message, reveals it.
+- **`Show` redacts secret keys.** `show` on a `SecKey` gives `SecKey <redacted>`,
+  so a record that holds a key and derives `Show` can go in a log line or an
+  error message. Only `Show` is redacted. `get` gives the bytes, and `Read`
+  and `IsString` parse hex, so a key you write out yourself is yours to
+  protect.
 - **Verification only proves what was signed.** It is your protocol's job to
   hash the right data; signing a hash an attacker chose is as good as signing
   whatever they want.
diff --git a/Setup.hs b/Setup.hs
--- a/Setup.hs
+++ b/Setup.hs
@@ -1,2 +1,3 @@
 import Distribution.Simple
+
 main = defaultMain
diff --git a/secp256k1-haskell.cabal b/secp256k1-haskell.cabal
--- a/secp256k1-haskell.cabal
+++ b/secp256k1-haskell.cabal
@@ -5,7 +5,7 @@
 -- see: https://github.com/sol/hpack
 
 name:           secp256k1-haskell
-version:        2.0.1
+version:        3.0.0
 synopsis:       Bindings for secp256k1
 description:    Sign and verify signatures using the secp256k1 library.
 category:       Crypto
@@ -33,11 +33,13 @@
   exposed-modules:
       Crypto.Secp256k1
       Crypto.Secp256k1.Internal.Base
-      Crypto.Secp256k1.Internal.BaseOps
-      Crypto.Secp256k1.Internal.Context
       Crypto.Secp256k1.Internal.ForeignTypes
       Crypto.Secp256k1.Internal.Util
       Paths_secp256k1_haskell
+  other-modules:
+      Crypto.Secp256k1.Internal.BaseOps
+      Crypto.Secp256k1.Internal.Context
+      Crypto.Secp256k1.Internal.ContextOps
   autogen-modules:
       Paths_secp256k1_haskell
   hs-source-dirs:
@@ -60,8 +62,9 @@
   if flag(recovery)
     exposed-modules:
         Crypto.Secp256k1.Internal.Recovery
-        Crypto.Secp256k1.Internal.RecoveryOps
         Crypto.Secp256k1.Recovery
+    other-modules:
+        Crypto.Secp256k1.Internal.RecoveryOps
 
 test-suite spec
   type: exitcode-stdio-1.0
@@ -71,12 +74,24 @@
       Crypto.Secp256k1.InternalSpec
       Crypto.Secp256k1.RecoverySpec
       Crypto.Secp256k1Spec
+      Crypto.Secp256k1
+      Crypto.Secp256k1.Internal.Base
+      Crypto.Secp256k1.Internal.BaseOps
+      Crypto.Secp256k1.Internal.Context
+      Crypto.Secp256k1.Internal.ContextOps
+      Crypto.Secp256k1.Internal.ForeignTypes
+      Crypto.Secp256k1.Internal.Util
       Paths_secp256k1_haskell
   autogen-modules:
       Paths_secp256k1_haskell
   hs-source-dirs:
       test
+      src
   ghc-options: -Wall -threaded -rtsopts -with-rtsopts=-N
+  c-sources:
+      cbits/illegal_callback.c
+  pkgconfig-depends:
+      libsecp256k1 >= 0.2.0
   build-depends:
       HUnit
     , QuickCheck >=2.9.2
@@ -89,9 +104,12 @@
     , hspec
     , monad-par
     , mtl
-    , secp256k1-haskell
     , string-conversions >=0.4
   default-language: Haskell2010
   if flag(recovery)
+    other-modules:
+        Crypto.Secp256k1.Internal.Recovery
+        Crypto.Secp256k1.Internal.RecoveryOps
+        Crypto.Secp256k1.Recovery
     cpp-options: -DRECOVERY
   build-tool-depends: hspec-discover:hspec-discover
diff --git a/src/Crypto/Secp256k1.hs b/src/Crypto/Secp256k1.hs
--- a/src/Crypto/Secp256k1.hs
+++ b/src/Crypto/Secp256k1.hs
@@ -20,14 +20,18 @@
 --   signature, and invalid input is refused at the boundary where it arrives.
 --
 -- * __Never abort.__ The C library calls @abort()@ on an illegal argument by
---   default, which kills the whole Haskell process and cannot be caught. Every
---   context this package creates replaces that callback, so a bad argument
---   becomes 'Nothing', 'False' or an exception instead.
+--   default, which kills the whole Haskell process and cannot be caught. The
+--   context of this package replaces that callback, so a bad argument becomes
+--   'Nothing', 'False' or an exception instead.
 --
+-- * __No context to carry.__ libsecp256k1 wants a context object in every
+--   call. The package keeps one for the whole process and passes it itself,
+--   so no function here takes one. See Contexts below.
+--
 -- * __Pure where the mathematics is pure.__ Signing, verifying and tweaking are
 --   deterministic functions of their inputs, so they are pure functions here.
---   Only the operations that need fresh randomness, such as 'signSchnorrIO'
---   and 'randomizeContext', run in 'IO'.
+--   Only the operations that need fresh randomness, such as 'signSchnorrIO',
+--   run in 'IO'.
 --
 -- * __Standard encodings at the edges.__ Values print and parse in the encodings
 --   other software understands (SEC1, DER, compact, BIP-340), never in the
@@ -61,7 +65,9 @@
 --
 -- 'Show', 'Read' and 'Data.String.IsString' use hex of a standard encoding: compressed
 -- SEC1 for 'PubKey', compact for 'Sig', and the plain bytes for the others.
--- 'Show' prints secret keys. See 'SecKey' for what that means for logging.
+-- The one exception is 'Show' for 'SecKey', which prints @SecKey \<redacted\>@
+-- instead of the key, so that a key never reaches a log by accident. 'Read'
+-- and 'Data.String.IsString' for 'SecKey' still parse hex.
 --
 -- The raw constructors are not exported from this module. They are in
 -- "Crypto.Secp256k1.Internal.Base", which has no API stability guarantee.
@@ -83,10 +89,41 @@
 --
 -- == Contexts
 --
--- Every operation takes a 'Ctx'. Create one with 'createContext' and share it
--- between threads. Only 'randomizeContext' modifies a context and needs
--- exclusive access.
+-- There is no context in this API. libsecp256k1 needs a context object for
+-- every call, which holds its error callbacks and the random blinding values
+-- that protect secret key operations against side-channel leakage. The
+-- package keeps a single global one and uses it for every function.
 --
+-- * __When it is created.__ The first time a function that needs it is
+--   evaluated, and once per process, even when several threads get there
+--   together. Programs that never use the package never pay for it. The first
+--   call is slower than the following ones by the time it takes to create the
+--   context and read 32 bytes from the operating system's secure random
+--   source. If that fails, the call raises an error.
+--
+-- * __Randomized once.__ The context is seeded with those 32 bytes before it
+--   is used, as libsecp256k1 recommends. The blinding changes how the
+--   computation runs, not its results.
+--
+-- * __Never re-randomized.__ After its creation the context is only read,
+--   which is what makes it safe to use from any number of threads without a
+--   lock, and what lets signing stay a pure function. Randomizing again
+--   writes to the context, and doing that while another thread signs is a
+--   data race in the C library. So the package has no function for it, and
+--   the context is in a hidden module where no other code can reach it
+--   either.
+--
+-- * __What was given up.__ Before version 3.0.0 the caller created contexts
+--   with @createContext@ and passed one to every function. That allowed
+--   a context per thread or per use, and re-randomizing one with
+--   @randomizeContext@ during a long run. Both are gone. In exchange, the
+--   argument that carried no information is gone from every signature, a
+--   context can no longer be modified under a thread that is using it, and
+--   instances such as 'Show' and 'Read' use the same randomized context as
+--   everything else.
+--
+-- The context is never destroyed. It lives as long as the process.
+--
 -- == Differences from Bitcoin Core
 --
 -- 'signMsg' is plain RFC 6979 and matches the published test vectors.
@@ -111,14 +148,7 @@
 -- module @Crypto.Secp256k1.Recovery@. It is built when the @recovery@ flag of
 -- the package is on, which is the default.
 module Crypto.Secp256k1
-  ( -- * Context
-    Ctx,
-    withContext,
-    createContext,
-    randomizeContext,
-    cloneContext,
-
-    -- * Messages
+  ( -- * Messages
     Msg (get),
     msg,
 
@@ -182,4 +212,3 @@
 where
 
 import Crypto.Secp256k1.Internal.Base
-import Crypto.Secp256k1.Internal.Context
diff --git a/src/Crypto/Secp256k1/Internal/Base.hs b/src/Crypto/Secp256k1/Internal/Base.hs
--- a/src/Crypto/Secp256k1/Internal/Base.hs
+++ b/src/Crypto/Secp256k1/Internal/Base.hs
@@ -13,6 +13,12 @@
 -- raises an 'Control.Exception.ErrorCall' when the length is wrong, but it does not check the
 -- content. A raw 'PubKey' or 'Sig' with invalid content makes functions
 -- return 'Nothing', 'False' or throw, never abort or read outside a buffer.
+--
+-- No function here takes a context. They all use the single global context
+-- of the package, which is created and randomized the first time one of them
+-- needs it and is only read afterwards. It lives in a hidden module, so it
+-- cannot be reached or modified from outside the package. The Contexts
+-- section of "Crypto.Secp256k1" explains the design.
 module Crypto.Secp256k1.Internal.Base where
 
 import Control.DeepSeq (NFData)
@@ -46,10 +52,9 @@
     xOnlyPubKeySerialize,
     xOnlyPubKeyTweakAdd,
   )
-import Crypto.Secp256k1.Internal.Context (Ctx (..), validationContext)
+import Crypto.Secp256k1.Internal.Context (globalContext)
 import Crypto.Secp256k1.Internal.ForeignTypes
   ( KeyPair96,
-    LCtx,
     SchnorrSig64,
     XOnlyPubKey64,
     compressed,
@@ -86,7 +91,6 @@
     peek,
     poke,
     pokeArray,
-    withForeignPtr,
   )
 import Foreign.C (CUChar)
 import GHC.Generics (Generic)
@@ -143,10 +147,11 @@
 -- | 32-byte secret key as a big-endian number in the range 1 to n−1, where n
 -- is the order of the curve.
 --
--- 'Show', 'Read' and 'IsString' use hex. 'Show' prints the key, so showing a
--- record that holds a key, in a log line or an error message for instance,
--- reveals it. The bytes live in an ordinary 'ByteString', so the garbage
--- collector copies them and nothing ever clears them from memory.
+-- 'Read' and 'IsString' use hex. 'Show' prints @SecKey \<redacted\>@ and never
+-- the key, so a record that holds a key and derives 'Show' can go in a log
+-- line or an error message without revealing it. Read the bytes from @get@
+-- when you mean to write a key out. They live in an ordinary 'ByteString', so
+-- the garbage collector copies them and nothing ever clears them from memory.
 newtype SecKey = SecKey {get :: ByteString}
   deriving (Eq, Generic, Hashable, NFData)
 
@@ -171,15 +176,15 @@
 instance Read PubKey where
   readPrec = parens $ do
     String str <- lexP
-    maybe pfail return $ importPubKey validationContext =<< decodeHex str
+    maybe pfail return $ importPubKey =<< decodeHex str
 
 instance IsString PubKey where
-  fromString = fromMaybe e . (importPubKey validationContext <=< decodeHex)
+  fromString = fromMaybe e . (importPubKey <=< decodeHex)
     where
       e = error "Could not decode public key from hex string"
 
 instance Show PubKey where
-  showsPrec _ = showsHex . exportPubKey validationContext True
+  showsPrec _ = showsHex . exportPubKey True
 
 instance Read Msg where
   readPrec = parens $ do
@@ -205,7 +210,7 @@
       e = error "Could not decode signature from hex string"
 
 instance Show Sig where
-  showsPrec _ = showsHex . (.get) . exportCompactSig validationContext
+  showsPrec _ = showsHex . (.get) . exportCompactSig
 
 instance Read SecKey where
   readPrec = parens $ do
@@ -217,8 +222,19 @@
     where
       e = error "Could not decode secret key from hex string"
 
+-- | Prints @SecKey \<redacted\>@. A secret key reaches 'show' by accident more
+-- often than on purpose: a record that holds one and derives 'Show', an
+-- error message, a debug trace, a REPL. None of those should reveal it.
+--
+-- The placeholder is constant. Showing the public key instead would tell
+-- keys apart, but it needs a point multiplication for every
+-- 'show', and a raw key of invalid content from this module has no public
+-- key. Call 'derivePubKey' and show that when you need to identify a key.
+--
+-- 'Read' is not the inverse of 'Show' for this type. It still parses hex, so
+-- that keys can be written as literals and read from configuration.
 instance Show SecKey where
-  showsPrec _ = showsHex . (.get)
+  showsPrec d _ = showParen (d > 10) $ showString "SecKey <redacted>"
 
 instance Read Tweak where
   readPrec = parens $ do
@@ -259,19 +275,47 @@
 instance Show SchnorrSig where
   showsPrec _ = showsHex . (.get)
 
--- | Parse the 64-byte compact encoding into a 'Sig' without a caller-provided
--- context. Used by the 'Read' and 'IsString' instances.
+-- | Parse the 64-byte compact encoding into a 'Sig'. Used by the 'Read' and
+-- 'IsString' instances.
 sigFromCompactBytes :: ByteString -> Maybe Sig
-sigFromCompactBytes = importCompactSig validationContext <=< compactSig
+sigFromCompactBytes = importCompactSig <=< compactSig
 
 -- | Order of the secp256k1 group, n, as a 32-byte big-endian number.
 curveOrder :: ByteString
 curveOrder =
   BS.pack
-    [ 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
-      0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xfe,
-      0xba, 0xae, 0xdc, 0xe6, 0xaf, 0x48, 0xa0, 0x3b,
-      0xbf, 0xd2, 0x5e, 0x8c, 0xd0, 0x36, 0x41, 0x41
+    [ 0xff,
+      0xff,
+      0xff,
+      0xff,
+      0xff,
+      0xff,
+      0xff,
+      0xff,
+      0xff,
+      0xff,
+      0xff,
+      0xff,
+      0xff,
+      0xff,
+      0xff,
+      0xfe,
+      0xba,
+      0xae,
+      0xdc,
+      0xe6,
+      0xaf,
+      0x48,
+      0xa0,
+      0x3b,
+      0xbf,
+      0xd2,
+      0x5e,
+      0x8c,
+      0xd0,
+      0x36,
+      0x41,
+      0x41
     ]
 
 -- | Thirty-two zero bytes.
@@ -303,20 +347,17 @@
 isCanonicalSig bs =
   BS.length bs == 64
     && unsafePerformIO
-      ( withForeignPtr fctx $ \ctx ->
-          unsafeUseByteString bs $ \(sig_ptr, _) ->
-            allocaBytes 64 $ \compact_ptr -> do
-              ret <- ecdsaSignatureSerializeCompact ctx compact_ptr sig_ptr
-              if not (isSuccess ret)
-                then return False
-                else do
-                  compact <- packByteString (compact_ptr, 64)
-                  parsed <- withOutput 64 $ \out ->
-                    isSuccess <$> ecdsaSignatureParseCompact ctx out compact_ptr
-                  return (parsed == Just bs && hasNonZeroComponents compact)
+      ( unsafeUseByteString bs $ \(sig_ptr, _) ->
+          allocaBytes 64 $ \compact_ptr -> do
+            ret <- ecdsaSignatureSerializeCompact globalContext compact_ptr sig_ptr
+            if not (isSuccess ret)
+              then return False
+              else do
+                compact <- packByteString (compact_ptr, 64)
+                parsed <- withOutput 64 $ \out ->
+                  isSuccess <$> ecdsaSignatureParseCompact globalContext out compact_ptr
+                return (parsed == Just bs && hasNonZeroComponents compact)
       )
-  where
-    Ctx fctx = validationContext
 
 -- | True when neither r nor s of a compact-encoded signature is zero.
 hasNonZeroComponents :: ByteString -> Bool
@@ -344,23 +385,20 @@
 isCanonicalPubKey bs =
   BS.length bs == 64
     && unsafePerformIO
-      ( withForeignPtr fctx $ \ctx ->
-          unsafeUseByteString bs $ \(pub_key_ptr, _) ->
-            alloca $ \len_ptr ->
-              allocaBytes 65 $ \ser_ptr -> do
-                poke len_ptr 65
-                ret <-
-                  ecPubKeySerialize ctx ser_ptr len_ptr pub_key_ptr uncompressed
-                if not (isSuccess ret)
-                  then return False
-                  else do
-                    len <- peek len_ptr
-                    parsed <- withOutput 64 $ \out ->
-                      isSuccess <$> ecPubKeyParse ctx out ser_ptr len
-                    return (parsed == Just bs)
+      ( unsafeUseByteString bs $ \(pub_key_ptr, _) ->
+          alloca $ \len_ptr ->
+            allocaBytes 65 $ \ser_ptr -> do
+              poke len_ptr 65
+              ret <-
+                ecPubKeySerialize globalContext ser_ptr len_ptr pub_key_ptr uncompressed
+              if not (isSuccess ret)
+                then return False
+                else do
+                  len <- peek len_ptr
+                  parsed <- withOutput 64 $ \out ->
+                    isSuccess <$> ecPubKeyParse globalContext out ser_ptr len
+                  return (parsed == Just bs)
       )
-  where
-    Ctx fctx = validationContext
 
 -- | Import a 32-byte message hash.
 msg :: ByteString -> Maybe Msg
@@ -394,53 +432,53 @@
 -- that form is returned unchanged. 'verifySig' only accepts lower-S
 -- signatures, so apply this first to signatures that may come from software
 -- that does not produce them.
-normalizeSig :: Ctx -> Sig -> Sig
-normalizeSig (Ctx fctx) (Sig sig_bs) =
-  unsafePerformIO $ withForeignPtr fctx $ \ctx ->
+normalizeSig :: Sig -> Sig
+normalizeSig (Sig sig_bs) =
+  unsafePerformIO $
     useFixedByteString "Sig" 64 sig_bs $ \(sig_in, _) ->
       -- The return value only says whether s was high. The output is written
       -- in both cases.
-      Sig <$> fillOutput 64 (\sig_out -> () <$ ecdsaSignatureNormalize ctx sig_out sig_in)
+      Sig <$> fillOutput 64 (\sig_out -> () <$ ecdsaSignatureNormalize globalContext sig_out sig_in)
 
 -- | True when the s component is not greater than n/2. This is the form that
 -- 'signMsg' produces and the only form that 'verifySig' accepts.
-isLowS :: Ctx -> Sig -> Bool
-isLowS (Ctx fctx) (Sig sig_bs) =
-  unsafePerformIO $ withForeignPtr fctx $ \ctx ->
+isLowS :: Sig -> Bool
+isLowS (Sig sig_bs) =
+  unsafePerformIO $
     useFixedByteString "Sig" 64 sig_bs $ \(sig_in, _) -> do
       -- With a null output pointer the C function only reports whether s is
       -- high: 1 when it is, 0 when it is not.
-      was_high <- ecdsaSignatureNormalize ctx nullPtr sig_in
+      was_high <- ecdsaSignatureNormalize globalContext nullPtr sig_in
       return (not (isSuccess was_high))
 
 -- | True when the r component is lower than 2^255, which makes the DER
 -- encoding at most 70 bytes. 'signMsgLowR' produces such signatures.
-isLowR :: Ctx -> Sig -> Bool
-isLowR ctx s = BS.index (exportCompactSig ctx s).get 0 < 0x80
+isLowR :: Sig -> Bool
+isLowR s = BS.index (exportCompactSig s).get 0 < 0x80
 
 -- | Parse a public key in SEC1 encoding: 33 bytes compressed (prefix 0x02 or
 -- 0x03), 65 bytes uncompressed (prefix 0x04) or 65 bytes hybrid (prefix 0x06
 -- or 0x07). 'Nothing' when the encoding is wrong or the point is not on the
 -- curve.
-importPubKey :: Ctx -> ByteString -> Maybe PubKey
-importPubKey (Ctx fctx) bs
+importPubKey :: ByteString -> Maybe PubKey
+importPubKey bs
   | BS.null bs = Nothing
   | otherwise =
-      unsafePerformIO $ withForeignPtr fctx $ \ctx ->
+      unsafePerformIO $
         unsafeUseByteString bs $ \(input, len) ->
           (fmap . fmap) PubKey . withOutput 64 $ \pub_key ->
-            isSuccess <$> ecPubKeyParse ctx pub_key input len
+            isSuccess <$> ecPubKeyParse globalContext pub_key input len
 
 -- | Serialize a public key in SEC1 encoding. 'True' for the 33-byte
 -- compressed form, 'False' for the 65-byte uncompressed form.
-exportPubKey :: Ctx -> Bool -> PubKey -> ByteString
-exportPubKey (Ctx fctx) compress (PubKey in_bs) =
-  unsafePerformIO $ withForeignPtr fctx $ \ctx ->
+exportPubKey :: Bool -> PubKey -> ByteString
+exportPubKey compress (PubKey in_bs) =
+  unsafePerformIO $
     useFixedByteString "PubKey" 64 in_bs $ \(in_ptr, _) ->
       alloca $ \len_ptr ->
         allocaBytes len $ \out_ptr -> do
           poke len_ptr $ fromIntegral len
-          ret <- ecPubKeySerialize ctx out_ptr len_ptr in_ptr flags
+          ret <- ecPubKeySerialize globalContext out_ptr len_ptr in_ptr flags
           unless (isSuccess ret) $ error "could not serialize public key"
           final_len <- peek len_ptr
           packByteString (out_ptr, final_len)
@@ -449,12 +487,12 @@
     flags = if compress then compressed else uncompressed
 
 -- | Serialize a signature in the compact encoding.
-exportCompactSig :: Ctx -> Sig -> CompactSig
-exportCompactSig (Ctx fctx) (Sig sig_bs) =
-  unsafePerformIO $ withForeignPtr fctx $ \ctx ->
+exportCompactSig :: Sig -> CompactSig
+exportCompactSig (Sig sig_bs) =
+  unsafePerformIO $
     useFixedByteString "Sig" 64 sig_bs $ \(sig_ptr, _) -> do
       out <- withOutput 64 $ \out_ptr ->
-        isSuccess <$> ecdsaSignatureSerializeCompact ctx out_ptr sig_ptr
+        isSuccess <$> ecdsaSignatureSerializeCompact globalContext out_ptr sig_ptr
       maybe
         (error "could not serialize compact signature")
         (return . CompactSig)
@@ -462,40 +500,40 @@
 
 -- | Parse a signature from the compact encoding. 'Nothing' unless both
 -- components are in the range 1 to n−1. The signature may be in high-S form.
-importCompactSig :: Ctx -> CompactSig -> Maybe Sig
-importCompactSig (Ctx fctx) (CompactSig compact) = do
+importCompactSig :: CompactSig -> Maybe Sig
+importCompactSig (CompactSig compact) = do
   guard (hasNonZeroComponents compact)
-  unsafePerformIO $ withForeignPtr fctx $ \ctx ->
+  unsafePerformIO $
     useFixedByteString "CompactSig" 64 compact $ \(compact_ptr, _) ->
       (fmap . fmap) Sig . withOutput 64 $ \out_sig ->
-        isSuccess <$> ecdsaSignatureParseCompact ctx out_sig compact_ptr
+        isSuccess <$> ecdsaSignatureParseCompact globalContext out_sig compact_ptr
 
 -- | Parse a signature in strict DER encoding. 'Nothing' when the encoding is
 -- not strict DER or when a component is outside the range 1 to n−1. The
 -- signature may be in high-S form.
-importSig :: Ctx -> ByteString -> Maybe Sig
-importSig ctx@(Ctx fctx) bs
+importSig :: ByteString -> Maybe Sig
+importSig bs
   | BS.null bs = Nothing
   | otherwise = do
       parsed <-
-        unsafePerformIO $ withForeignPtr fctx $ \ctx_ptr ->
+        unsafePerformIO $
           unsafeUseByteString bs $ \(in_ptr, in_len) ->
             (fmap . fmap) Sig . withOutput 64 $ \out_sig ->
-              isSuccess <$> ecdsaSignatureParseDer ctx_ptr out_sig in_ptr in_len
+              isSuccess <$> ecdsaSignatureParseDer globalContext out_sig in_ptr in_len
       -- libsecp256k1 parses a component that is not below the curve order as
       -- zero and still reports success. Such a signature can never verify.
-      guard (hasNonZeroComponents (exportCompactSig ctx parsed).get)
+      guard (hasNonZeroComponents (exportCompactSig parsed).get)
       return parsed
 
 -- | Serialize a signature in strict DER encoding (8 to 72 bytes).
-exportSig :: Ctx -> Sig -> ByteString
-exportSig (Ctx fctx) (Sig in_sig) =
-  unsafePerformIO $ withForeignPtr fctx $ \ctx ->
+exportSig :: Sig -> ByteString
+exportSig (Sig in_sig) =
+  unsafePerformIO $
     useFixedByteString "Sig" 64 in_sig $ \(in_ptr, _) ->
       alloca $ \out_len ->
         allocaBytes 72 $ \out_ptr -> do
           poke out_len 72
-          ret <- ecdsaSignatureSerializeDer ctx out_ptr out_len in_ptr
+          ret <- ecdsaSignatureSerializeDer globalContext out_ptr out_len in_ptr
           unless (isSuccess ret) $ error "could not serialize signature"
           final_len <- peek out_len
           packByteString (out_ptr, final_len)
@@ -509,13 +547,13 @@
 -- and therefore its id, without the key. Accepting only one of the two forms
 -- removes that freedom, which is why libsecp256k1 and Bitcoin's relay rules
 -- insist on it.
-verifySig :: Ctx -> PubKey -> Sig -> Msg -> Bool
-verifySig (Ctx fctx) (PubKey pub_key) (Sig sig_bs) (Msg m) =
-  unsafePerformIO $ withForeignPtr fctx $ \ctx ->
+verifySig :: PubKey -> Sig -> Msg -> Bool
+verifySig (PubKey pub_key) (Sig sig_bs) (Msg m) =
+  unsafePerformIO $
     useFixedByteString "PubKey" 64 pub_key $ \(pub_key_ptr, _) ->
       useFixedByteString "Sig" 64 sig_bs $ \(sig_ptr, _) ->
         useFixedByteString "Msg" 32 m $ \(msg_ptr, _) ->
-          isSuccess <$> ecdsaVerify ctx sig_ptr msg_ptr pub_key_ptr
+          isSuccess <$> ecdsaVerify globalContext sig_ptr msg_ptr pub_key_ptr
 
 -- | Sign a message hash. The nonce comes from RFC 6979, so the same key and
 -- hash always give the same signature. The signature is in lower-S form.
@@ -525,16 +563,16 @@
 -- even slightly predictable, reveals the secret key. Deriving it from the key
 -- and the hash, as RFC 6979 does, removes the need for a good random number
 -- generator at signing time.
-signMsg :: Ctx -> SecKey -> Msg -> Sig
-signMsg ctx key m = signMsgWith ctx key m Nothing
+signMsg :: SecKey -> Msg -> Sig
+signMsg key m = signMsgWith key m Nothing
 
 -- | Sign a message hash with RFC 6979 and 32 bytes of extra nonce data (RFC
 -- 6979 section 3.6), or without extra data for 'Nothing', which is the same as
 -- 'signMsg'. The data must be exactly 32 bytes long. This is the primitive
 -- behind 'signMsgLowR'.
-signMsgWith :: Ctx -> SecKey -> Msg -> Maybe ByteString -> Sig
-signMsgWith (Ctx fctx) (SecKey sec_key) (Msg m) nonce_data =
-  unsafePerformIO $ withForeignPtr fctx $ \ctx ->
+signMsgWith :: SecKey -> Msg -> Maybe ByteString -> Sig
+signMsgWith (SecKey sec_key) (Msg m) nonce_data =
+  unsafePerformIO $
     useFixedByteString "SecKey" 32 sec_key $ \(sec_key_ptr, _) ->
       useFixedByteString "Msg" 32 m $ \(msg_ptr, _) ->
         withNonceData $ \data_ptr -> do
@@ -542,7 +580,7 @@
           -- receives the extra data.
           out <- withOutput 64 $ \sig_ptr ->
             isSuccess
-              <$> ecdsaSign ctx sig_ptr msg_ptr sec_key_ptr nullFunPtr data_ptr
+              <$> ecdsaSign globalContext sig_ptr msg_ptr sec_key_ptr nullFunPtr data_ptr
           maybe (error "could not sign message") (return . Sig) out
   where
     withNonceData f = case nonce_data of
@@ -559,15 +597,15 @@
 -- Use it where the size of a signature matters, as in Bitcoin transactions,
 -- where every byte costs a fee, or where signatures must match Bitcoin Core's
 -- byte for byte. Use 'signMsg' where the RFC 6979 test vectors must hold.
-signMsgLowR :: Ctx -> SecKey -> Msg -> Sig
-signMsgLowR ctx key m = go 0 (signMsg ctx key m)
+signMsgLowR :: SecKey -> Msg -> Sig
+signMsgLowR key m = go 0 (signMsg key m)
   where
     go :: Word32 -> Sig -> Sig
     go counter s
-      | isLowR ctx s = s
+      | isLowR s = s
       | otherwise =
           let next = counter + 1
-           in go next (signMsgWith ctx key m (Just (counterData next)))
+           in go next (signMsgWith key m (Just (counterData next)))
     counterData c =
       BS.pack (map (fromIntegral . (c `shiftR`)) [0, 8, 16, 24])
         <> BS.replicate 28 0
@@ -576,12 +614,12 @@
 --
 -- It is a pure function and cannot fail, because a 'SecKey' is valid by
 -- construction.
-derivePubKey :: Ctx -> SecKey -> PubKey
-derivePubKey (Ctx fctx) (SecKey sec_key) =
-  unsafePerformIO $ withForeignPtr fctx $ \ctx ->
+derivePubKey :: SecKey -> PubKey
+derivePubKey (SecKey sec_key) =
+  unsafePerformIO $
     useFixedByteString "SecKey" 32 sec_key $ \(sec_key_ptr, _) -> do
       out <- withOutput 64 $ \pub_key_ptr ->
-        isSuccess <$> ecPubKeyCreate ctx pub_key_ptr sec_key_ptr
+        isSuccess <$> ecPubKeyCreate globalContext pub_key_ptr sec_key_ptr
       maybe (error "could not compute public key") (return . PubKey) out
 
 -- | Add a tweak to a secret key: @key + tweak mod n@. 'Nothing' when the
@@ -592,56 +630,56 @@
 -- parent key plus a tweak, and Taproot outputs are an internal key plus a
 -- tweak. 'tweakAddPubKey' does the same on the public side, which is what lets
 -- a watch-only wallet derive addresses without any secret.
-tweakAddSecKey :: Ctx -> SecKey -> Tweak -> Maybe SecKey
-tweakAddSecKey (Ctx fctx) (SecKey sec_key) (Tweak t) =
-  unsafePerformIO $ withForeignPtr fctx $ \ctx ->
+tweakAddSecKey :: SecKey -> Tweak -> Maybe SecKey
+tweakAddSecKey (SecKey sec_key) (Tweak t) =
+  unsafePerformIO $
     useFixedByteString "Tweak" 32 t $ \(tweak_ptr, _) ->
       (fmap . fmap) SecKey . withCopy "SecKey" 32 sec_key $ \sec_key_ptr ->
-        isSuccess <$> ecSecKeyTweakAdd ctx sec_key_ptr tweak_ptr
+        isSuccess <$> ecSecKeyTweakAdd globalContext sec_key_ptr tweak_ptr
 
 -- | Multiply a secret key by a tweak: @key * tweak mod n@. 'Nothing' when the
 -- tweak is zero.
-tweakMulSecKey :: Ctx -> SecKey -> Tweak -> Maybe SecKey
-tweakMulSecKey (Ctx fctx) (SecKey sec_key) (Tweak t) =
-  unsafePerformIO $ withForeignPtr fctx $ \ctx ->
+tweakMulSecKey :: SecKey -> Tweak -> Maybe SecKey
+tweakMulSecKey (SecKey sec_key) (Tweak t) =
+  unsafePerformIO $
     useFixedByteString "Tweak" 32 t $ \(tweak_ptr, _) ->
       (fmap . fmap) SecKey . withCopy "SecKey" 32 sec_key $ \sec_key_ptr ->
-        isSuccess <$> ecSecKeyTweakMul ctx sec_key_ptr tweak_ptr
+        isSuccess <$> ecSecKeyTweakMul globalContext sec_key_ptr tweak_ptr
 
 -- | Add a tweak to a public key: @key + tweak * G@. 'Nothing' when the result
 -- would be the point at infinity, which happens when the tweak is the negation
 -- of the secret key.
-tweakAddPubKey :: Ctx -> PubKey -> Tweak -> Maybe PubKey
-tweakAddPubKey (Ctx fctx) (PubKey pub_key) (Tweak t) =
-  unsafePerformIO $ withForeignPtr fctx $ \ctx ->
+tweakAddPubKey :: PubKey -> Tweak -> Maybe PubKey
+tweakAddPubKey (PubKey pub_key) (Tweak t) =
+  unsafePerformIO $
     useFixedByteString "Tweak" 32 t $ \(tweak_ptr, _) ->
       (fmap . fmap) PubKey . withCopy "PubKey" 64 pub_key $ \pub_key_ptr ->
-        isSuccess <$> ecPubKeyTweakAdd ctx pub_key_ptr tweak_ptr
+        isSuccess <$> ecPubKeyTweakAdd globalContext pub_key_ptr tweak_ptr
 
 -- | Multiply a public key by a tweak: @tweak * key@. 'Nothing' when the tweak
 -- is zero.
-tweakMulPubKey :: Ctx -> PubKey -> Tweak -> Maybe PubKey
-tweakMulPubKey (Ctx fctx) (PubKey pub_key) (Tweak t) =
-  unsafePerformIO $ withForeignPtr fctx $ \ctx ->
+tweakMulPubKey :: PubKey -> Tweak -> Maybe PubKey
+tweakMulPubKey (PubKey pub_key) (Tweak t) =
+  unsafePerformIO $
     useFixedByteString "Tweak" 32 t $ \(tweak_ptr, _) ->
       (fmap . fmap) PubKey . withCopy "PubKey" 64 pub_key $ \pub_key_ptr ->
-        isSuccess <$> ecPubKeyTweakMul ctx pub_key_ptr tweak_ptr
+        isSuccess <$> ecPubKeyTweakMul globalContext pub_key_ptr tweak_ptr
 
 -- | Add public keys together. 'Nothing' for an empty list, when a key is not
 -- a valid point, or when the sum is the point at infinity.
-combinePubKeys :: Ctx -> [PubKey] -> Maybe PubKey
-combinePubKeys _ [] = Nothing
-combinePubKeys (Ctx fctx) pubs
+combinePubKeys :: [PubKey] -> Maybe PubKey
+combinePubKeys [] = Nothing
+combinePubKeys pubs
   -- @secp256k1_ec_pubkey_combine@ ignores whether each key loads, so an
   -- invalid key would be added as if it were a point.
   | not (all isValidPoint pubs) = Nothing
   | otherwise =
-      unsafePerformIO $ withForeignPtr fctx $ \ctx ->
+      unsafePerformIO $
         withPointers pubs $ \ps ->
           allocaArray (length ps) $ \arr -> do
             pokeArray arr ps
             (fmap . fmap) PubKey . withOutput 64 $ \out ->
-              isSuccess <$> ecPubKeyCombine ctx out arr (fromIntegral (length ps))
+              isSuccess <$> ecPubKeyCombine globalContext out arr (fromIntegral (length ps))
   where
     -- A raw key of the wrong length is a programming error, like everywhere
     -- else. A raw key of the right length that is not a point gives Nothing.
@@ -656,13 +694,13 @@
 -- | Negate a tweak modulo the curve order: @n − tweak@, or zero for zero.
 -- Adding a tweak and then its negation gives the original key back.
 -- 'Nothing' only for a raw 'Tweak' that is not below the curve order.
-tweakNegate :: Ctx -> Tweak -> Maybe Tweak
-tweakNegate (Ctx fctx) (Tweak t)
+tweakNegate :: Tweak -> Maybe Tweak
+tweakNegate (Tweak t)
   | t == zero32 = Just (Tweak t)
   | otherwise =
-      unsafePerformIO $ withForeignPtr fctx $ \ctx ->
+      unsafePerformIO $
         (fmap . fmap) Tweak . withCopy "Tweak" 32 t $ \out ->
-          isSuccess <$> ecTweakNegate ctx out
+          isSuccess <$> ecTweakNegate globalContext out
 
 -- * Schnorr signatures (BIP-340)
 
@@ -677,42 +715,42 @@
 -- coordinate and drops the parity of y. 'Nothing' if the key does not load
 -- as a point.
 withXOnlyPubKey ::
-  Ptr LCtx -> ByteString -> (Ptr XOnlyPubKey64 -> IO a) -> IO (Maybe a)
-withXOnlyPubKey ctx pub_key f =
+  ByteString -> (Ptr XOnlyPubKey64 -> IO a) -> IO (Maybe a)
+withXOnlyPubKey pub_key f =
   useFixedByteString "PubKey" 64 pub_key $ \(pub_key_ptr, _) ->
     allocaBytes 64 $ \xonly_ptr -> do
-      ret <- xOnlyPubKeyFromPubKey ctx xonly_ptr nullPtr pub_key_ptr
+      ret <- xOnlyPubKeyFromPubKey globalContext xonly_ptr nullPtr pub_key_ptr
       if isSuccess ret then Just <$> f xonly_ptr else return Nothing
 
 -- | Run an action with the key pair of a secret key. 'Nothing' if the secret
 -- key is not valid. The key pair holds the secret key, so its buffer is
 -- zeroed when the action is done, whether it returns or throws.
 withKeyPair ::
-  Ptr LCtx -> ByteString -> (Ptr KeyPair96 -> IO a) -> IO (Maybe a)
-withKeyPair ctx sec_key f =
+  ByteString -> (Ptr KeyPair96 -> IO a) -> IO (Maybe a)
+withKeyPair sec_key f =
   useFixedByteString "SecKey" 32 sec_key $ \(sec_key_ptr, _) ->
     allocaBytes 96 $ \key_pair -> do
       let create = do
-            ret <- keyPairCreate ctx key_pair sec_key_ptr
+            ret <- keyPairCreate globalContext key_pair sec_key_ptr
             if isSuccess ret then Just <$> f key_pair else return Nothing
       create `finally` fillBytes key_pair 0 96
 
 -- | Import a 32-byte BIP-340 x-only public key: the x coordinate of a point.
 -- The result is the point with that x coordinate and an even y coordinate,
 -- as BIP-340 defines. 'Nothing' if no point has that x coordinate.
-importXOnlyPubKey :: Ctx -> ByteString -> Maybe PubKey
-importXOnlyPubKey ctx bs
-  | BS.length bs == 32 = importPubKey ctx (BS.cons 0x02 bs)
+importXOnlyPubKey :: ByteString -> Maybe PubKey
+importXOnlyPubKey bs
+  | BS.length bs == 32 = importPubKey (BS.cons 0x02 bs)
   | otherwise = Nothing
 
 -- | Export a public key as a 32-byte BIP-340 x-only public key: its x
 -- coordinate. A key and its negation have the same x-only form.
-exportXOnlyPubKey :: Ctx -> PubKey -> ByteString
-exportXOnlyPubKey (Ctx fctx) (PubKey pub_key) =
-  unsafePerformIO $ withForeignPtr fctx $ \ctx -> do
-    out <- withXOnlyPubKey ctx pub_key $ \xonly_ptr ->
+exportXOnlyPubKey :: PubKey -> ByteString
+exportXOnlyPubKey (PubKey pub_key) =
+  unsafePerformIO $ do
+    out <- withXOnlyPubKey pub_key $ \xonly_ptr ->
       fillOutput 32 $ \out_ptr -> do
-        ret <- xOnlyPubKeySerialize ctx out_ptr xonly_ptr
+        ret <- xOnlyPubKeySerialize globalContext out_ptr xonly_ptr
         unless (isSuccess ret) $ error "could not serialize x-only public key"
     maybe (error "could not serialize x-only public key") return out
 
@@ -724,39 +762,39 @@
 --
 -- As BIP-340 requires, the signature is verified before it is returned, and
 -- an error is raised if that fails.
-signSchnorr :: Ctx -> SecKey -> Msg -> SchnorrSig
-signSchnorr ctx key m = signSchnorrInternal ctx key m Nothing
+signSchnorr :: SecKey -> Msg -> SchnorrSig
+signSchnorr key m = signSchnorrInternal key m Nothing
 
 -- | Sign a message hash with BIP-340 and the given 32 bytes of auxiliary
 -- randomness. 'Nothing' if the randomness is not 32 bytes long. The
 -- signature is verified before it is returned, as in 'signSchnorr'.
-signSchnorrWithAux :: Ctx -> SecKey -> Msg -> ByteString -> Maybe SchnorrSig
-signSchnorrWithAux ctx key m aux
-  | BS.length aux == 32 = Just (signSchnorrInternal ctx key m (Just aux))
+signSchnorrWithAux :: SecKey -> Msg -> ByteString -> Maybe SchnorrSig
+signSchnorrWithAux key m aux
+  | BS.length aux == 32 = Just (signSchnorrInternal key m (Just aux))
   | otherwise = Nothing
 
 -- | Sign a message hash with BIP-340 and fresh auxiliary randomness from the
 -- system, as BIP-340 recommends. The signature is different each time. It is
 -- verified before it is returned, as in 'signSchnorr'.
-signSchnorrIO :: (MonadIO m) => Ctx -> SecKey -> Msg -> m SchnorrSig
-signSchnorrIO ctx key m = liftIO $ do
+signSchnorrIO :: (MonadIO m) => SecKey -> Msg -> m SchnorrSig
+signSchnorrIO key m = liftIO $ do
   aux <- getEntropy 32
-  evaluate (signSchnorrInternal ctx key m (Just aux))
+  evaluate (signSchnorrInternal key m (Just aux))
 
 -- | Sign with optional auxiliary randomness, then verify the signature with
 -- the key pair that made it. BIP-340 makes that check the last step of
 -- signing, so that a signature corrupted by a fault in the signer never
 -- leaves it. Bitcoin Core does the same.
-signSchnorrInternal :: Ctx -> SecKey -> Msg -> Maybe ByteString -> SchnorrSig
-signSchnorrInternal (Ctx fctx) (SecKey sec_key) (Msg m) aux =
-  unsafePerformIO $ withForeignPtr fctx $ \ctx ->
+signSchnorrInternal :: SecKey -> Msg -> Maybe ByteString -> SchnorrSig
+signSchnorrInternal (SecKey sec_key) (Msg m) aux =
+  unsafePerformIO $
     useFixedByteString "Msg" 32 m $ \(msg_ptr, _) ->
       withAux $ \aux_ptr -> do
-        out <- withKeyPair ctx sec_key $ \key_pair ->
+        out <- withKeyPair sec_key $ \key_pair ->
           withOutput 64 $ \sig_ptr -> do
-            ret <- schnorrSigSign32 ctx sig_ptr msg_ptr key_pair aux_ptr
+            ret <- schnorrSigSign32 globalContext sig_ptr msg_ptr key_pair aux_ptr
             if isSuccess ret
-              then verifyFreshSignature ctx key_pair sig_ptr (castPtr msg_ptr)
+              then verifyFreshSignature key_pair sig_ptr (castPtr msg_ptr)
               else return False
         case out of
           Nothing -> error "could not sign message"
@@ -770,24 +808,24 @@
 -- | Verify a signature that a key pair just made, with the x-only public key
 -- of that key pair. The message is 32 bytes.
 verifyFreshSignature ::
-  Ptr LCtx -> Ptr KeyPair96 -> Ptr SchnorrSig64 -> Ptr CUChar -> IO Bool
-verifyFreshSignature ctx key_pair sig_ptr msg_ptr =
+  Ptr KeyPair96 -> Ptr SchnorrSig64 -> Ptr CUChar -> IO Bool
+verifyFreshSignature key_pair sig_ptr msg_ptr =
   allocaBytes 64 $ \xonly_ptr -> do
-    ret <- keyPairXOnlyPub ctx xonly_ptr nullPtr key_pair
+    ret <- keyPairXOnlyPub globalContext xonly_ptr nullPtr key_pair
     if isSuccess ret
-      then isSuccess <$> schnorrSigVerify ctx sig_ptr msg_ptr 32 xonly_ptr
+      then isSuccess <$> schnorrSigVerify globalContext sig_ptr msg_ptr 32 xonly_ptr
       else return False
 
 -- | Verify a BIP-340 signature of a message hash. Only the x coordinate of
 -- the public key is used, so a key and its negation verify the same
 -- signatures. 'True' means that the signature is correct.
-verifySchnorr :: Ctx -> PubKey -> SchnorrSig -> Msg -> Bool
-verifySchnorr (Ctx fctx) (PubKey pub_key) (SchnorrSig sig_bs) (Msg m) =
-  unsafePerformIO $ withForeignPtr fctx $ \ctx ->
+verifySchnorr :: PubKey -> SchnorrSig -> Msg -> Bool
+verifySchnorr (PubKey pub_key) (SchnorrSig sig_bs) (Msg m) =
+  unsafePerformIO $
     useFixedByteString "SchnorrSig" 64 sig_bs $ \(sig_ptr, _) ->
       useFixedByteString "Msg" 32 m $ \(msg_ptr, msg_len) ->
-        fmap (fromMaybe False) . withXOnlyPubKey ctx pub_key $ \xonly_ptr ->
-          isSuccess <$> schnorrSigVerify ctx sig_ptr msg_ptr msg_len xonly_ptr
+        fmap (fromMaybe False) . withXOnlyPubKey pub_key $ \xonly_ptr ->
+          isSuccess <$> schnorrSigVerify globalContext sig_ptr msg_ptr msg_len xonly_ptr
 
 -- | Add a tweak to the x-only form of a public key: @P + t·G@, where @P@ is
 -- the point with the key's x coordinate and an even y coordinate. This is
@@ -796,29 +834,28 @@
 -- of its y coordinate goes into the control block of a script path spend.
 -- 'Nothing' if the result is the point at infinity, or for a raw 'Tweak' that
 -- is not below the curve order.
-tweakAddXOnlyPubKey :: Ctx -> PubKey -> Tweak -> Maybe PubKey
-tweakAddXOnlyPubKey (Ctx fctx) (PubKey pub_key) (Tweak t) =
-  unsafePerformIO $ withForeignPtr fctx $ \ctx ->
+tweakAddXOnlyPubKey :: PubKey -> Tweak -> Maybe PubKey
+tweakAddXOnlyPubKey (PubKey pub_key) (Tweak t) =
+  unsafePerformIO $
     useFixedByteString "Tweak" 32 t $ \(tweak_ptr, _) ->
-      fmap join . withXOnlyPubKey ctx pub_key $ \xonly_ptr ->
+      fmap join . withXOnlyPubKey pub_key $ \xonly_ptr ->
         (fmap . fmap) PubKey . withOutput 64 $ \out ->
-          isSuccess <$> xOnlyPubKeyTweakAdd ctx out xonly_ptr tweak_ptr
+          isSuccess <$> xOnlyPubKeyTweakAdd globalContext out xonly_ptr tweak_ptr
 
 -- | Add a tweak to a secret key the way 'tweakAddXOnlyPubKey' adds it to the
 -- public key: the secret key is negated first when its public key has an odd
 -- y coordinate, then the tweak is added. The result signs for the Taproot
 -- output of 'tweakAddXOnlyPubKey' in a key path spend. 'Nothing' if the
 -- result is zero, or for a raw 'Tweak' that is not below the curve order.
-tweakAddXOnlySecKey :: Ctx -> SecKey -> Tweak -> Maybe SecKey
-tweakAddXOnlySecKey (Ctx fctx) (SecKey sec_key) (Tweak t) =
-  unsafePerformIO $ withForeignPtr fctx $ \ctx ->
+tweakAddXOnlySecKey :: SecKey -> Tweak -> Maybe SecKey
+tweakAddXOnlySecKey (SecKey sec_key) (Tweak t) =
+  unsafePerformIO $
     useFixedByteString "Tweak" 32 t $ \(tweak_ptr, _) ->
-      fmap join . withKeyPair ctx sec_key $ \key_pair -> do
-        ret <- keyPairXOnlyTweakAdd ctx key_pair tweak_ptr
+      fmap join . withKeyPair sec_key $ \key_pair -> do
+        ret <- keyPairXOnlyTweakAdd globalContext key_pair tweak_ptr
         if isSuccess ret
-          then
-            (fmap . fmap) SecKey . withOutput 32 $ \out ->
-              isSuccess <$> keyPairSec ctx out key_pair
+          then (fmap . fmap) SecKey . withOutput 32 $ \out ->
+            isSuccess <$> keyPairSec globalContext out key_pair
           else return Nothing
 
 instance Arbitrary Msg where
diff --git a/src/Crypto/Secp256k1/Internal/BaseOps.hs b/src/Crypto/Secp256k1/Internal/BaseOps.hs
--- a/src/Crypto/Secp256k1/Internal/BaseOps.hs
+++ b/src/Crypto/Secp256k1/Internal/BaseOps.hs
@@ -5,15 +5,19 @@
 -- bindings are @safe@ calls: signing and verifying take tens of microseconds,
 -- and a @safe@ call lets other Haskell threads run meanwhile. Never call these
 -- directly with unchecked inputs; "Crypto.Secp256k1.Internal.Base" validates
--- lengths and contents first. This module is internal and has no API
--- stability guarantee.
+-- lengths and contents first.
+--
+-- Every function takes a context pointer, and the package passes its global
+-- context. Because of that argument this module is hidden: the package
+-- exposes nothing that makes, takes or names a context. Only the package
+-- itself and its tests can call these bindings.
 module Crypto.Secp256k1.Internal.BaseOps where
 
+import Crypto.Secp256k1.Internal.ContextOps (LCtx)
 import Crypto.Secp256k1.Internal.ForeignTypes
   ( AuxRand32,
     Compact64,
     KeyPair96,
-    LCtx,
     Msg32,
     NonceFun,
     PubKey64,
diff --git a/src/Crypto/Secp256k1/Internal/Context.hs b/src/Crypto/Secp256k1/Internal/Context.hs
--- a/src/Crypto/Secp256k1/Internal/Context.hs
+++ b/src/Crypto/Secp256k1/Internal/Context.hs
@@ -1,160 +1,99 @@
-{-# LANGUAGE NoFieldSelectors #-}
-
--- | Internal module. Everything is exported and there is no API stability
--- guarantee. In particular 'contextDestroy' is here for add-on packages and
--- tests that manage raw context pointers. Never call it on the pointer inside
--- a 'Ctx', because the garbage collector will destroy that one again.
-module Crypto.Secp256k1.Internal.Context where
+-- | The one libsecp256k1 context of the process.
+--
+-- == Purpose
+--
+-- Every function of libsecp256k1 takes a context: an object that holds the
+-- callbacks for errors and the random blinding values that protect secret key
+-- operations against side-channel leakage. Earlier versions of this package
+-- made the caller create one and pass it to every function. That argument
+-- carried no information, since any context gives the same results, yet it
+-- ran through every signature of every program built on the package. Now the
+-- package keeps a single context here and uses it for everything.
+--
+-- == Design
+--
+-- * __Created on first use.__ 'globalContext' is a top-level value, so the
+--   runtime evaluates it once, the first time a function needs it, and every
+--   later use gets the same pointer. 'unsafePerformIO' takes a lock on the
+--   value while it runs (@unsafeDupablePerformIO@ does not), so two threads
+--   that arrive together cannot both create a context. The @NOINLINE@ pragma
+--   keeps the compiler from copying the definition to its uses, which would
+--   make a context per use.
+--
+-- * __Randomized once, then read-only.__ The context is seeded with 32 bytes
+--   from the operating system before anything else can see it, which is what
+--   libsecp256k1 recommends. After that nothing writes to it, and the C
+--   library allows any number of threads to read one context at once. This is
+--   why there is no way to randomize it again: that writes to the context
+--   while other threads may be reading it, which is a data race, and guarding
+--   against it would put a lock around every operation.
+--
+-- * __Never aborts.__ The illegal-argument callback is replaced with one that
+--   does nothing (see @cbits/illegal_callback.c@), so an invalid argument
+--   makes a C function return 0 instead of aborting the process. Two rules
+--   follow for every binding that uses the context. The return value of the C
+--   function must always be checked, because after a failed check its outputs
+--   are undefined. And a C function that ignores the result of an internal
+--   check must get validated inputs, as 'Crypto.Secp256k1.combinePubKeys'
+--   does for @secp256k1_ec_pubkey_combine@.
+--
+-- * __Never destroyed.__ The context lives as long as the process, like any
+--   other global, so it has no finalizer. The operating system reclaims it at
+--   exit.
+--
+-- * __Hidden.__ This module is not exposed by the package. If the pointer
+--   could be reached from outside, any code could randomize or destroy the
+--   context, or change its callbacks, under every other user of it. The
+--   modules with the raw bindings, which take a context pointer, and the one
+--   that creates contexts are hidden as well, so no code outside the package
+--   can make, hold or name a context at all.
+--
+-- == What is given up
+--
+-- A program can no longer have several contexts, for example one per thread
+-- or one per secret, and it can no longer refresh the blinding during a long
+-- run. Neither changes any result. The blinding is defence in depth on top
+-- of code that is already constant-time, and seeding it once per process is
+-- what the C library asks for.
+module Crypto.Secp256k1.Internal.Context (globalContext) where
 
-import Control.Exception (mask_)
-import Control.Monad (unless)
-import Crypto.Secp256k1.Internal.ForeignTypes
-  ( CtxFlags,
-    LCtx,
-    Ret,
-    Seed32,
-    isSuccess,
+import Control.Exception (mask_, onException)
+import Control.Monad (unless, when)
+import Crypto.Secp256k1.Internal.ContextOps
+  ( LCtx,
+    contextCreate,
+    contextDestroy,
+    contextRandomize,
+    illegalCallbackFunPtr,
+    setIllegalCallback,
+    signVerify,
   )
+import Crypto.Secp256k1.Internal.ForeignTypes (isSuccess)
 import Crypto.Secp256k1.Internal.Util (withRandomSeed)
-import Foreign (FunPtr, Ptr, nullPtr)
-import Foreign.C (CInt (..), CString, CUInt (..))
-import Foreign.ForeignPtr
-  ( ForeignPtr,
-    newForeignPtr,
-    withForeignPtr,
-  )
+import Foreign (Ptr, nullPtr)
 import System.IO.Unsafe (unsafePerformIO)
 
--- | A libsecp256k1 context. It is destroyed by the garbage collector.
+-- | The context that every binding of the package uses. It is created,
+-- given the illegal-argument callback that does nothing, and randomized the
+-- first time it is needed, and it is only read from then on, so any number of
+-- threads may use it at once. See the module header for why it is built this
+-- way.
 --
--- A context can be shared between threads. Every function in
--- "Crypto.Secp256k1" only reads it, except 'randomizeContext', which needs
--- exclusive access. See there.
-data Ctx = Ctx (ForeignPtr LCtx)
-
--- | Re-seed the blinding values that protect secret key operations against
--- side-channel leakage. 'createContext' already does this once, which is what
--- libsecp256k1 recommends, so most programs never need to call it.
+-- Bindings must only pass it to C functions that take a @const@ context.
+-- Never pass it to @secp256k1_context_randomize@,
+-- @secp256k1_context_destroy@ or a function that sets a callback.
 --
--- This function modifies the context. Calling it while another thread uses
--- the same context, for example by evaluating 'Crypto.Secp256k1.signMsg', is a
--- data race in the C library. Either call it before the context is shared, or
--- protect every use of the context with a read-write lock.
-randomizeContext :: Ctx -> IO ()
-randomizeContext (Ctx fctx) = withForeignPtr fctx $ \ctx -> do
-  ret <- withRandomSeed $ contextRandomize ctx
-  unless (isSuccess ret) $ error "Could not randomize context"
-
--- | Create a context and randomize it.
-createContext :: IO Ctx
-createContext = do
-  ctx <- mask_ $ contextCreate signVerify >>= wrapContext
-  randomizeContext ctx
+-- If the context cannot be created or randomized, for example because the
+-- operating system gives no entropy, the error is raised by the function that
+-- needed the context, and again by every later one.
+globalContext :: Ptr LCtx
+globalContext = unsafePerformIO . mask_ $ do
+  ctx <- contextCreate signVerify
+  when (ctx == nullPtr) $ error "Could not create secp256k1 context"
+  setIllegalCallback ctx illegalCallbackFunPtr nullPtr
+  ret <- withRandomSeed (contextRandomize ctx) `onException` contextDestroy ctx
+  unless (isSuccess ret) $ do
+    contextDestroy ctx
+    error "Could not randomize secp256k1 context"
   return ctx
-
--- | Copy a context, including its randomization.
-cloneContext :: Ctx -> IO Ctx
-cloneContext (Ctx fctx) =
-  withForeignPtr fctx $ \ctx -> mask_ $ contextClone ctx >>= wrapContext
-
--- | Create a context and pass it to the action. The context is not destroyed
--- when the action returns. It stays valid for as long as it is referenced,
--- and the garbage collector destroys it afterwards.
-withContext :: (Ctx -> IO a) -> IO a
-withContext = (createContext >>=)
-
--- | Wrap a raw context pointer. The illegal-argument callback is replaced
--- with one that does nothing (see @cbits/illegal_callback.c@), so an invalid
--- argument makes the C function return 0 instead of aborting the process.
---
--- Two rules follow for every binding that uses a 'Ctx'. The return value of
--- the C function must always be checked, because after a failed check its
--- outputs are undefined. And a C function that ignores the result of an
--- internal check must get validated inputs, as
--- 'Crypto.Secp256k1.combinePubKeys' does for @secp256k1_ec_pubkey_combine@.
-wrapContext :: Ptr LCtx -> IO Ctx
-wrapContext pctx = do
-  setIllegalCallback pctx illegalCallbackFunPtr nullPtr
-  Ctx <$> newForeignPtr contextDestroyFunPtr pctx
-
--- | Context used to validate values that are built without a context, such
--- as public keys and signatures read from their internal representation or
--- from a string. It is only used for parsing and serialization, which do not
--- involve secret keys and so do not need randomization. It is never modified
--- after creation, so sharing it between threads is safe.
-validationContext :: Ctx
-validationContext =
-  unsafePerformIO . mask_ $ contextCreate none >>= wrapContext
-{-# NOINLINE validationContext #-}
-
--- | @SECP256K1_CONTEXT_NONE@. Enough for every operation since libsecp256k1
--- 0.2.0, and for parsing and serialization in older versions.
-none :: CtxFlags
-none = 0x0001
-
--- | @SECP256K1_CONTEXT_VERIFY@. Deprecated upstream since 0.2.0, where it
--- means the same as 'none'. Older libraries need it to verify.
-verify :: CtxFlags
-verify = 0x0101
-
--- | @SECP256K1_CONTEXT_SIGN@. Deprecated upstream since 0.2.0, where it means
--- the same as 'none'. Older libraries need it to sign.
-sign :: CtxFlags
-sign = 0x0201
-
--- | Both 'sign' and 'verify', passed by 'createContext'. The package requires
--- libsecp256k1 0.2.0 or later for its Schnorr bindings, and from that version
--- on these flags mean the same as 'none'. Passing them is harmless.
-signVerify :: CtxFlags
-signVerify = 0x0301
-
--- | Binding to @secp256k1_context_create@.
-foreign import ccall safe "secp256k1.h secp256k1_context_create"
-  contextCreate ::
-    CtxFlags ->
-    IO (Ptr LCtx)
-
--- | Binding to @secp256k1_context_clone@.
-foreign import ccall safe "secp256k1.h secp256k1_context_clone"
-  contextClone ::
-    Ptr LCtx ->
-    IO (Ptr LCtx)
-
--- | Binding to @secp256k1_context_destroy@.
-foreign import ccall safe "secp256k1.h secp256k1_context_destroy"
-  contextDestroy :: Ptr LCtx -> IO ()
-
--- | Pointer to @secp256k1_context_destroy@, for use as a finalizer or callback.
-foreign import ccall safe "secp256k1.h &secp256k1_context_destroy"
-  contextDestroyFunPtr :: FunPtr (Ptr LCtx -> IO ())
-
--- | Pointer to @secp256k1_haskell_illegal_callback@, for use as a finalizer or callback.
-foreign import ccall safe "&secp256k1_haskell_illegal_callback"
-  illegalCallbackFunPtr :: FunPtr (CString -> Ptr a -> IO ())
-
--- | Binding to @secp256k1_context_set_illegal_callback@.
-foreign import ccall safe "secp256k1.h secp256k1_context_set_illegal_callback"
-  setIllegalCallback ::
-    Ptr LCtx ->
-    -- | message, data
-    FunPtr (CString -> Ptr a -> IO ()) ->
-    -- | data
-    Ptr a ->
-    IO ()
-
--- | Binding to @secp256k1_context_set_error_callback@.
-foreign import ccall safe "secp256k1.h secp256k1_context_set_error_callback"
-  setErrorCallback ::
-    Ptr LCtx ->
-    -- | message, data
-    FunPtr (CString -> Ptr a -> IO ()) ->
-    -- | data
-    Ptr a ->
-    IO ()
-
--- | Binding to @secp256k1_context_randomize@.
-foreign import ccall safe "secp256k1.h secp256k1_context_randomize"
-  contextRandomize ::
-    Ptr LCtx ->
-    Ptr Seed32 ->
-    IO Ret
+{-# NOINLINE globalContext #-}
diff --git a/src/Crypto/Secp256k1/Internal/ContextOps.hs b/src/Crypto/Secp256k1/Internal/ContextOps.hs
new file mode 100644
--- /dev/null
+++ b/src/Crypto/Secp256k1/Internal/ContextOps.hs
@@ -0,0 +1,107 @@
+-- | Foreign imports for creating and managing libsecp256k1 contexts, and the
+-- flags they take.
+--
+-- The package needs these only once, to make its global context in
+-- "Crypto.Secp256k1.Internal.Context". The tests also use them, to exercise
+-- the raw bindings of "Crypto.Secp256k1.Internal.BaseOps" on contexts of
+-- their own.
+--
+-- This module is hidden: the package does not expose it, nor any other
+-- module that makes, takes or names a context. The owner's decision is that
+-- the one global context is the only context there is, so the library offers
+-- no way to create another. The price is that code outside the package can
+-- no longer call the raw bindings; it uses the validated functions of
+-- "Crypto.Secp256k1" instead.
+--
+-- 'contextRandomize' and the two callback setters modify a context, so they
+-- need exclusive access to it. They must never be given the global context
+-- after its creation.
+module Crypto.Secp256k1.Internal.ContextOps where
+
+import Crypto.Secp256k1.Internal.ForeignTypes (Ret, Seed32)
+import Foreign (FunPtr, Ptr)
+import Foreign.C (CInt (..), CString, CUInt (..))
+
+-- | Context (@secp256k1_context@). Only ever used behind a 'Ptr'. It is
+-- declared here and not with the other foreign types so that no exposed
+-- module can name a context.
+data LCtx
+
+-- | Flags passed to @secp256k1_context_create@.
+type CtxFlags = CUInt
+
+-- | @SECP256K1_CONTEXT_NONE@. Enough for every operation since libsecp256k1
+-- 0.2.0, and for parsing and serialization in older versions.
+none :: CtxFlags
+none = 0x0001
+
+-- | @SECP256K1_CONTEXT_VERIFY@. Deprecated upstream since 0.2.0, where it
+-- means the same as 'none'. Older libraries need it to verify.
+verify :: CtxFlags
+verify = 0x0101
+
+-- | @SECP256K1_CONTEXT_SIGN@. Deprecated upstream since 0.2.0, where it means
+-- the same as 'none'. Older libraries need it to sign.
+sign :: CtxFlags
+sign = 0x0201
+
+-- | Both 'sign' and 'verify', which the global context of the package is
+-- created with. The package requires libsecp256k1 0.2.0 or later for its
+-- Schnorr bindings, and from that version on these flags mean the same as
+-- 'none'. Passing them is harmless.
+signVerify :: CtxFlags
+signVerify = 0x0301
+
+-- | Binding to @secp256k1_context_create@.
+foreign import ccall safe "secp256k1.h secp256k1_context_create"
+  contextCreate ::
+    CtxFlags ->
+    IO (Ptr LCtx)
+
+-- | Binding to @secp256k1_context_clone@.
+foreign import ccall safe "secp256k1.h secp256k1_context_clone"
+  contextClone ::
+    Ptr LCtx ->
+    IO (Ptr LCtx)
+
+-- | Binding to @secp256k1_context_destroy@.
+foreign import ccall safe "secp256k1.h secp256k1_context_destroy"
+  contextDestroy :: Ptr LCtx -> IO ()
+
+-- | Pointer to @secp256k1_context_destroy@, for use as a finalizer or callback.
+foreign import ccall safe "secp256k1.h &secp256k1_context_destroy"
+  contextDestroyFunPtr :: FunPtr (Ptr LCtx -> IO ())
+
+-- | Pointer to @secp256k1_haskell_illegal_callback@ (see
+-- @cbits/illegal_callback.c@), a callback that does nothing. Set as the
+-- illegal-argument callback of a context, it makes a C function that is given
+-- an invalid argument return 0 instead of aborting the process.
+foreign import ccall safe "&secp256k1_haskell_illegal_callback"
+  illegalCallbackFunPtr :: FunPtr (CString -> Ptr a -> IO ())
+
+-- | Binding to @secp256k1_context_set_illegal_callback@.
+foreign import ccall safe "secp256k1.h secp256k1_context_set_illegal_callback"
+  setIllegalCallback ::
+    Ptr LCtx ->
+    -- | message, data
+    FunPtr (CString -> Ptr a -> IO ()) ->
+    -- | data
+    Ptr a ->
+    IO ()
+
+-- | Binding to @secp256k1_context_set_error_callback@.
+foreign import ccall safe "secp256k1.h secp256k1_context_set_error_callback"
+  setErrorCallback ::
+    Ptr LCtx ->
+    -- | message, data
+    FunPtr (CString -> Ptr a -> IO ()) ->
+    -- | data
+    Ptr a ->
+    IO ()
+
+-- | Binding to @secp256k1_context_randomize@.
+foreign import ccall safe "secp256k1.h secp256k1_context_randomize"
+  contextRandomize ::
+    Ptr LCtx ->
+    Ptr Seed32 ->
+    IO Ret
diff --git a/src/Crypto/Secp256k1/Internal/ForeignTypes.hs b/src/Crypto/Secp256k1/Internal/ForeignTypes.hs
--- a/src/Crypto/Secp256k1/Internal/ForeignTypes.hs
+++ b/src/Crypto/Secp256k1/Internal/ForeignTypes.hs
@@ -10,9 +10,6 @@
 import Foreign (Ptr)
 import Foreign.C (CInt (..), CUChar, CUInt (..))
 
--- | Context (@secp256k1_context@).
-data LCtx
-
 -- | Public key (@secp256k1_pubkey@), 64 bytes.
 data PubKey64
 
@@ -48,9 +45,6 @@
 
 -- | Auxiliary randomness for BIP-340 signing, 32 bytes.
 data AuxRand32
-
--- | Flags passed to @secp256k1_context_create@.
-type CtxFlags = CUInt
 
 -- | Flags passed to @secp256k1_ec_pubkey_serialize@.
 type SerFlags = CUInt
diff --git a/src/Crypto/Secp256k1/Internal/Recovery.hs b/src/Crypto/Secp256k1/Internal/Recovery.hs
--- a/src/Crypto/Secp256k1/Internal/Recovery.hs
+++ b/src/Crypto/Secp256k1/Internal/Recovery.hs
@@ -16,6 +16,9 @@
 -- does not check the content. A raw 'RecSig' with invalid content makes
 -- functions return 'Nothing', a value that does not verify, or throw, never
 -- abort or read outside a buffer.
+--
+-- As in "Crypto.Secp256k1.Internal.Base", every function uses the global
+-- context of the package and none takes one.
 module Crypto.Secp256k1.Internal.Recovery where
 
 import Control.DeepSeq (NFData)
@@ -28,7 +31,7 @@
     Sig (..),
     hasNonZeroComponents,
   )
-import Crypto.Secp256k1.Internal.Context (Ctx (..), validationContext)
+import Crypto.Secp256k1.Internal.Context (globalContext)
 import Crypto.Secp256k1.Internal.ForeignTypes (isSuccess)
 import Crypto.Secp256k1.Internal.RecoveryOps
   ( ecdsaRecover,
@@ -51,7 +54,7 @@
 import Data.Maybe (fromMaybe)
 import Data.String (IsString (..))
 import Data.Word (Word8)
-import Foreign (alloca, allocaBytes, nullFunPtr, nullPtr, peek, withForeignPtr)
+import Foreign (alloca, allocaBytes, nullFunPtr, nullPtr, peek)
 import GHC.Generics (Generic)
 import System.IO.Unsafe (unsafePerformIO)
 import Text.Read
@@ -96,14 +99,14 @@
 recSigToEncoding :: RecSig -> ByteString
 recSigToEncoding rs = compact.get `BS.snoc` rec_id
   where
-    (compact, rec_id) = exportCompactRecSig validationContext rs
+    (compact, rec_id) = exportCompactRecSig rs
 
--- | Parse the 65-byte encoding of 'recSigToEncoding' without a
--- caller-provided context. Used by the 'Read' and 'IsString' instances.
+-- | Parse the 65-byte encoding of 'recSigToEncoding'. Used by the 'Read' and
+-- 'IsString' instances.
 recSigFromEncoding :: ByteString -> Maybe RecSig
 recSigFromEncoding bs = do
   guard (BS.length bs == 65)
-  importCompactRecSig validationContext (CompactSig (BS.take 64 bs)) (BS.last bs)
+  importCompactRecSig (CompactSig (BS.take 64 bs)) (BS.last bs)
 
 -- | Import a recoverable signature from the bytes of its internal
 -- representation, as found in the @get@ field of a 'RecSig' on the same
@@ -127,43 +130,40 @@
 isCanonicalRecSig bs =
   BS.length bs == 65
     && unsafePerformIO
-      ( withForeignPtr fctx $ \ctx ->
-          unsafeUseByteString bs $ \(rec_sig_ptr, _) ->
-            allocaBytes 64 $ \compact_ptr ->
-              alloca $ \rec_id_ptr -> do
-                ret <-
-                  ecdsaRecoverableSignatureSerializeCompact
-                    ctx
-                    compact_ptr
-                    rec_id_ptr
-                    rec_sig_ptr
-                if not (isSuccess ret)
-                  then return False
-                  else do
-                    rec_id <- peek rec_id_ptr
-                    compact <- packByteString (compact_ptr, 64)
-                    parsed <- withOutput 65 $ \out ->
-                      isSuccess
-                        <$> ecdsaRecoverableSignatureParseCompact ctx out compact_ptr rec_id
-                    return (parsed == Just bs && hasNonZeroComponents compact)
+      ( unsafeUseByteString bs $ \(rec_sig_ptr, _) ->
+          allocaBytes 64 $ \compact_ptr ->
+            alloca $ \rec_id_ptr -> do
+              ret <-
+                ecdsaRecoverableSignatureSerializeCompact
+                  globalContext
+                  compact_ptr
+                  rec_id_ptr
+                  rec_sig_ptr
+              if not (isSuccess ret)
+                then return False
+                else do
+                  rec_id <- peek rec_id_ptr
+                  compact <- packByteString (compact_ptr, 64)
+                  parsed <- withOutput 65 $ \out ->
+                    isSuccess
+                      <$> ecdsaRecoverableSignatureParseCompact globalContext out compact_ptr rec_id
+                  return (parsed == Just bs && hasNonZeroComponents compact)
       )
-  where
-    Ctx fctx = validationContext
 
 -- | Sign a message hash and keep the recovery id. The nonce comes from RFC
 -- 6979, so the same key and hash always give the same signature, and r and s
 -- are those of 'Crypto.Secp256k1.signMsg', in lower-S form. There is no low-R
 -- grinding. Bitcoin Core does not grind when it signs a message with
 -- @SignCompact@ either, so the signatures are the same as Bitcoin Core's.
-signRecMsg :: Ctx -> SecKey -> Msg -> RecSig
-signRecMsg (Ctx fctx) (SecKey sec_key) (Msg m) =
-  unsafePerformIO $ withForeignPtr fctx $ \ctx ->
+signRecMsg :: SecKey -> Msg -> RecSig
+signRecMsg (SecKey sec_key) (Msg m) =
+  unsafePerformIO $
     useFixedByteString "SecKey" 32 sec_key $ \(sec_key_ptr, _) ->
       useFixedByteString "Msg" 32 m $ \(msg_ptr, _) -> do
         -- A null nonce function selects the RFC 6979 default.
         out <- withOutput 65 $ \rec_sig_ptr ->
           isSuccess
-            <$> ecdsaSignRecoverable ctx rec_sig_ptr msg_ptr sec_key_ptr nullFunPtr nullPtr
+            <$> ecdsaSignRecoverable globalContext rec_sig_ptr msg_ptr sec_key_ptr nullFunPtr nullPtr
         maybe (error "could not sign message") (return . RecSig) out
 
 -- | The public key that made a signature of a message hash. 'Nothing' when no
@@ -176,51 +176,51 @@
 -- same key. Bitcoin Core accepts such message signatures too. Where the rule
 -- matters, check 'Crypto.Secp256k1.isLowS' on 'convertRecSig'. The hash is
 -- reduced modulo the curve order, as 'Crypto.Secp256k1.verifySig' does.
-recover :: Ctx -> RecSig -> Msg -> Maybe PubKey
-recover (Ctx fctx) (RecSig rec_sig) (Msg m) =
-  unsafePerformIO $ withForeignPtr fctx $ \ctx ->
+recover :: RecSig -> Msg -> Maybe PubKey
+recover (RecSig rec_sig) (Msg m) =
+  unsafePerformIO $
     useFixedByteString "RecSig" 65 rec_sig $ \(rec_sig_ptr, _) ->
       useFixedByteString "Msg" 32 m $ \(msg_ptr, _) ->
         (fmap . fmap) PubKey . withOutput 64 $ \pub_key_ptr ->
-          isSuccess <$> ecdsaRecover ctx pub_key_ptr rec_sig_ptr msg_ptr
+          isSuccess <$> ecdsaRecover globalContext pub_key_ptr rec_sig_ptr msg_ptr
 
 -- | The signature without its recovery id. For a signature from
 -- 'signRecMsg', this is the signature that 'Crypto.Secp256k1.signMsg' gives.
-convertRecSig :: Ctx -> RecSig -> Sig
-convertRecSig (Ctx fctx) (RecSig rec_sig) =
-  unsafePerformIO $ withForeignPtr fctx $ \ctx ->
+convertRecSig :: RecSig -> Sig
+convertRecSig (RecSig rec_sig) =
+  unsafePerformIO $
     useFixedByteString "RecSig" 65 rec_sig $ \(rec_sig_ptr, _) -> do
       out <- withOutput 64 $ \sig_ptr ->
-        isSuccess <$> ecdsaRecoverableSignatureConvert ctx sig_ptr rec_sig_ptr
+        isSuccess <$> ecdsaRecoverableSignatureConvert globalContext sig_ptr rec_sig_ptr
       maybe (error "could not convert recoverable signature") (return . Sig) out
 
 -- | Parse a signature from the compact encoding and its recovery id.
 -- 'Nothing' unless both components are in the range 1 to n−1 and the id is 0
 -- to 3. The signature may be in high-S form.
-importCompactRecSig :: Ctx -> CompactSig -> Word8 -> Maybe RecSig
-importCompactRecSig (Ctx fctx) (CompactSig compact) rec_id = do
+importCompactRecSig :: CompactSig -> Word8 -> Maybe RecSig
+importCompactRecSig (CompactSig compact) rec_id = do
   guard (rec_id <= 3)
   -- libsecp256k1 accepts a zero component here and only refuses it in
   -- 'recover'. It is rejected here so that 'convertRecSig' always gives a
   -- valid 'Sig', as 'Crypto.Secp256k1.importCompactSig' does.
   guard (hasNonZeroComponents compact)
-  unsafePerformIO $ withForeignPtr fctx $ \ctx ->
+  unsafePerformIO $
     useFixedByteString "CompactSig" 64 compact $ \(compact_ptr, _) ->
       (fmap . fmap) RecSig . withOutput 65 $ \out ->
         isSuccess
-          <$> ecdsaRecoverableSignatureParseCompact ctx out compact_ptr (fromIntegral rec_id)
+          <$> ecdsaRecoverableSignatureParseCompact globalContext out compact_ptr (fromIntegral rec_id)
 
 -- | Serialize a signature to the compact encoding and its recovery id. The
 -- header byte of a Bitcoin signed message is 27 plus the id, plus 4 for a
 -- compressed key, which the caller adds.
-exportCompactRecSig :: Ctx -> RecSig -> (CompactSig, Word8)
-exportCompactRecSig (Ctx fctx) (RecSig rec_sig) =
-  unsafePerformIO $ withForeignPtr fctx $ \ctx ->
+exportCompactRecSig :: RecSig -> (CompactSig, Word8)
+exportCompactRecSig (RecSig rec_sig) =
+  unsafePerformIO $
     useFixedByteString "RecSig" 65 rec_sig $ \(rec_sig_ptr, _) ->
       alloca $ \rec_id_ptr -> do
         out <- withOutput 64 $ \compact_ptr ->
           isSuccess
-            <$> ecdsaRecoverableSignatureSerializeCompact ctx compact_ptr rec_id_ptr rec_sig_ptr
+            <$> ecdsaRecoverableSignatureSerializeCompact globalContext compact_ptr rec_id_ptr rec_sig_ptr
         case out of
           Nothing -> error "could not serialize recoverable signature"
           Just compact -> do
diff --git a/src/Crypto/Secp256k1/Internal/RecoveryOps.hs b/src/Crypto/Secp256k1/Internal/RecoveryOps.hs
--- a/src/Crypto/Secp256k1/Internal/RecoveryOps.hs
+++ b/src/Crypto/Secp256k1/Internal/RecoveryOps.hs
@@ -2,11 +2,15 @@
 -- library only has when it was built with @--enable-module-recovery@. See
 -- "Crypto.Secp256k1.Recovery". This module is only built when the @recovery@
 -- flag of the package is on.
+--
+-- Like "Crypto.Secp256k1.Internal.BaseOps", it is hidden, because every
+-- binding takes a context pointer and the package exposes nothing that makes,
+-- takes or names a context.
 module Crypto.Secp256k1.Internal.RecoveryOps where
 
+import Crypto.Secp256k1.Internal.ContextOps (LCtx)
 import Crypto.Secp256k1.Internal.ForeignTypes
   ( Compact64,
-    LCtx,
     Msg32,
     NonceFun,
     PubKey64,
diff --git a/test/Crypto/Secp256k1/Fixtures.hs b/test/Crypto/Secp256k1/Fixtures.hs
--- a/test/Crypto/Secp256k1/Fixtures.hs
+++ b/test/Crypto/Secp256k1/Fixtures.hs
@@ -13,6 +13,7 @@
 import Data.String (fromString)
 
 -- * Fixtures
+
 --
 -- Every expected value is a literal from an independent source: the secp256k1
 -- generator, the RFC 6979 vector for key 1 and sha256 "Satoshi Nakamoto",
@@ -124,5 +125,5 @@
 quoted s = "\"" ++ s ++ "\""
 
 -- The negation of a public key: multiplication by n - 1.
-negatePubKey :: Ctx -> PubKey -> PubKey
-negatePubKey ctx p = fromJust (tweakMulPubKey ctx p (fromString orderMinusOne))
+negatePubKey :: PubKey -> PubKey
+negatePubKey p = fromJust (tweakMulPubKey p (fromString orderMinusOne))
diff --git a/test/Crypto/Secp256k1/InternalSpec.hs b/test/Crypto/Secp256k1/InternalSpec.hs
--- a/test/Crypto/Secp256k1/InternalSpec.hs
+++ b/test/Crypto/Secp256k1/InternalSpec.hs
@@ -6,7 +6,7 @@
 import Control.Monad
 import Control.Monad.Trans
 import Crypto.Secp256k1.Internal.BaseOps
-import Crypto.Secp256k1.Internal.Context
+import Crypto.Secp256k1.Internal.ContextOps
 import Crypto.Secp256k1.Internal.ForeignTypes
 import Crypto.Secp256k1.Internal.Util
 import Data.Base16.Types (assertBase16)
diff --git a/test/Crypto/Secp256k1/RecoverySpec.hs b/test/Crypto/Secp256k1/RecoverySpec.hs
--- a/test/Crypto/Secp256k1/RecoverySpec.hs
+++ b/test/Crypto/Secp256k1/RecoverySpec.hs
@@ -33,7 +33,7 @@
 import Text.Read (readMaybe)
 
 spec :: Spec
-spec = around withContext $ describe "public key recovery" $ do
+spec = describe "public key recovery" $ do
   signingSpec
   recoverySpec
   formulaSpec
@@ -130,161 +130,161 @@
 
 -- * Signing
 
-signingSpec :: SpecWith Ctx
+signingSpec :: Spec
 signingSpec = describe "signing" $ do
-  it "produces Bitcoin Core's SignCompact signature of sha256d 'Very deterministic message'" $ \ctx ->
-    exportCompactRecSig ctx (signRecMsg ctx coreKey coreMsg)
+  it "produces Bitcoin Core's SignCompact signature of sha256d 'Very deterministic message'" $
+    exportCompactRecSig (signRecMsg coreKey coreMsg)
       `shouldBe` (fromString (coreR ++ coreS), coreRecId)
-  it "produces Bitcoin Core's signmessage signature of 'Trust no one'" $ \ctx ->
-    exportCompactRecSig ctx (signRecMsg ctx messageKey messageHash)
+  it "produces Bitcoin Core's signmessage signature of 'Trust no one'" $
+    exportCompactRecSig (signRecMsg messageKey messageHash)
       `shouldBe` (fromString (messageR ++ messageS), 1)
-  it "produces the RFC 6979 vector with recovery id 1" $ \ctx ->
-    exportCompactRecSig ctx (signRecMsg ctx keyOne satoshiMsg)
+  it "produces the RFC 6979 vector with recovery id 1" $
+    exportCompactRecSig (signRecMsg keyOne satoshiMsg)
       `shouldBe` (fromString (satoshiR ++ satoshiS), 1)
-  it "keeps a high r, as Bitcoin Core's message signing does" $ \ctx -> do
-    exportCompactRecSig ctx (signRecMsg ctx keyOne highRMsg)
+  it "keeps a high r, as Bitcoin Core's message signing does" $ do
+    exportCompactRecSig (signRecMsg keyOne highRMsg)
       `shouldBe` (fromString (highRR ++ highRS), 0)
-    convertRecSig ctx (signRecMsg ctx keyOne highRMsg) `shouldNotBe` signMsgLowR ctx keyOne highRMsg
-  it "signs with the r and s of signMsg" $ \ctx ->
-    property $ \(m :: Msg, k :: SecKey) -> convertRecSig ctx (signRecMsg ctx k m) == signMsg ctx k m
-  it "is deterministic" $ \ctx ->
-    property $ \(m :: Msg, k :: SecKey) -> signRecMsg ctx k m == signRecMsg ctx k m
-  it "gives a recovery id of 0 or 1" $ \ctx ->
+    convertRecSig (signRecMsg keyOne highRMsg) `shouldNotBe` signMsgLowR keyOne highRMsg
+  it "signs with the r and s of signMsg" $
+    property $ \(m :: Msg, k :: SecKey) -> convertRecSig (signRecMsg k m) == signMsg k m
+  it "is deterministic" $
+    property $ \(m :: Msg, k :: SecKey) -> signRecMsg k m == signRecMsg k m
+  it "gives a recovery id of 0 or 1" $
     -- The ids 2 and 3 need r below p - n, about one signature in 2^128.
     property $ \(m :: Msg, k :: SecKey) ->
-      snd (exportCompactRecSig ctx (signRecMsg ctx k m)) `elem` [0, 1]
-  it "produces lower-S signatures" $ \ctx ->
-    property $ \(m :: Msg, k :: SecKey) -> isLowS ctx (convertRecSig ctx (signRecMsg ctx k m))
-  it "signs and recovers in parallel" $ \ctx ->
+      snd (exportCompactRecSig (signRecMsg k m)) `elem` [0, 1]
+  it "produces lower-S signatures" $
+    property $ \(m :: Msg, k :: SecKey) -> isLowS (convertRecSig (signRecMsg k m))
+  it "signs and recovers in parallel" $
     property $ \(xs :: [(Msg, SecKey)]) -> P.runPar $ do
-      results <- mapM (P.spawnP . signsAndRecovers ctx) xs
+      results <- mapM (P.spawnP . signsAndRecovers) xs
       and <$> mapM P.get results
   where
-    signsAndRecovers ctx (m, k) =
-      recover ctx (signRecMsg ctx k m) m == Just (derivePubKey ctx k)
+    signsAndRecovers (m, k) =
+      recover (signRecMsg k m) m == Just (derivePubKey k)
 
 -- * Recovery
 
-recoverySpec :: SpecWith Ctx
+recoverySpec :: Spec
 recoverySpec = describe "recovery" $ do
-  it "recovers the key of Bitcoin Core's SignCompact vector" $ \ctx ->
-    recovered ctx (coreR ++ coreS ++ "01") coreMsg `shouldBe` Just corePub
-  it "recovers another key with the other recovery id" $ \ctx ->
-    recovered ctx (coreR ++ coreS ++ "00") coreMsg `shouldBe` Just coreOtherPub
-  it "recovers the signer of Bitcoin Core's 'Trust no one' message" $ \ctx ->
-    recovered ctx (messageR ++ messageS ++ "01") messageHash `shouldBe` Just messagePub
-  it "recovers G from the RFC 6979 vector" $ \ctx -> do
-    recovered ctx (satoshiR ++ satoshiS ++ "01") satoshiMsg `shouldBe` Just genCompressed
-    recovered ctx (satoshiR ++ satoshiS ++ "00") satoshiMsg `shouldBe` Just satoshiOtherPub
-  it "recovers the signing key" $ \ctx ->
+  it "recovers the key of Bitcoin Core's SignCompact vector" $
+    recovered (coreR ++ coreS ++ "01") coreMsg `shouldBe` Just corePub
+  it "recovers another key with the other recovery id" $
+    recovered (coreR ++ coreS ++ "00") coreMsg `shouldBe` Just coreOtherPub
+  it "recovers the signer of Bitcoin Core's 'Trust no one' message" $
+    recovered (messageR ++ messageS ++ "01") messageHash `shouldBe` Just messagePub
+  it "recovers G from the RFC 6979 vector" $ do
+    recovered (satoshiR ++ satoshiS ++ "01") satoshiMsg `shouldBe` Just genCompressed
+    recovered (satoshiR ++ satoshiS ++ "00") satoshiMsg `shouldBe` Just satoshiOtherPub
+  it "recovers the signing key" $
     property $ \(m :: Msg, k :: SecKey) ->
-      recover ctx (signRecMsg ctx k m) m == Just (derivePubKey ctx k)
-  it "recovers a different key for another message" $ \ctx ->
+      recover (signRecMsg k m) m == Just (derivePubKey k)
+  it "recovers a different key for another message" $
     property $ \(m :: Msg, m' :: Msg, k :: SecKey) ->
-      m /= m' ==> recover ctx (signRecMsg ctx k m) m' /= Just (derivePubKey ctx k)
-  it "recovers the same key from the high-S form with the parity bit flipped" $ \ctx -> do
+      m /= m' ==> recover (signRecMsg k m) m' /= Just (derivePubKey k)
+  it "recovers the same key from the high-S form with the parity bit flipped" $ do
     -- The RFC 6979 vector with s replaced by n - s and the id 1 turned into 0.
-    recovered ctx (satoshiR ++ satoshiHighS ++ "00") satoshiMsg `shouldBe` Just genCompressed
-    recovered ctx (satoshiR ++ satoshiHighS ++ "01") satoshiMsg `shouldNotBe` Just genCompressed
-  it "does not apply the lower-S rule" $ \ctx ->
+    recovered (satoshiR ++ satoshiHighS ++ "00") satoshiMsg `shouldBe` Just genCompressed
+    recovered (satoshiR ++ satoshiHighS ++ "01") satoshiMsg `shouldNotBe` Just genCompressed
+  it "does not apply the lower-S rule" $
     property $ \(m :: Msg, k :: SecKey) ->
-      let (compact, i) = exportCompactRecSig ctx (signRecMsg ctx k m)
+      let (compact, i) = exportCompactRecSig (signRecMsg k m)
           (r, s) = BS.splitAt 32 compact.get
           -- n - s, through the negation of a tweak.
-          highS = (fromJust (tweakNegate ctx (fromJust (tweak s)))).get
-          high = fromJust (importCompactRecSig ctx (fromJust (compactSig (r <> highS))) (i `xor` 1))
-       in recover ctx high m == Just (derivePubKey ctx k)
+          highS = (fromJust (tweakNegate (fromJust (tweak s)))).get
+          high = fromJust (importCompactRecSig (fromJust (compactSig (r <> highS))) (i `xor` 1))
+       in recover high m == Just (derivePubKey k)
   where
-    recovered ctx sigHex m = bytesToHex . exportPubKey ctx True <$> recover ctx (fromString sigHex) m
+    recovered sigHex m = bytesToHex . exportPubKey True <$> recover (fromString sigHex) m
 
 -- * The formula
 
-formulaSpec :: SpecWith Ctx
+formulaSpec :: Spec
 formulaSpec = describe "the formula Q = r⁻¹(s·R − e·G)" $ do
-  it "gives R itself for r = 1, s = 1 and a zero hash" $ \ctx ->
-    recovered ctx (one ++ one ++ "00") zero `shouldBe` Just pointOne
-  it "takes the parity of y from the recovery id" $ \ctx ->
-    recovered ctx (one ++ one ++ "01") zero `shouldBe` Just ("03" ++ one)
-  it "reduces the hash modulo n" $ \ctx ->
-    recovered ctx (one ++ one ++ "00") order `shouldBe` Just pointOne
-  it "subtracts e·G" $ \ctx ->
-    recovered ctx (one ++ one ++ "00") one `shouldBe` Just pointOneMinusG
-  it "multiplies by s" $ \ctx -> do
-    recovered ctx (one ++ two ++ "00") zero `shouldBe` Just twicePointOne
-    recovered ctx (one ++ orderMinusOne ++ "00") zero `shouldBe` Just ("03" ++ one)
-  it "divides by r" $ \ctx ->
-    recovered ctx (two ++ one ++ "02") zero `shouldBe` Just halfPointOrderPlusTwo
-  it "uses r + n as the x coordinate for the ids 2 and 3" $ \ctx -> do
-    recovered ctx (two ++ two ++ "02") zero `shouldBe` Just ("02" ++ orderPlusTwo)
-    recovered ctx (two ++ two ++ "03") zero `shouldBe` Just ("03" ++ orderPlusTwo)
-  it "gives nothing when no point has the x coordinate" $ \ctx -> do
-    recovered ctx (five ++ one ++ "00") zero `shouldBe` Nothing
-    recovered ctx (one ++ one ++ "02") zero `shouldBe` Nothing
-    recovered ctx (fieldMinusOrderMinusOne ++ one ++ "02") zero `shouldBe` Nothing
-  it "gives nothing when r + n reaches the field size" $ \ctx ->
-    recovered ctx (fieldMinusOrder ++ one ++ "02") zero `shouldBe` Nothing
-  it "gives nothing when s·R − e·G is the point at infinity" $ \ctx -> do
+  it "gives R itself for r = 1, s = 1 and a zero hash" $
+    recovered (one ++ one ++ "00") zero `shouldBe` Just pointOne
+  it "takes the parity of y from the recovery id" $
+    recovered (one ++ one ++ "01") zero `shouldBe` Just ("03" ++ one)
+  it "reduces the hash modulo n" $
+    recovered (one ++ one ++ "00") order `shouldBe` Just pointOne
+  it "subtracts e·G" $
+    recovered (one ++ one ++ "00") one `shouldBe` Just pointOneMinusG
+  it "multiplies by s" $ do
+    recovered (one ++ two ++ "00") zero `shouldBe` Just twicePointOne
+    recovered (one ++ orderMinusOne ++ "00") zero `shouldBe` Just ("03" ++ one)
+  it "divides by r" $
+    recovered (two ++ one ++ "02") zero `shouldBe` Just halfPointOrderPlusTwo
+  it "uses r + n as the x coordinate for the ids 2 and 3" $ do
+    recovered (two ++ two ++ "02") zero `shouldBe` Just ("02" ++ orderPlusTwo)
+    recovered (two ++ two ++ "03") zero `shouldBe` Just ("03" ++ orderPlusTwo)
+  it "gives nothing when no point has the x coordinate" $ do
+    recovered (five ++ one ++ "00") zero `shouldBe` Nothing
+    recovered (one ++ one ++ "02") zero `shouldBe` Nothing
+    recovered (fieldMinusOrderMinusOne ++ one ++ "02") zero `shouldBe` Nothing
+  it "gives nothing when r + n reaches the field size" $
+    recovered (fieldMinusOrder ++ one ++ "02") zero `shouldBe` Nothing
+  it "gives nothing when s·R − e·G is the point at infinity" $ do
     -- R = G, s = 1 and e = 1: G - G.
-    recovered ctx (genX ++ one ++ "00") one `shouldBe` Nothing
+    recovered (genX ++ one ++ "00") one `shouldBe` Nothing
     -- With e = 2 instead: (G - 2G) / x = -(x⁻¹)·G.
-    recovered ctx (genX ++ one ++ "00") two `shouldBe` Just genNegatedOverX
+    recovered (genX ++ one ++ "00") two `shouldBe` Just genNegatedOverX
   where
-    recovered ctx sigHex msgHex =
-      bytesToHex . exportPubKey ctx True <$> recover ctx (fromString sigHex) (fromString msgHex)
+    recovered sigHex msgHex =
+      bytesToHex . exportPubKey True <$> recover (fromString sigHex) (fromString msgHex)
 
 -- * Compact encoding
 
-compactSpec :: SpecWith Ctx
+compactSpec :: Spec
 compactSpec = describe "compact encoding" $ do
-  it "imports and exports back the same signature" $ \ctx ->
+  it "imports and exports back the same signature" $
     property $ \(m :: Msg, k :: SecKey) ->
-      let s = signRecMsg ctx k m
-          (compact, i) = exportCompactRecSig ctx s
-       in importCompactRecSig ctx compact i == Just s
-  it "accepts the recovery ids 0 to 3 and rejects 4 and 255" $ \ctx -> do
-    forM_ [0 .. 3] $ \i -> importCompactRecSig ctx (fromString (one ++ one)) i `shouldSatisfy` isJust
-    importCompactRecSig ctx (fromString (one ++ one)) 4 `shouldBe` Nothing
-    importCompactRecSig ctx (fromString (one ++ one)) 255 `shouldBe` Nothing
-  it "accepts components of 1 and n - 1 and rejects 0 and n" $ \ctx -> do
-    importCompactRecSig ctx (fromString (one ++ one)) 0 `shouldSatisfy` isJust
-    importCompactRecSig ctx (fromString (orderMinusOne ++ orderMinusOne)) 0 `shouldSatisfy` isJust
-    importCompactRecSig ctx (fromString (order ++ one)) 0 `shouldBe` Nothing
-    importCompactRecSig ctx (fromString (one ++ order)) 0 `shouldBe` Nothing
-    importCompactRecSig ctx (fromString (zero ++ one)) 0 `shouldBe` Nothing
-    importCompactRecSig ctx (fromString (one ++ zero)) 0 `shouldBe` Nothing
-  it "imports a high-S signature" $ \ctx ->
-    importCompactRecSig ctx (fromString (satoshiR ++ satoshiHighS)) 0 `shouldSatisfy` isJust
-  it "converts to the signature without the id" $ \ctx -> do
-    bytesToHex (exportSig ctx (convertRecSig ctx (fromString (coreR ++ coreS ++ "01")))) `shouldBe` coreDer
-    convertRecSig ctx (fromString (coreR ++ coreS ++ "00"))
-      `shouldBe` convertRecSig ctx (fromString (coreR ++ coreS ++ "01"))
-  it "converts to a signature that verifies" $ \ctx ->
+      let s = signRecMsg k m
+          (compact, i) = exportCompactRecSig s
+       in importCompactRecSig compact i == Just s
+  it "accepts the recovery ids 0 to 3 and rejects 4 and 255" $ do
+    forM_ [0 .. 3] $ \i -> importCompactRecSig (fromString (one ++ one)) i `shouldSatisfy` isJust
+    importCompactRecSig (fromString (one ++ one)) 4 `shouldBe` Nothing
+    importCompactRecSig (fromString (one ++ one)) 255 `shouldBe` Nothing
+  it "accepts components of 1 and n - 1 and rejects 0 and n" $ do
+    importCompactRecSig (fromString (one ++ one)) 0 `shouldSatisfy` isJust
+    importCompactRecSig (fromString (orderMinusOne ++ orderMinusOne)) 0 `shouldSatisfy` isJust
+    importCompactRecSig (fromString (order ++ one)) 0 `shouldBe` Nothing
+    importCompactRecSig (fromString (one ++ order)) 0 `shouldBe` Nothing
+    importCompactRecSig (fromString (zero ++ one)) 0 `shouldBe` Nothing
+    importCompactRecSig (fromString (one ++ zero)) 0 `shouldBe` Nothing
+  it "imports a high-S signature" $
+    importCompactRecSig (fromString (satoshiR ++ satoshiHighS)) 0 `shouldSatisfy` isJust
+  it "converts to the signature without the id" $ do
+    bytesToHex (exportSig (convertRecSig (fromString (coreR ++ coreS ++ "01")))) `shouldBe` coreDer
+    convertRecSig (fromString (coreR ++ coreS ++ "00"))
+      `shouldBe` convertRecSig (fromString (coreR ++ coreS ++ "01"))
+  it "converts to a signature that verifies" $
     property $ \(m :: Msg, k :: SecKey) ->
-      verifySig ctx (derivePubKey ctx k) (convertRecSig ctx (signRecMsg ctx k m)) m
+      verifySig (derivePubKey k) (convertRecSig (signRecMsg k m)) m
 
 -- * Signature values
 
-valueSpec :: SpecWith Ctx
+valueSpec :: Spec
 valueSpec = describe "signature values" $ do
-  it "rebuild from their internal bytes" $ \ctx ->
-    property $ \(m :: Msg, k :: SecKey) -> let s = signRecMsg ctx k m in recSig s.get == Just s
-  it "reject internal bytes that are not a signature" $ \_ -> do
+  it "rebuild from their internal bytes" $
+    property $ \(m :: Msg, k :: SecKey) -> let s = signRecMsg k m in recSig s.get == Just s
+  it "reject internal bytes that are not a signature" $ do
     recSig (BS.replicate 65 0) `shouldBe` Nothing
     recSig (BS.replicate 65 0xff) `shouldBe` Nothing
     recSig (BS.replicate 64 1) `shouldBe` Nothing
     recSig (BS.replicate 66 1) `shouldBe` Nothing
-  it "reject an internal recovery id above 3" $ \ctx -> do
+  it "reject an internal recovery id above 3" $ do
     -- libsecp256k1 keeps the id in the last byte of the representation.
-    let bytes = (signRecMsg ctx keyOne satoshiMsg).get
+    let bytes = (signRecMsg keyOne satoshiMsg).get
     recSig (BS.init bytes `BS.snoc` 4) `shouldBe` Nothing
-  it "show r, s and the recovery id in hex" $ \ctx ->
-    show (signRecMsg ctx coreKey coreMsg) `shouldBe` quoted (coreR ++ coreS ++ "01")
-  it "read that encoding" $ \ctx -> do
-    read (quoted (coreR ++ coreS ++ "01")) `shouldBe` signRecMsg ctx coreKey coreMsg
-    (fromString (coreR ++ coreS ++ "01") :: RecSig) `shouldBe` signRecMsg ctx coreKey coreMsg
-  it "show and read" $ \ctx ->
-    property $ \(m :: Msg, k :: SecKey) -> showRead (signRecMsg ctx k m)
-  it "do not read an invalid signature" $ \_ -> do
+  it "show r, s and the recovery id in hex" $
+    show (signRecMsg coreKey coreMsg) `shouldBe` quoted (coreR ++ coreS ++ "01")
+  it "read that encoding" $ do
+    read (quoted (coreR ++ coreS ++ "01")) `shouldBe` signRecMsg coreKey coreMsg
+    (fromString (coreR ++ coreS ++ "01") :: RecSig) `shouldBe` signRecMsg coreKey coreMsg
+  it "show and read" $
+    property $ \(m :: Msg, k :: SecKey) -> showRead (signRecMsg k m)
+  it "do not read an invalid signature" $ do
     (readMaybe (quoted (coreR ++ coreS)) :: Maybe RecSig) `shouldBe` Nothing
     (readMaybe (quoted (coreR ++ coreS ++ "04")) :: Maybe RecSig) `shouldBe` Nothing
     (readMaybe (quoted (zero ++ coreS ++ "01")) :: Maybe RecSig) `shouldBe` Nothing
@@ -294,34 +294,34 @@
 
 -- * Values built with the raw constructors of the Internal modules
 
-rawValueSpec :: SpecWith Ctx
+rawValueSpec :: Spec
 rawValueSpec = describe "raw values from the Internal modules" $ do
-  it "a signature of 65 zero bytes recovers nothing, instead of aborting the process" $ \ctx ->
-    recover ctx (RecSig (BS.replicate 65 0)) satoshiMsg `shouldBe` Nothing
-  it "a zero secret key throws instead of signing" $ \ctx ->
-    evaluate (signRecMsg ctx (SecKey (BS.replicate 32 0)) satoshiMsg) `shouldThrow` anyErrorCall
-  it "values of the wrong length throw before reaching the library" $ \ctx -> do
-    evaluate (signRecMsg ctx (SecKey "a") satoshiMsg) `shouldThrow` anyErrorCall
-    evaluate (signRecMsg ctx keyOne (Msg "a")) `shouldThrow` anyErrorCall
-    evaluate (recover ctx (RecSig "a") satoshiMsg) `shouldThrow` anyErrorCall
-    evaluate (recover ctx (signRecMsg ctx keyOne satoshiMsg) (Msg "a")) `shouldThrow` anyErrorCall
-    evaluate (convertRecSig ctx (RecSig "a")) `shouldThrow` anyErrorCall
-    evaluate (exportCompactRecSig ctx (RecSig "a")) `shouldThrow` anyErrorCall
-    evaluate (importCompactRecSig ctx (CompactSig "a") 0) `shouldThrow` anyErrorCall
+  it "a signature of 65 zero bytes recovers nothing, instead of aborting the process" $
+    recover (RecSig (BS.replicate 65 0)) satoshiMsg `shouldBe` Nothing
+  it "a zero secret key throws instead of signing" $
+    evaluate (signRecMsg (SecKey (BS.replicate 32 0)) satoshiMsg) `shouldThrow` anyErrorCall
+  it "values of the wrong length throw before reaching the library" $ do
+    evaluate (signRecMsg (SecKey "a") satoshiMsg) `shouldThrow` anyErrorCall
+    evaluate (signRecMsg keyOne (Msg "a")) `shouldThrow` anyErrorCall
+    evaluate (recover (RecSig "a") satoshiMsg) `shouldThrow` anyErrorCall
+    evaluate (recover (signRecMsg keyOne satoshiMsg) (Msg "a")) `shouldThrow` anyErrorCall
+    evaluate (convertRecSig (RecSig "a")) `shouldThrow` anyErrorCall
+    evaluate (exportCompactRecSig (RecSig "a")) `shouldThrow` anyErrorCall
+    evaluate (importCompactRecSig (CompactSig "a") 0) `shouldThrow` anyErrorCall
     evaluate (length (show (RecSig "a"))) `shouldThrow` anyErrorCall
 
 -- * Derived instances
 
-instanceSpec :: SpecWith Ctx
+instanceSpec :: Spec
 instanceSpec = describe "derived instances" $ do
-  it "equal values hash equally, whichever way they were built" $ \ctx ->
+  it "equal values hash equally, whichever way they were built" $
     property $ \(m :: Msg, k :: SecKey) ->
-      let s = signRecMsg ctx k m
-          (compact, i) = exportCompactRecSig ctx s
-       in hash s == hash (fromJust (importCompactRecSig ctx compact i))
+      let s = signRecMsg k m
+          (compact, i) = exportCompactRecSig s
+       in hash s == hash (fromJust (importCompactRecSig compact i))
             && hash s == hash (fromJust (recSig s.get))
-  it "can be fully evaluated" $ \ctx ->
-    (signRecMsg ctx keyOne satoshiMsg `deepseq` ()) `shouldBe` ()
+  it "can be fully evaluated" $
+    (signRecMsg keyOne satoshiMsg `deepseq` ()) `shouldBe` ()
 
 #else
 
diff --git a/test/Crypto/Secp256k1Spec.hs b/test/Crypto/Secp256k1Spec.hs
--- a/test/Crypto/Secp256k1Spec.hs
+++ b/test/Crypto/Secp256k1Spec.hs
@@ -9,7 +9,6 @@
 import Control.DeepSeq (deepseq)
 import Control.Exception (evaluate)
 import Control.Monad.Par qualified as P
-import Data.Bits (xor)
 import Crypto.Secp256k1
 import Crypto.Secp256k1.Fixtures
 import Crypto.Secp256k1.Internal.Base
@@ -22,6 +21,7 @@
     Tweak (Tweak),
     signMsgWith,
   )
+import Data.Bits (xor)
 import Data.ByteString qualified as BS
 import Data.Hashable (hash)
 import Data.Maybe (fromJust, isJust, isNothing)
@@ -31,7 +31,7 @@
 import Text.Read (readMaybe)
 
 spec :: Spec
-spec = around withContext $ do
+spec = do
   secretKeySpec
   publicKeySpec
   messageSpec
@@ -44,7 +44,6 @@
   schnorrSpec
   xOnlySpec
   taprootSpec
-  contextSpec
   rawValueSpec
   instanceSpec
 
@@ -313,39 +312,44 @@
 
 -- * Secret keys
 
-secretKeySpec :: SpecWith Ctx
+secretKeySpec :: Spec
 secretKeySpec = describe "secret keys" $ do
-  it "accepts 1 and n - 1" $ \_ -> do
+  it "accepts 1 and n - 1" $ do
     secKey (hexToBytes one) `shouldSatisfy` isJust
     secKey (hexToBytes orderMinusOne) `shouldSatisfy` isJust
-  it "rejects 0, n, n + 1 and 2^256 - 1" $ \_ -> do
+  it "rejects 0, n, n + 1 and 2^256 - 1" $ do
     secKey (hexToBytes zero) `shouldBe` Nothing
     secKey (hexToBytes order) `shouldBe` Nothing
     secKey (hexToBytes orderPlusOne) `shouldBe` Nothing
     secKey (hexToBytes allOnes) `shouldBe` Nothing
-  it "rejects 31 and 33 bytes" $ \_ -> do
+  it "rejects 31 and 33 bytes" $ do
     secKey (BS.replicate 31 1) `shouldBe` Nothing
     secKey (BS.replicate 33 1) `shouldBe` Nothing
-  it "keeps the bytes it was given" $ \_ ->
-    property $ \(k :: SecKey) -> secKey k.get == Just k
-  it "derives the generator from key 1" $ \ctx -> do
-    bytesToHex (exportPubKey ctx True (derivePubKey ctx keyOne))
+  it "keeps the bytes it was given" $
+    property $
+      \(k :: SecKey) -> secKey k.get == Just k
+  it "derives the generator from key 1" $ do
+    bytesToHex (exportPubKey True (derivePubKey keyOne))
       `shouldBe` genCompressed
-    bytesToHex (exportPubKey ctx False (derivePubKey ctx keyOne))
+    bytesToHex (exportPubKey False (derivePubKey keyOne))
       `shouldBe` genUncompressed
-  it "derives the negated generator from key n - 1" $ \ctx ->
+  it "derives the negated generator from key n - 1" $
     -- -G has the same x as G and an odd y, so the prefix is 03.
-    bytesToHex (exportPubKey ctx True (derivePubKey ctx (fromString orderMinusOne)))
+    bytesToHex (exportPubKey True (derivePubKey (fromString orderMinusOne)))
       `shouldBe` "0379be667ef9dcbbac55a06295ce870b07029bfcdb2dce28d959f2815b16f81798"
-  it "derives the historical public key" $ \ctx ->
-    bytesToHex (exportPubKey ctx False (derivePubKey ctx histKey)) `shouldBe` histPub
-  it "shows the key in hex" $ \_ ->
-    show keyOne `shouldBe` quoted one
-  it "shows and reads" $ \_ ->
-    property (showRead :: SecKey -> Bool)
-  it "reads from a string" $ \_ ->
-    property $ \(k :: SecKey) -> fromString (bytesToHex k.get) == k
-  it "does not read an invalid key" $ \_ -> do
+  it "derives the historical public key" $
+    bytesToHex (exportPubKey False (derivePubKey histKey)) `shouldBe` histPub
+  it "shows a placeholder instead of the key" $
+    property $
+      \(k :: SecKey) -> show k == "SecKey <redacted>"
+  it "parenthesizes the placeholder inside a larger value" $
+    show (Just keyOne) `shouldBe` "Just (SecKey <redacted>)"
+  it "reads the key from hex" $
+    read (quoted one) `shouldBe` keyOne
+  it "reads from a string" $
+    property $
+      \(k :: SecKey) -> fromString (bytesToHex k.get) == k
+  it "does not read an invalid key" $ do
     (readMaybe (quoted zero) :: Maybe SecKey) `shouldBe` Nothing
     (readMaybe (quoted order) :: Maybe SecKey) `shouldBe` Nothing
     (readMaybe (quoted (drop 1 one)) :: Maybe SecKey) `shouldBe` Nothing
@@ -354,83 +358,85 @@
 
 -- * Public keys
 
-publicKeySpec :: SpecWith Ctx
+publicKeySpec :: Spec
 publicKeySpec = describe "public keys" $ do
-  it "imports the compressed, uncompressed and hybrid encodings of G" $ \ctx -> do
-    let g = derivePubKey ctx keyOne
-    importPubKey ctx (hexToBytes genCompressed) `shouldBe` Just g
-    importPubKey ctx (hexToBytes genUncompressed) `shouldBe` Just g
-    importPubKey ctx (hexToBytes genHybrid) `shouldBe` Just g
-  it "rejects malformed encodings" $ \ctx -> do
-    importPubKey ctx "" `shouldBe` Nothing
+  it "imports the compressed, uncompressed and hybrid encodings of G" $ do
+    let g = derivePubKey keyOne
+    importPubKey (hexToBytes genCompressed) `shouldBe` Just g
+    importPubKey (hexToBytes genUncompressed) `shouldBe` Just g
+    importPubKey (hexToBytes genHybrid) `shouldBe` Just g
+  it "rejects malformed encodings" $ do
+    importPubKey "" `shouldBe` Nothing
     -- prefix 05 does not exist
-    importPubKey ctx (hexToBytes ("05" ++ drop 2 genCompressed)) `shouldBe` Nothing
+    importPubKey (hexToBytes ("05" ++ drop 2 genCompressed)) `shouldBe` Nothing
     -- x only, no prefix
-    importPubKey ctx (hexToBytes (drop 2 genCompressed)) `shouldBe` Nothing
+    importPubKey (hexToBytes (drop 2 genCompressed)) `shouldBe` Nothing
     -- x and y without a prefix
-    importPubKey ctx (hexToBytes (drop 2 genUncompressed)) `shouldBe` Nothing
+    importPubKey (hexToBytes (drop 2 genUncompressed)) `shouldBe` Nothing
     -- uncompressed prefix on a compressed length
-    importPubKey ctx (hexToBytes ("04" ++ drop 2 genCompressed)) `shouldBe` Nothing
+    importPubKey (hexToBytes ("04" ++ drop 2 genCompressed)) `shouldBe` Nothing
     -- compressed prefix on an uncompressed length
-    importPubKey ctx (hexToBytes ("02" ++ drop 2 genUncompressed)) `shouldBe` Nothing
-  it "rejects points that are not on the curve" $ \ctx -> do
+    importPubKey (hexToBytes ("02" ++ drop 2 genUncompressed)) `shouldBe` Nothing
+  it "rejects points that are not on the curve" $ do
     -- x = 5 has no point on secp256k1 (x^3 + 7 is not a square mod p).
-    importPubKey ctx (hexToBytes ("02" ++ take 62 zero ++ "05")) `shouldBe` Nothing
+    importPubKey (hexToBytes ("02" ++ take 62 zero ++ "05")) `shouldBe` Nothing
     -- (1, 1) is not on the curve: 1 /= 1 + 7.
-    importPubKey ctx (hexToBytes ("04" ++ take 62 zero ++ "01" ++ take 62 zero ++ "01"))
+    importPubKey (hexToBytes ("04" ++ take 62 zero ++ "01" ++ take 62 zero ++ "01"))
       `shouldBe` Nothing
-  it "exports and imports back the same key" $ \ctx ->
+  it "exports and imports back the same key" $
     property $ \(k :: SecKey, compress :: Bool) ->
-      let p = derivePubKey ctx k
-       in importPubKey ctx (exportPubKey ctx compress p) == Just p
-  it "exports and imports in parallel" $ \ctx ->
+      let p = derivePubKey k
+       in importPubKey (exportPubKey compress p) == Just p
+  it "exports and imports in parallel" $
     property $ \(ks :: [(SecKey, Bool)]) -> P.runPar $ do
-      results <- mapM (P.spawnP . roundTrip ctx) ks
+      results <- mapM (P.spawnP . roundTrip) ks
       and <$> mapM P.get results
-  it "rebuilds a key from its internal bytes" $ \ctx ->
-    property $ \(k :: SecKey) -> let p = derivePubKey ctx k in pubKey p.get == Just p
-  it "rejects internal bytes that are not a point" $ \_ -> do
+  it "rebuilds a key from its internal bytes" $
+    property $
+      \(k :: SecKey) -> let p = derivePubKey k in pubKey p.get == Just p
+  it "rejects internal bytes that are not a point" $ do
     pubKey (BS.replicate 64 0) `shouldBe` Nothing
     pubKey (BS.replicate 64 1) `shouldBe` Nothing
     pubKey (BS.replicate 64 0xff) `shouldBe` Nothing
     pubKey (BS.pack [1 .. 64]) `shouldBe` Nothing
     pubKey (BS.replicate 63 1) `shouldBe` Nothing
-  it "shows the compressed encoding" $ \ctx ->
-    show (derivePubKey ctx keyOne) `shouldBe` quoted genCompressed
-  it "reads any encoding" $ \ctx -> do
-    let g = derivePubKey ctx keyOne
+  it "shows the compressed encoding" $
+    show (derivePubKey keyOne) `shouldBe` quoted genCompressed
+  it "reads any encoding" $ do
+    let g = derivePubKey keyOne
     read (quoted genCompressed) `shouldBe` g
     read (quoted genUncompressed) `shouldBe` g
     read (quoted genHybrid) `shouldBe` g
     (fromString genUncompressed :: PubKey) `shouldBe` g
-  it "shows and reads" $ \ctx ->
-    property $ \(k :: SecKey) -> showRead (derivePubKey ctx k)
-  it "does not read an invalid key" $ \_ -> do
+  it "shows and reads" $
+    property $
+      \(k :: SecKey) -> showRead (derivePubKey k)
+  it "does not read an invalid key" $ do
     (readMaybe (quoted (zero ++ zero)) :: Maybe PubKey) `shouldBe` Nothing
     (readMaybe (quoted ("02" ++ take 62 zero ++ "05")) :: Maybe PubKey) `shouldBe` Nothing
     (readMaybe (quoted (drop 2 genCompressed)) :: Maybe PubKey) `shouldBe` Nothing
     evaluate (fromString (drop 2 genCompressed) :: PubKey) `shouldThrow` anyErrorCall
   where
-    roundTrip ctx (k, compress) =
-      let p = derivePubKey ctx k
-       in importPubKey ctx (exportPubKey ctx compress p) == Just p
+    roundTrip (k, compress) =
+      let p = derivePubKey k
+       in importPubKey (exportPubKey compress p) == Just p
 
 -- * Messages
 
-messageSpec :: SpecWith Ctx
+messageSpec :: Spec
 messageSpec = describe "messages" $ do
-  it "accepts 32 bytes and rejects other lengths" $ \_ -> do
+  it "accepts 32 bytes and rejects other lengths" $ do
     msg (BS.replicate 32 7) `shouldSatisfy` isJust
     msg (BS.replicate 31 7) `shouldBe` Nothing
     msg (BS.replicate 33 7) `shouldBe` Nothing
     msg "" `shouldBe` Nothing
-  it "shows and reads" $ \_ ->
+  it "shows and reads" $
     property (showRead :: Msg -> Bool)
-  it "reads from a string, upper or lower case" $ \_ ->
+  it "reads from a string, upper or lower case" $
     property $ \(m :: Msg) ->
       fromString (bytesToHex m.get) == m
         && fromString (map toUpperHex (bytesToHex m.get)) == m
-  it "does not read an invalid message" $ \_ -> do
+  it "does not read an invalid message" $ do
     (readMaybe (quoted (drop 1 one)) :: Maybe Msg) `shouldBe` Nothing
     -- A non-ASCII character is not a hex digit even when its low byte is one
     -- (U+FF41, fullwidth 'a').
@@ -441,185 +447,189 @@
 
 -- * Signing
 
-signingSpec :: SpecWith Ctx
+signingSpec :: Spec
 signingSpec = describe "signing" $ do
-  it "produces the RFC 6979 vector for key 1 and sha256 'Satoshi Nakamoto'" $ \ctx -> do
-    bytesToHex (exportSig ctx (signMsg ctx keyOne satoshiMsg)) `shouldBe` satoshiDer
-    bytesToHex (exportCompactSig ctx (signMsg ctx keyOne satoshiMsg)).get
+  it "produces the RFC 6979 vector for key 1 and sha256 'Satoshi Nakamoto'" $ do
+    bytesToHex (exportSig (signMsg keyOne satoshiMsg)) `shouldBe` satoshiDer
+    bytesToHex (exportCompactSig (signMsg keyOne satoshiMsg)).get
       `shouldBe` satoshiR ++ satoshiS
-  it "produces Bitcoin Core's deterministic signature" $ \ctx -> do
-    bytesToHex (exportSig ctx (signMsg ctx coreKey coreMsg)) `shouldBe` coreDer
-    bytesToHex (exportSig ctx (signMsgLowR ctx coreKey coreMsg)) `shouldBe` coreDer
-  it "is deterministic" $ \ctx ->
-    property $ \(m :: Msg, k :: SecKey) -> signMsg ctx k m == signMsg ctx k m
-  it "verifies with the matching public key" $ \ctx ->
-    property $ \(m :: Msg, k :: SecKey) -> signsAndVerifies ctx (m, k)
-  it "verifies in parallel" $ \ctx ->
+  it "produces Bitcoin Core's deterministic signature" $ do
+    bytesToHex (exportSig (signMsg coreKey coreMsg)) `shouldBe` coreDer
+    bytesToHex (exportSig (signMsgLowR coreKey coreMsg)) `shouldBe` coreDer
+  it "is deterministic" $
+    property $
+      \(m :: Msg, k :: SecKey) -> signMsg k m == signMsg k m
+  it "verifies with the matching public key" $
+    property $
+      \(m :: Msg, k :: SecKey) -> signsAndVerifies (m, k)
+  it "verifies in parallel" $
     property $ \(xs :: [(Msg, SecKey)]) -> P.runPar $ do
-      results <- mapM (P.spawnP . signsAndVerifies ctx) xs
+      results <- mapM (P.spawnP . signsAndVerifies) xs
       and <$> mapM P.get results
-  it "produces lower-S signatures" $ \ctx ->
-    property $ \(m :: Msg, k :: SecKey) -> isLowS ctx (signMsg ctx k m)
+  it "produces lower-S signatures" $
+    property $
+      \(m :: Msg, k :: SecKey) -> isLowS (signMsg k m)
   describe "with low r" $ do
-    it "leaves a signature alone when r is already low" $ \ctx -> do
-      bytesToHex (exportSig ctx (signMsg ctx keyOne lowRMsg)) `shouldBe` lowRDer
-      signMsgLowR ctx keyOne lowRMsg `shouldBe` signMsg ctx keyOne lowRMsg
-    it "grinds a high r down the way Bitcoin Core does" $ \ctx -> do
-      bytesToHex (exportSig ctx (signMsg ctx keyOne highRMsg)) `shouldBe` highRDer
-      bytesToHex (exportSig ctx (signMsgLowR ctx keyOne highRMsg)) `shouldBe` groundDer
-    it "always gives low r, lower s, at most 70 DER bytes, and verifies" $ \ctx ->
+    it "leaves a signature alone when r is already low" $ do
+      bytesToHex (exportSig (signMsg keyOne lowRMsg)) `shouldBe` lowRDer
+      signMsgLowR keyOne lowRMsg `shouldBe` signMsg keyOne lowRMsg
+    it "grinds a high r down the way Bitcoin Core does" $ do
+      bytesToHex (exportSig (signMsg keyOne highRMsg)) `shouldBe` highRDer
+      bytesToHex (exportSig (signMsgLowR keyOne highRMsg)) `shouldBe` groundDer
+    it "always gives low r, lower s, at most 70 DER bytes, and verifies" $
       property $ \(m :: Msg, k :: SecKey) ->
-        let s = signMsgLowR ctx k m
-         in isLowR ctx s
-              && isLowS ctx s
-              && BS.length (exportSig ctx s) <= 70
-              && verifySig ctx (derivePubKey ctx k) s m
-    it "equals plain signing whenever that already has low r" $ \ctx ->
+        let s = signMsgLowR k m
+         in isLowR s
+              && isLowS s
+              && BS.length (exportSig s) <= 70
+              && verifySig (derivePubKey k) s m
+    it "equals plain signing whenever that already has low r" $
       property $ \(m :: Msg, k :: SecKey) ->
-        let s = signMsg ctx k m
-         in isLowR ctx s ==> signMsgLowR ctx k m == s
+        let s = signMsg k m
+         in isLowR s ==> signMsgLowR k m == s
   where
-    signsAndVerifies ctx (m, k) =
-      verifySig ctx (derivePubKey ctx k) (signMsg ctx k m) m
+    signsAndVerifies (m, k) =
+      verifySig (derivePubKey k) (signMsg k m) m
 
 -- * Verification
 
-verificationSpec :: SpecWith Ctx
+verificationSpec :: Spec
 verificationSpec = describe "verification" $ do
-  it "accepts the RFC 6979 vector from its DER encoding" $ \ctx ->
-    verifySig ctx (fromString genCompressed) (fromJust (importSig ctx (hexToBytes satoshiDer))) satoshiMsg
+  it "accepts the RFC 6979 vector from its DER encoding" $
+    verifySig (fromString genCompressed) (fromJust (importSig (hexToBytes satoshiDer))) satoshiMsg
       `shouldBe` True
-  it "accepts the historical vector" $ \ctx ->
+  it "accepts the historical vector" $
     verifySig
-      ctx
       (fromString histPub)
-      ( fromJust . importSig ctx . hexToBytes $
+      ( fromJust . importSig . hexToBytes $
           "3045022100f502bfa07af43e7ef265618b0d929a7619ee01d6150e37eb6eaaf2c8bd37fb22\
           \02206f0415ab0e9a977afd78b2c26ef39b3952096d319fd4b101c768ad6c132e3045"
       )
       "f5cbe7d88182a4b8e400f96b06128921864a18187d114c8ae8541b566c8ace00"
       `shouldBe` True
-  it "rejects a signature from another key" $ \ctx ->
+  it "rejects a signature from another key" $
     property $ \(m :: Msg, k :: SecKey, k' :: SecKey) ->
-      k /= k' ==> not (verifySig ctx (derivePubKey ctx k') (signMsg ctx k m) m)
-  it "rejects a signature over another message" $ \ctx ->
+      k /= k' ==> not (verifySig (derivePubKey k') (signMsg k m) m)
+  it "rejects a signature over another message" $
     property $ \(m :: Msg, m' :: Msg, k :: SecKey) ->
-      m /= m' ==> not (verifySig ctx (derivePubKey ctx k) (signMsg ctx k m) m')
-  it "rejects a signature with one bit flipped" $ \ctx ->
+      m /= m' ==> not (verifySig (derivePubKey k) (signMsg k m) m')
+  it "rejects a signature with one bit flipped" $
     property $ \(m :: Msg, k :: SecKey) ->
-      let compact = (exportCompactSig ctx (signMsg ctx k m)).get
+      let compact = (exportCompactSig (signMsg k m)).get
           -- Flipping the lowest bit of a lower-S s keeps it below n.
           flipped = BS.init compact `BS.snoc` (BS.last compact `xor` 1)
-       in case importCompactSig ctx (fromJust (compactSig flipped)) of
+       in case importCompactSig (fromJust (compactSig flipped)) of
             Nothing -> False
-            Just s -> not (verifySig ctx (derivePubKey ctx k) s m)
+            Just s -> not (verifySig (derivePubKey k) s m)
   describe "lower-S form" $ do
-    it "rejects the high-S form of a valid signature" $ \ctx -> do
+    it "rejects the high-S form of a valid signature" $ do
       let high = fromString (satoshiR ++ satoshiHighS) :: Sig
-      isLowS ctx high `shouldBe` False
-      verifySig ctx (fromString genCompressed) high satoshiMsg `shouldBe` False
-    it "normalizes the high-S form to the signature that was made" $ \ctx -> do
+      isLowS high `shouldBe` False
+      verifySig (fromString genCompressed) high satoshiMsg `shouldBe` False
+    it "normalizes the high-S form to the signature that was made" $ do
       let high = fromString (satoshiR ++ satoshiHighS) :: Sig
-          low = normalizeSig ctx high
-      low `shouldBe` signMsg ctx keyOne satoshiMsg
-      isLowS ctx low `shouldBe` True
-      verifySig ctx (fromString genCompressed) low satoshiMsg `shouldBe` True
-    it "leaves a lower-S signature unchanged" $ \ctx ->
+          low = normalizeSig high
+      low `shouldBe` signMsg keyOne satoshiMsg
+      isLowS low `shouldBe` True
+      verifySig (fromString genCompressed) low satoshiMsg `shouldBe` True
+    it "leaves a lower-S signature unchanged" $
       property $ \(m :: Msg, k :: SecKey) ->
-        let s = signMsg ctx k m in normalizeSig ctx s == s
-    it "is idempotent" $ \ctx -> do
+        let s = signMsg k m in normalizeSig s == s
+    it "is idempotent" $ do
       let high = fromString (satoshiR ++ satoshiHighS) :: Sig
-      normalizeSig ctx (normalizeSig ctx high) `shouldBe` normalizeSig ctx high
+      normalizeSig (normalizeSig high) `shouldBe` normalizeSig high
 
 -- * DER
 
-derSpec :: SpecWith Ctx
+derSpec :: Spec
 derSpec = describe "DER signatures" $ do
-  it "exports the RFC 6979 vector and imports it back" $ \ctx -> do
-    let s = signMsg ctx keyOne satoshiMsg
-    bytesToHex (exportSig ctx s) `shouldBe` satoshiDer
-    importSig ctx (hexToBytes satoshiDer) `shouldBe` Just s
-  it "exports and imports back the same signature" $ \ctx ->
+  it "exports the RFC 6979 vector and imports it back" $ do
+    let s = signMsg keyOne satoshiMsg
+    bytesToHex (exportSig s) `shouldBe` satoshiDer
+    importSig (hexToBytes satoshiDer) `shouldBe` Just s
+  it "exports and imports back the same signature" $
     property $ \(m :: Msg, k :: SecKey) ->
-      let s = signMsg ctx k m in importSig ctx (exportSig ctx s) == Just s
-  it "exports and imports in parallel" $ \ctx ->
+      let s = signMsg k m in importSig (exportSig s) == Just s
+  it "exports and imports in parallel" $
     property $ \(xs :: [(Msg, SecKey)]) -> P.runPar $ do
-      results <- mapM (P.spawnP . roundTrip ctx) xs
+      results <- mapM (P.spawnP . roundTrip) xs
       and <$> mapM P.get results
-  it "exports 70 bytes for low r and 71 bytes for high r" $ \ctx -> do
-    BS.length (exportSig ctx (signMsg ctx keyOne lowRMsg)) `shouldBe` 70
-    BS.length (exportSig ctx (signMsg ctx keyOne highRMsg)) `shouldBe` 71
-  it "imports a high-S signature" $ \ctx -> do
+  it "exports 70 bytes for low r and 71 bytes for high r" $ do
+    BS.length (exportSig (signMsg keyOne lowRMsg)) `shouldBe` 70
+    BS.length (exportSig (signMsg keyOne highRMsg)) `shouldBe` 71
+  it "imports a high-S signature" $ do
     let high = fromString (satoshiR ++ satoshiHighS) :: Sig
-    importSig ctx (exportSig ctx high) `shouldBe` Just high
-  it "rejects an empty input" $ \ctx ->
-    importSig ctx "" `shouldBe` Nothing
-  it "rejects a component equal to n or zero" $ \ctx -> do
+    importSig (exportSig high) `shouldBe` Just high
+  it "rejects an empty input" $
+    importSig "" `shouldBe` Nothing
+  it "rejects a component equal to n or zero" $ do
     -- r = n (33 bytes with a zero pad), s = r of the vector.
-    importSig ctx (hexToBytes ("3046022100" ++ order ++ "022100" ++ satoshiR)) `shouldBe` Nothing
+    importSig (hexToBytes ("3046022100" ++ order ++ "022100" ++ satoshiR)) `shouldBe` Nothing
     -- r = 0, s = r of the vector. 3 + 35 = 38 = 0x26 bytes.
-    importSig ctx (hexToBytes ("3026020100022100" ++ satoshiR)) `shouldBe` Nothing
+    importSig (hexToBytes ("3026020100022100" ++ satoshiR)) `shouldBe` Nothing
     -- r of the vector, s = 0.
-    importSig ctx (hexToBytes ("3026022100" ++ satoshiR ++ "020100")) `shouldBe` Nothing
-  it "rejects encodings that are not strict DER" $ \ctx -> do
+    importSig (hexToBytes ("3026022100" ++ satoshiR ++ "020100")) `shouldBe` Nothing
+  it "rejects encodings that are not strict DER" $ do
     -- Long-form length for a value below 128.
-    importSig ctx (hexToBytes ("308145" ++ drop 4 satoshiDer)) `shouldBe` Nothing
+    importSig (hexToBytes ("308145" ++ drop 4 satoshiDer)) `shouldBe` Nothing
     -- A byte after the sequence.
-    importSig ctx (hexToBytes (satoshiDer ++ "00")) `shouldBe` Nothing
+    importSig (hexToBytes (satoshiDer ++ "00")) `shouldBe` Nothing
     -- A byte missing at the end.
-    importSig ctx (hexToBytes (take (length satoshiDer - 2) satoshiDer)) `shouldBe` Nothing
+    importSig (hexToBytes (take (length satoshiDer - 2) satoshiDer)) `shouldBe` Nothing
     -- Wrong sequence tag.
-    importSig ctx (hexToBytes ("31" ++ drop 2 satoshiDer)) `shouldBe` Nothing
+    importSig (hexToBytes ("31" ++ drop 2 satoshiDer)) `shouldBe` Nothing
     -- Negative r: the zero pad is removed although the first byte is 0x93.
-    importSig ctx (hexToBytes ("30440220" ++ satoshiR ++ "0220" ++ satoshiS)) `shouldBe` Nothing
+    importSig (hexToBytes ("30440220" ++ satoshiR ++ "0220" ++ satoshiS)) `shouldBe` Nothing
     -- Two zero pad bytes on r.
-    importSig ctx (hexToBytes ("3046022200" ++ "00" ++ satoshiR ++ "0220" ++ satoshiS)) `shouldBe` Nothing
+    importSig (hexToBytes ("3046022200" ++ "00" ++ satoshiR ++ "0220" ++ satoshiS)) `shouldBe` Nothing
   where
-    roundTrip ctx (m, k) = let s = signMsg ctx k m in importSig ctx (exportSig ctx s) == Just s
+    roundTrip (m, k) = let s = signMsg k m in importSig (exportSig s) == Just s
 
 -- * Compact signatures
 
-compactSpec :: SpecWith Ctx
+compactSpec :: Spec
 compactSpec = describe "compact signatures" $ do
-  it "exports the RFC 6979 vector and imports it back" $ \ctx -> do
-    let s = signMsg ctx keyOne satoshiMsg
-    bytesToHex (exportCompactSig ctx s).get `shouldBe` satoshiR ++ satoshiS
-    importCompactSig ctx (fromString (satoshiR ++ satoshiS)) `shouldBe` Just s
-  it "exports and imports back the same signature" $ \ctx ->
+  it "exports the RFC 6979 vector and imports it back" $ do
+    let s = signMsg keyOne satoshiMsg
+    bytesToHex (exportCompactSig s).get `shouldBe` satoshiR ++ satoshiS
+    importCompactSig (fromString (satoshiR ++ satoshiS)) `shouldBe` Just s
+  it "exports and imports back the same signature" $
     property $ \(m :: Msg, k :: SecKey) ->
-      let s = signMsg ctx k m in importCompactSig ctx (exportCompactSig ctx s) == Just s
-  it "accepts components of 1 and n - 1 and rejects 0 and n" $ \ctx -> do
-    importCompactSig ctx (fromString (one ++ one)) `shouldSatisfy` isJust
-    importCompactSig ctx (fromString (orderMinusOne ++ orderMinusOne)) `shouldSatisfy` isJust
-    importCompactSig ctx (fromString (order ++ one)) `shouldBe` Nothing
-    importCompactSig ctx (fromString (one ++ order)) `shouldBe` Nothing
-    importCompactSig ctx (fromString (zero ++ one)) `shouldBe` Nothing
-    importCompactSig ctx (fromString (one ++ zero)) `shouldBe` Nothing
-  it "only accepts 64 bytes as a compact signature" $ \_ -> do
+      let s = signMsg k m in importCompactSig (exportCompactSig s) == Just s
+  it "accepts components of 1 and n - 1 and rejects 0 and n" $ do
+    importCompactSig (fromString (one ++ one)) `shouldSatisfy` isJust
+    importCompactSig (fromString (orderMinusOne ++ orderMinusOne)) `shouldSatisfy` isJust
+    importCompactSig (fromString (order ++ one)) `shouldBe` Nothing
+    importCompactSig (fromString (one ++ order)) `shouldBe` Nothing
+    importCompactSig (fromString (zero ++ one)) `shouldBe` Nothing
+    importCompactSig (fromString (one ++ zero)) `shouldBe` Nothing
+  it "only accepts 64 bytes as a compact signature" $ do
     compactSig (BS.replicate 64 1) `shouldSatisfy` isJust
     compactSig (BS.replicate 63 1) `shouldBe` Nothing
     compactSig (BS.replicate 65 1) `shouldBe` Nothing
-  it "shows and reads a compact signature" $ \_ -> do
+  it "shows and reads a compact signature" $ do
     show (fromString (satoshiR ++ satoshiS) :: CompactSig) `shouldBe` quoted (satoshiR ++ satoshiS)
     (readMaybe (quoted (satoshiR ++ satoshiS)) :: Maybe CompactSig)
       `shouldBe` Just (fromString (satoshiR ++ satoshiS))
     (readMaybe (quoted satoshiR) :: Maybe CompactSig) `shouldBe` Nothing
     evaluate (fromString satoshiR :: CompactSig) `shouldThrow` anyErrorCall
   describe "signature values" $ do
-    it "rebuild from their internal bytes" $ \ctx ->
-      property $ \(m :: Msg, k :: SecKey) -> let s = signMsg ctx k m in sig s.get == Just s
-    it "reject internal bytes that are not a signature" $ \_ -> do
+    it "rebuild from their internal bytes" $
+      property $
+        \(m :: Msg, k :: SecKey) -> let s = signMsg k m in sig s.get == Just s
+    it "reject internal bytes that are not a signature" $ do
       sig (BS.replicate 64 0) `shouldBe` Nothing
       sig (BS.replicate 64 0xff) `shouldBe` Nothing
       sig (BS.replicate 63 1) `shouldBe` Nothing
-    it "show the compact encoding" $ \ctx ->
-      show (signMsg ctx keyOne satoshiMsg) `shouldBe` quoted (satoshiR ++ satoshiS)
-    it "read the compact encoding" $ \ctx -> do
-      read (quoted (satoshiR ++ satoshiS)) `shouldBe` signMsg ctx keyOne satoshiMsg
-      (fromString (satoshiR ++ satoshiS) :: Sig) `shouldBe` signMsg ctx keyOne satoshiMsg
-    it "show and read" $ \ctx ->
-      property $ \(m :: Msg, k :: SecKey) -> showRead (signMsg ctx k m)
-    it "do not read an invalid signature" $ \_ -> do
+    it "show the compact encoding" $
+      show (signMsg keyOne satoshiMsg) `shouldBe` quoted (satoshiR ++ satoshiS)
+    it "read the compact encoding" $ do
+      read (quoted (satoshiR ++ satoshiS)) `shouldBe` signMsg keyOne satoshiMsg
+      (fromString (satoshiR ++ satoshiS) :: Sig) `shouldBe` signMsg keyOne satoshiMsg
+    it "show and read" $
+      property $
+        \(m :: Msg, k :: SecKey) -> showRead (signMsg k m)
+    it "do not read an invalid signature" $ do
       (readMaybe (quoted (zero ++ one)) :: Maybe Sig) `shouldBe` Nothing
       (readMaybe (quoted (order ++ one)) :: Maybe Sig) `shouldBe` Nothing
       (readMaybe (quoted satoshiDer) :: Maybe Sig) `shouldBe` Nothing
@@ -627,87 +637,89 @@
 
 -- * Tweaks
 
-tweakSpec :: SpecWith Ctx
+tweakSpec :: Spec
 tweakSpec = describe "tweaks" $ do
-  it "accepts 0 and n - 1 and rejects n and 2^256 - 1" $ \_ -> do
+  it "accepts 0 and n - 1 and rejects n and 2^256 - 1" $ do
     tweak (hexToBytes zero) `shouldSatisfy` isJust
     tweak (hexToBytes orderMinusOne) `shouldSatisfy` isJust
     tweak (hexToBytes order) `shouldBe` Nothing
     tweak (hexToBytes allOnes) `shouldBe` Nothing
     tweak (BS.replicate 31 0) `shouldBe` Nothing
-  it "shows and reads" $ \_ ->
+  it "shows and reads" $
     property (showRead :: Tweak -> Bool)
-  it "does not read a tweak of n" $ \_ -> do
+  it "does not read a tweak of n" $ do
     (readMaybe (quoted order) :: Maybe Tweak) `shouldBe` Nothing
     evaluate (fromString order :: Tweak) `shouldThrow` anyErrorCall
-  it "reads from a string" $ \_ ->
-    property $ \(t :: Tweak) -> fromString (bytesToHex t.get) == t
-  it "adds to a secret key" $ \ctx ->
+  it "reads from a string" $
+    property $
+      \(t :: Tweak) -> fromString (bytesToHex t.get) == t
+  it "adds to a secret key" $
     -- (key + tweak) mod n
-    tweakAddSecKey ctx histKey histTweak
+    tweakAddSecKey histKey histTweak
       `shouldBe` Just "ec1e3ce1cefa18a671d51125e2b249688d934b0e28f5d1665384d9b02f929059"
-  it "multiplies a secret key" $ \ctx ->
+  it "multiplies a secret key" $
     -- (key * tweak) mod n
-    tweakMulSecKey ctx histKey histTweak
+    tweakMulSecKey histKey histTweak
       `shouldBe` Just "a96f5962493acb179f60a86a9785fc7a30e0c39b64c09d24fe064d9aef15e4c0"
-  it "adds to a public key" $ \ctx ->
+  it "adds to a public key" $
     -- P + tweak * G
-    fmap (bytesToHex . exportPubKey ctx False) (tweakAddPubKey ctx (fromString histPub) histTweak)
+    fmap (bytesToHex . exportPubKey False) (tweakAddPubKey (fromString histPub) histTweak)
       `shouldBe` Just
         "04441c3982b97576646e0df0c96736063df6b42f2ee566d13b9f6424302d1379e5\
         \18fdc87a14c5435bff7a5db4552042cb4120c6b86a4bbd3d0643f3c14ad01368"
-  it "multiplies a public key" $ \ctx ->
+  it "multiplies a public key" $
     -- tweak * P
-    fmap (bytesToHex . exportPubKey ctx False) (tweakMulPubKey ctx (fromString histPub) histTweak)
+    fmap (bytesToHex . exportPubKey False) (tweakMulPubKey (fromString histPub) histTweak)
       `shouldBe` Just
         "04f379dc99cdf5c83e433defa267fbb3377d61d6b779c06a0e4ce29ae3ff5353b1\
         \2ae49c9d07e7368f2ba5a446c203255ce912322991a2d6a9d5d5761c61ed1845"
-  it "tweaks the public key like the secret key" $ \ctx ->
+  it "tweaks the public key like the secret key" $
     property $ \(k :: SecKey, t :: Tweak) ->
-      fmap (derivePubKey ctx) (tweakAddSecKey ctx k t) == tweakAddPubKey ctx (derivePubKey ctx k) t
-        && fmap (derivePubKey ctx) (tweakMulSecKey ctx k t) == tweakMulPubKey ctx (derivePubKey ctx k) t
-  it "adding zero changes nothing" $ \ctx ->
+      fmap (derivePubKey) (tweakAddSecKey k t) == tweakAddPubKey (derivePubKey k) t
+        && fmap (derivePubKey) (tweakMulSecKey k t) == tweakMulPubKey (derivePubKey k) t
+  it "adding zero changes nothing" $
     property $ \(k :: SecKey) ->
-      tweakAddSecKey ctx k (fromString zero) == Just k
-        && tweakAddPubKey ctx (derivePubKey ctx k) (fromString zero) == Just (derivePubKey ctx k)
-  it "multiplying by zero fails" $ \ctx -> do
-    tweakMulSecKey ctx keyOne (fromString zero) `shouldBe` Nothing
-    tweakMulPubKey ctx (derivePubKey ctx keyOne) (fromString zero) `shouldBe` Nothing
-  it "adding the negation of the key fails" $ \ctx -> do
+      tweakAddSecKey k (fromString zero) == Just k
+        && tweakAddPubKey (derivePubKey k) (fromString zero) == Just (derivePubKey k)
+  it "multiplying by zero fails" $ do
+    tweakMulSecKey keyOne (fromString zero) `shouldBe` Nothing
+    tweakMulPubKey (derivePubKey keyOne) (fromString zero) `shouldBe` Nothing
+  it "adding the negation of the key fails" $ do
     -- 1 + (n - 1) = 0 mod n
-    tweakAddSecKey ctx keyOne (fromString orderMinusOne) `shouldBe` Nothing
-    tweakAddPubKey ctx (derivePubKey ctx keyOne) (fromString orderMinusOne) `shouldBe` Nothing
-  it "negates modulo n" $ \ctx -> do
-    tweakNegate ctx (fromString one) `shouldBe` Just (fromString orderMinusOne)
-    tweakNegate ctx (fromString zero) `shouldBe` Just (fromString zero)
+    tweakAddSecKey keyOne (fromString orderMinusOne) `shouldBe` Nothing
+    tweakAddPubKey (derivePubKey keyOne) (fromString orderMinusOne) `shouldBe` Nothing
+  it "negates modulo n" $ do
+    tweakNegate (fromString one) `shouldBe` Just (fromString orderMinusOne)
+    tweakNegate (fromString zero) `shouldBe` Just (fromString zero)
     -- n - histTweak
-    tweakNegate ctx histTweak
+    tweakNegate histTweak
       `shouldBe` Just "0a3418277e7d5b471bff0694f9ed76dd3464c4ce323753b0d77e433663ab7341"
-  it "negating twice gives the tweak back" $ \ctx ->
-    property $ \(t :: Tweak) -> (tweakNegate ctx t >>= tweakNegate ctx) == Just t
-  it "adding a tweak and then its negation gives the key back" $ \ctx ->
+  it "negating twice gives the tweak back" $
+    property $
+      \(t :: Tweak) -> (tweakNegate t >>= tweakNegate) == Just t
+  it "adding a tweak and then its negation gives the key back" $
     property $ \(k :: SecKey, t :: Tweak) ->
-      let minus = fromJust (tweakNegate ctx t)
-       in (tweakAddSecKey ctx k t >>= \k' -> tweakAddSecKey ctx k' minus) == Just k
-  it "leaves its inputs unchanged" $ \ctx ->
+      let minus = fromJust (tweakNegate t)
+       in (tweakAddSecKey k t >>= \k' -> tweakAddSecKey k' minus) == Just k
+  it "leaves its inputs unchanged" $
     property $ \(k :: SecKey, t :: Tweak) ->
       let kBytes = BS.copy k.get
-          p = derivePubKey ctx k
+          p = derivePubKey k
           pBytes = BS.copy p.get
           tBytes = BS.copy t.get
-       in tweakAddSecKey ctx k t `seq`
-            tweakMulPubKey ctx p t `seq`
-              tweakNegate ctx t `seq`
+       in tweakAddSecKey k t `seq`
+            tweakMulPubKey p t `seq`
+              tweakNegate t `seq`
                 (k.get == kBytes && p.get == pBytes && t.get == tBytes)
 
 -- * Combining public keys
 
-combineSpec :: SpecWith Ctx
+combineSpec :: Spec
 combineSpec = describe "combining public keys" $ do
-  it "adds three historical keys" $ \ctx ->
-    fmap (bytesToHex . exportPubKey ctx False)
+  it "adds three historical keys" $
+    fmap
+      (bytesToHex . exportPubKey False)
       ( combinePubKeys
-          ctx
           [ fromString histPub,
             "0487d82042d93447008dfe2af762068a1e53ff394a5bf8f68a045fa642b99ea5d1\
             \53f577dd2dba6c7ae4cfd7b6622409d7edd2d76dd13a8092cd3af97b77bd2c77",
@@ -718,70 +730,70 @@
       `shouldBe` Just
         "043d9a7ec70011efc23c33a7e62d2ea73cca87797e3b659d93bea6aa871aebde56\
         \c3bc6134ca82e324b0ab9c0e601a6d2933afe7fb5d9f3aae900f5c5dc6e362c8"
-  it "adds G to itself" $ \ctx ->
+  it "adds G to itself" $
     -- 2 * G
-    fmap (bytesToHex . exportPubKey ctx True) (combinePubKeys ctx [fromString genCompressed, fromString genCompressed])
+    fmap (bytesToHex . exportPubKey True) (combinePubKeys [fromString genCompressed, fromString genCompressed])
       `shouldBe` Just "02c6047f9441ed7d6d3045406e95c07cd85c778e4b8cef3ca7abac09b95c709ee5"
-  it "adds like the secret keys add" $ \ctx ->
+  it "adds like the secret keys add" $
     property $ \(k1 :: SecKey, k2 :: SecKey) ->
-      combinePubKeys ctx [derivePubKey ctx k1, derivePubKey ctx k2]
-        == fmap (derivePubKey ctx) (tweakAddSecKey ctx k1 (fromString (bytesToHex k2.get)))
-  it "returns a single key unchanged" $ \ctx ->
-    property $ \(k :: SecKey) -> combinePubKeys ctx [derivePubKey ctx k] == Just (derivePubKey ctx k)
-  it "fails for no keys" $ \ctx ->
-    combinePubKeys ctx [] `shouldBe` Nothing
-  it "fails when the sum is the point at infinity" $ \ctx ->
+      combinePubKeys [derivePubKey k1, derivePubKey k2]
+        == fmap (derivePubKey) (tweakAddSecKey k1 (fromString (bytesToHex k2.get)))
+  it "returns a single key unchanged" $
+    property $
+      \(k :: SecKey) -> combinePubKeys [derivePubKey k] == Just (derivePubKey k)
+  it "fails for no keys" $
+    combinePubKeys [] `shouldBe` Nothing
+  it "fails when the sum is the point at infinity" $
     property $ \(k :: SecKey) ->
-      let p = derivePubKey ctx k
-          minusP = fromJust (tweakMulPubKey ctx p (fromString orderMinusOne))
-       in isNothing (combinePubKeys ctx [p, minusP])
-
--- * Contexts
+      let p = derivePubKey k
+          minusP = fromJust (tweakMulPubKey p (fromString orderMinusOne))
+       in isNothing (combinePubKeys [p, minusP])
 
 -- * Schnorr signatures
 
-schnorrSpec :: SpecWith Ctx
+schnorrSpec :: Spec
 schnorrSpec = describe "Schnorr signatures" $ do
   describe "BIP-340 vector" $ mapM_ bip340VectorSpec bip340Vectors
-  it "signs vector 0 without auxiliary randomness as with 32 zero bytes" $ \ctx ->
-    signSchnorr ctx bip340Key0 (fromString zero) `shouldBe` fromString bip340Sig0
-  it "signs without randomness as with 32 zero bytes" $ \ctx ->
+  it "signs vector 0 without auxiliary randomness as with 32 zero bytes" $
+    signSchnorr bip340Key0 (fromString zero) `shouldBe` fromString bip340Sig0
+  it "signs without randomness as with 32 zero bytes" $
     property $ \(m :: Msg, k :: SecKey) ->
-      signSchnorrWithAux ctx k m (BS.replicate 32 0) == Just (signSchnorr ctx k m)
-  it "verifies with the matching public key" $ \ctx ->
+      signSchnorrWithAux k m (BS.replicate 32 0) == Just (signSchnorr k m)
+  it "verifies with the matching public key" $
     property $ \(m :: Msg, k :: SecKey) ->
-      verifySchnorr ctx (derivePubKey ctx k) (signSchnorr ctx k m) m
-  it "verifies with the negation of the public key" $ \ctx ->
+      verifySchnorr (derivePubKey k) (signSchnorr k m) m
+  it "verifies with the negation of the public key" $
     property $ \(m :: Msg, k :: SecKey) ->
-      verifySchnorr ctx (negatePubKey ctx (derivePubKey ctx k)) (signSchnorr ctx k m) m
-  it "verifies a signature made with fresh randomness" $ \ctx ->
+      verifySchnorr (negatePubKey (derivePubKey k)) (signSchnorr k m) m
+  it "verifies a signature made with fresh randomness" $
     property $ \(m :: Msg, k :: SecKey) -> ioProperty $ do
-      s <- signSchnorrIO ctx k m
-      return (verifySchnorr ctx (derivePubKey ctx k) s m)
-  it "changes with the auxiliary randomness" $ \ctx ->
+      s <- signSchnorrIO k m
+      return (verifySchnorr (derivePubKey k) s m)
+  it "changes with the auxiliary randomness" $
     property $ \(m :: Msg, k :: SecKey) ->
-      signSchnorrWithAux ctx k m (BS.replicate 32 1) /= signSchnorrWithAux ctx k m (BS.replicate 32 2)
-  it "rejects auxiliary randomness that is not 32 bytes" $ \ctx -> do
-    signSchnorrWithAux ctx keyOne satoshiMsg (BS.replicate 31 0) `shouldBe` Nothing
-    signSchnorrWithAux ctx keyOne satoshiMsg (BS.replicate 33 0) `shouldBe` Nothing
-  it "rejects a signature from another key" $ \ctx ->
+      signSchnorrWithAux k m (BS.replicate 32 1) /= signSchnorrWithAux k m (BS.replicate 32 2)
+  it "rejects auxiliary randomness that is not 32 bytes" $ do
+    signSchnorrWithAux keyOne satoshiMsg (BS.replicate 31 0) `shouldBe` Nothing
+    signSchnorrWithAux keyOne satoshiMsg (BS.replicate 33 0) `shouldBe` Nothing
+  it "rejects a signature from another key" $
     property $ \(m :: Msg, k :: SecKey, k' :: SecKey) ->
-      k /= k' ==> not (verifySchnorr ctx (derivePubKey ctx k') (signSchnorr ctx k m) m)
-  it "rejects a signature over another message" $ \ctx ->
+      k /= k' ==> not (verifySchnorr (derivePubKey k') (signSchnorr k m) m)
+  it "rejects a signature over another message" $
     property $ \(m :: Msg, m' :: Msg, k :: SecKey) ->
-      m /= m' ==> not (verifySchnorr ctx (derivePubKey ctx k) (signSchnorr ctx k m) m')
-  it "only accepts 64 bytes as a signature" $ \_ -> do
+      m /= m' ==> not (verifySchnorr (derivePubKey k) (signSchnorr k m) m')
+  it "only accepts 64 bytes as a signature" $ do
     schnorrSig (BS.replicate 64 0) `shouldSatisfy` isJust
     schnorrSig (BS.replicate 63 0) `shouldBe` Nothing
     schnorrSig (BS.replicate 65 0) `shouldBe` Nothing
-  it "shows the signature in hex" $ \_ ->
+  it "shows the signature in hex" $
     show (fromString bip340Sig0 :: SchnorrSig) `shouldBe` quoted bip340Sig0
-  it "shows and reads" $ \ctx ->
-    property $ \(m :: Msg, k :: SecKey) -> showRead (signSchnorr ctx k m)
-  it "reads from a string" $ \ctx ->
+  it "shows and reads" $
+    property $
+      \(m :: Msg, k :: SecKey) -> showRead (signSchnorr k m)
+  it "reads from a string" $
     property $ \(m :: Msg, k :: SecKey) ->
-      let s = signSchnorr ctx k m in fromString (bytesToHex s.get) == s
-  it "does not read a signature of the wrong length" $ \_ -> do
+      let s = signSchnorr k m in fromString (bytesToHex s.get) == s
+  it "does not read a signature of the wrong length" $ do
     (readMaybe (quoted (replicate 126 '0')) :: Maybe SchnorrSig) `shouldBe` Nothing
     evaluate (fromString (replicate 126 '0') :: SchnorrSig) `shouldThrow` anyErrorCall
 
@@ -789,207 +801,193 @@
 -- with the given auxiliary randomness gives the signature. For every vector:
 -- verification gives the expected result, where a public key that does not
 -- import counts as a failed verification.
-bip340VectorSpec :: BIP340Vector -> SpecWith Ctx
-bip340VectorSpec v = it (show v.index ++ " " ++ v.comment) $ \ctx -> do
+bip340VectorSpec :: BIP340Vector -> Spec
+bip340VectorSpec v = it (show v.index ++ " " ++ v.comment) $ do
   let m = fromString v.message :: Msg
       s = fromString v.signature :: SchnorrSig
   case (v.secretKey, v.auxRand) of
     (Just key, Just aux) -> do
       let k = fromString key :: SecKey
-      bytesToHex (exportXOnlyPubKey ctx (derivePubKey ctx k)) `shouldBe` v.publicKey
-      signSchnorrWithAux ctx k m (hexToBytes aux) `shouldBe` Just s
+      bytesToHex (exportXOnlyPubKey (derivePubKey k)) `shouldBe` v.publicKey
+      signSchnorrWithAux k m (hexToBytes aux) `shouldBe` Just s
     _ -> return ()
-  maybe False (\p -> verifySchnorr ctx p s m) (importXOnlyPubKey ctx (hexToBytes v.publicKey))
+  maybe False (\p -> verifySchnorr p s m) (importXOnlyPubKey (hexToBytes v.publicKey))
     `shouldBe` v.result
 
 -- * X-only public keys
 
-xOnlySpec :: SpecWith Ctx
+xOnlySpec :: Spec
 xOnlySpec = describe "x-only public keys" $ do
-  it "exports the x coordinate of G" $ \ctx ->
+  it "exports the x coordinate of G" $
     -- the compressed encoding of G without its 02 prefix
-    bytesToHex (exportXOnlyPubKey ctx (derivePubKey ctx keyOne)) `shouldBe` drop 2 genCompressed
-  it "exports the public key of BIP-340 vector 0" $ \ctx ->
-    bytesToHex (exportXOnlyPubKey ctx (derivePubKey ctx bip340Key0)) `shouldBe` bip340Pub0
-  it "exports the x coordinate of any key" $ \ctx ->
+    bytesToHex (exportXOnlyPubKey (derivePubKey keyOne)) `shouldBe` drop 2 genCompressed
+  it "exports the public key of BIP-340 vector 0" $
+    bytesToHex (exportXOnlyPubKey (derivePubKey bip340Key0)) `shouldBe` bip340Pub0
+  it "exports the x coordinate of any key" $
     property $ \(k :: SecKey) ->
-      let p = derivePubKey ctx k
-       in exportXOnlyPubKey ctx p == BS.drop 1 (exportPubKey ctx True p)
-  it "exports a key and its negation the same way" $ \ctx ->
+      let p = derivePubKey k
+       in exportXOnlyPubKey p == BS.drop 1 (exportPubKey True p)
+  it "exports a key and its negation the same way" $
     property $ \(k :: SecKey) ->
-      let p = derivePubKey ctx k
-       in exportXOnlyPubKey ctx p == exportXOnlyPubKey ctx (negatePubKey ctx p)
-  it "imports G from its x coordinate" $ \ctx ->
-    fmap (bytesToHex . exportPubKey ctx True) (importXOnlyPubKey ctx (hexToBytes (drop 2 genCompressed)))
+      let p = derivePubKey k
+       in exportXOnlyPubKey p == exportXOnlyPubKey (negatePubKey p)
+  it "imports G from its x coordinate" $
+    fmap (bytesToHex . exportPubKey True) (importXOnlyPubKey (hexToBytes (drop 2 genCompressed)))
       `shouldBe` Just genCompressed
-  it "imports the point with an even y coordinate" $ \ctx ->
+  it "imports the point with an even y coordinate" $
     property $ \(k :: SecKey) ->
-      let x = exportXOnlyPubKey ctx (derivePubKey ctx k)
-       in fmap (exportPubKey ctx True) (importXOnlyPubKey ctx x) == Just (BS.cons 0x02 x)
-  it "rejects an x coordinate that is not on the curve" $ \ctx -> do
-    importXOnlyPubKey ctx (hexToBytes fieldSize) `shouldBe` Nothing
+      let x = exportXOnlyPubKey (derivePubKey k)
+       in fmap (exportPubKey True) (importXOnlyPubKey x) == Just (BS.cons 0x02 x)
+  it "rejects an x coordinate that is not on the curve" $ do
+    importXOnlyPubKey (hexToBytes fieldSize) `shouldBe` Nothing
     -- BIP-340 vector 5
-    importXOnlyPubKey ctx (hexToBytes "eefdea4cdb677750a420fee807eacf21eb9898ae79b9768766e4faa04a2d4a34")
+    importXOnlyPubKey (hexToBytes "eefdea4cdb677750a420fee807eacf21eb9898ae79b9768766e4faa04a2d4a34")
       `shouldBe` Nothing
-  it "rejects 31 and 33 bytes" $ \ctx -> do
-    importXOnlyPubKey ctx (BS.replicate 31 1) `shouldBe` Nothing
-    importXOnlyPubKey ctx (BS.replicate 33 1) `shouldBe` Nothing
+  it "rejects 31 and 33 bytes" $ do
+    importXOnlyPubKey (BS.replicate 31 1) `shouldBe` Nothing
+    importXOnlyPubKey (BS.replicate 33 1) `shouldBe` Nothing
 
 -- * Taproot tweaks
 
-taprootSpec :: SpecWith Ctx
+taprootSpec :: Spec
 taprootSpec = describe "Taproot tweaks" $ do
   describe "BIP-341 key path input" $ mapM_ (uncurry bip341VectorSpec) (zip [0 :: Int ..] bip341Vectors)
-  it "tweaks the public key like the secret key" $ \ctx ->
+  it "tweaks the public key like the secret key" $
     property $ \(k :: SecKey, t :: Tweak) ->
-      fmap (derivePubKey ctx) (tweakAddXOnlySecKey ctx k t) == tweakAddXOnlyPubKey ctx (derivePubKey ctx k) t
-  it "tweaks a key and its negation alike" $ \ctx ->
+      fmap (derivePubKey) (tweakAddXOnlySecKey k t) == tweakAddXOnlyPubKey (derivePubKey k) t
+  it "tweaks a key and its negation alike" $
     property $ \(k :: SecKey, t :: Tweak) ->
-      let p = derivePubKey ctx k
-       in tweakAddXOnlyPubKey ctx p t == tweakAddXOnlyPubKey ctx (negatePubKey ctx p) t
-  it "signs for the tweaked output key with the tweaked secret key" $ \ctx ->
+      let p = derivePubKey k
+       in tweakAddXOnlyPubKey p t == tweakAddXOnlyPubKey (negatePubKey p) t
+  it "signs for the tweaked output key with the tweaked secret key" $
     property $ \(m :: Msg, k :: SecKey, t :: Tweak) ->
-      let k' = fromJust (tweakAddXOnlySecKey ctx k t)
-          p' = fromJust (tweakAddXOnlyPubKey ctx (derivePubKey ctx k) t)
-       in verifySchnorr ctx p' (signSchnorr ctx k' m) m
-  it "adding zero gives the point with an even y coordinate" $ \ctx ->
+      let k' = fromJust (tweakAddXOnlySecKey k t)
+          p' = fromJust (tweakAddXOnlyPubKey (derivePubKey k) t)
+       in verifySchnorr p' (signSchnorr k' m) m
+  it "adding zero gives the point with an even y coordinate" $
     property $ \(k :: SecKey) ->
-      let p = derivePubKey ctx k
-       in fmap (exportPubKey ctx True) (tweakAddXOnlyPubKey ctx p (fromString zero))
-            == Just (BS.cons 0x02 (exportXOnlyPubKey ctx p))
-  it "negates a secret key whose public key has an odd y coordinate" $ \ctx ->
+      let p = derivePubKey k
+       in fmap (exportPubKey True) (tweakAddXOnlyPubKey p (fromString zero))
+            == Just (BS.cons 0x02 (exportXOnlyPubKey p))
+  it "negates a secret key whose public key has an odd y coordinate" $
     -- Key n - 1 has the public key -G, whose y coordinate is odd, so the key
     -- is negated to 1 before the zero tweak is added.
-    tweakAddXOnlySecKey ctx (fromString orderMinusOne) (fromString zero) `shouldBe` Just keyOne
-  it "fails when the result would be zero" $ \ctx -> do
+    tweakAddXOnlySecKey (fromString orderMinusOne) (fromString zero) `shouldBe` Just keyOne
+  it "fails when the result would be zero" $ do
     -- G has an even y coordinate, so key 1 is not negated: 1 + (n - 1) = 0.
-    tweakAddXOnlySecKey ctx keyOne (fromString orderMinusOne) `shouldBe` Nothing
-    tweakAddXOnlyPubKey ctx (derivePubKey ctx keyOne) (fromString orderMinusOne) `shouldBe` Nothing
+    tweakAddXOnlySecKey keyOne (fromString orderMinusOne) `shouldBe` Nothing
+    tweakAddXOnlyPubKey (derivePubKey keyOne) (fromString orderMinusOne) `shouldBe` Nothing
     -- Key n - 1 is negated to 1 first, with the same result.
-    tweakAddXOnlySecKey ctx (fromString orderMinusOne) (fromString orderMinusOne) `shouldBe` Nothing
-    tweakAddXOnlyPubKey ctx (derivePubKey ctx (fromString orderMinusOne)) (fromString orderMinusOne)
+    tweakAddXOnlySecKey (fromString orderMinusOne) (fromString orderMinusOne) `shouldBe` Nothing
+    tweakAddXOnlyPubKey (derivePubKey (fromString orderMinusOne)) (fromString orderMinusOne)
       `shouldBe` Nothing
 
 -- The internal key gives the internal public key. The tweak gives the tweaked
 -- secret key and the output key, and they match. The tweaked key signs the
 -- signature hash to the signature in the witness, which verifies against the
 -- output key.
-bip341VectorSpec :: Int -> BIP341Vector -> SpecWith Ctx
-bip341VectorSpec i v = it (show i) $ \ctx -> do
+bip341VectorSpec :: Int -> BIP341Vector -> Spec
+bip341VectorSpec i v = it (show i) $ do
   let k = fromString v.internalKey :: SecKey
       t = fromString v.tapTweak :: Tweak
       k' = fromString v.tweakedKey :: SecKey
       m = fromString v.sigHash :: Msg
       s = fromString v.keyPathSig :: SchnorrSig
-  bytesToHex (exportXOnlyPubKey ctx (derivePubKey ctx k)) `shouldBe` v.internalPub
-  tweakAddXOnlySecKey ctx k t `shouldBe` Just k'
-  fmap (bytesToHex . exportXOnlyPubKey ctx) (tweakAddXOnlyPubKey ctx (derivePubKey ctx k) t)
+  bytesToHex (exportXOnlyPubKey (derivePubKey k)) `shouldBe` v.internalPub
+  tweakAddXOnlySecKey k t `shouldBe` Just k'
+  fmap (bytesToHex . exportXOnlyPubKey) (tweakAddXOnlyPubKey (derivePubKey k) t)
     `shouldBe` Just v.outputKey
-  signSchnorr ctx k' m `shouldBe` s
-  verifySchnorr ctx (fromJust (importXOnlyPubKey ctx (hexToBytes v.outputKey))) s m `shouldBe` True
-
-contextSpec :: SpecWith Ctx
-contextSpec = describe "contexts" $ do
-  it "a clone signs and verifies like the original" $ \ctx -> do
-    clone <- cloneContext ctx
-    signMsg clone keyOne satoshiMsg `shouldBe` signMsg ctx keyOne satoshiMsg
-    verifySig clone (derivePubKey ctx keyOne) (signMsg ctx keyOne satoshiMsg) satoshiMsg `shouldBe` True
-  it "randomizing does not change signatures" $ \ctx -> do
-    let original = signMsg ctx keyOne satoshiMsg
-    randomizeContext ctx
-    signMsg ctx keyOne satoshiMsg `shouldBe` original
-  it "withContext gives a working context" $ \_ ->
-    withContext $ \ctx ->
-      bytesToHex (exportSig ctx (signMsg ctx keyOne satoshiMsg)) `shouldBe` satoshiDer
+  signSchnorr k' m `shouldBe` s
+  verifySchnorr (fromJust (importXOnlyPubKey (hexToBytes v.outputKey))) s m `shouldBe` True
 
 -- * Values built with the raw constructors of the Internal module
 
-rawValueSpec :: SpecWith Ctx
+rawValueSpec :: Spec
 rawValueSpec = describe "raw values from the Internal module" $ do
   describe "a public key with a zero x coordinate" $ do
-    it "does not verify, instead of aborting the process" $ \ctx ->
+    it "does not verify, instead of aborting the process" $
       property $ \(m :: Msg, k :: SecKey) ->
-        not (verifySig ctx zeroKey (signMsg ctx k m) m)
-    it "throws on export" $ \ctx ->
-      evaluate (exportPubKey ctx True zeroKey) `shouldThrow` anyErrorCall
-    it "throws on show" $ \_ ->
+        not (verifySig zeroKey (signMsg k m) m)
+    it "throws on export" $
+      evaluate (exportPubKey True zeroKey) `shouldThrow` anyErrorCall
+    it "throws on show" $
       evaluate (length (show zeroKey)) `shouldThrow` anyErrorCall
-    it "fails to tweak" $ \ctx -> do
-      tweakAddPubKey ctx zeroKey (fromString one) `shouldBe` Nothing
-      tweakMulPubKey ctx zeroKey (fromString one) `shouldBe` Nothing
-    it "fails to combine" $ \ctx ->
-      combinePubKeys ctx [derivePubKey ctx keyOne, zeroKey] `shouldBe` Nothing
-    it "does not verify a Schnorr signature" $ \ctx ->
-      verifySchnorr ctx zeroKey (signSchnorr ctx keyOne satoshiMsg) satoshiMsg `shouldBe` False
-    it "throws on x-only export" $ \ctx ->
-      evaluate (exportXOnlyPubKey ctx zeroKey) `shouldThrow` anyErrorCall
-    it "fails to tweak as an x-only key" $ \ctx ->
-      tweakAddXOnlyPubKey ctx zeroKey (fromString one) `shouldBe` Nothing
-  it "a public key off the curve fails to combine" $ \ctx ->
-    combinePubKeys ctx [derivePubKey ctx keyOne, PubKey (BS.replicate 64 1)] `shouldBe` Nothing
-  it "a zero secret key throws instead of signing" $ \ctx -> do
-    evaluate (signMsg ctx (SecKey (BS.replicate 32 0)) satoshiMsg) `shouldThrow` anyErrorCall
-    evaluate (derivePubKey ctx (SecKey (BS.replicate 32 0))) `shouldThrow` anyErrorCall
-    evaluate (signSchnorr ctx (SecKey (BS.replicate 32 0)) satoshiMsg) `shouldThrow` anyErrorCall
-  it "a zero secret key fails to tweak as an x-only key" $ \ctx ->
-    tweakAddXOnlySecKey ctx (SecKey (BS.replicate 32 0)) (fromString one) `shouldBe` Nothing
-  it "a tweak of n fails" $ \ctx -> do
-    tweakAddSecKey ctx keyOne (Tweak (hexToBytes order)) `shouldBe` Nothing
-    tweakNegate ctx (Tweak (hexToBytes order)) `shouldBe` Nothing
-    tweakAddXOnlySecKey ctx keyOne (Tweak (hexToBytes order)) `shouldBe` Nothing
-    tweakAddXOnlyPubKey ctx (derivePubKey ctx keyOne) (Tweak (hexToBytes order)) `shouldBe` Nothing
-  it "values of the wrong length throw before reaching the library" $ \ctx -> do
-    evaluate (derivePubKey ctx (SecKey "a")) `shouldThrow` anyErrorCall
-    evaluate (signMsg ctx (SecKey "a") satoshiMsg) `shouldThrow` anyErrorCall
-    evaluate (signMsg ctx keyOne (Msg "a")) `shouldThrow` anyErrorCall
-    evaluate (verifySig ctx (derivePubKey ctx keyOne) (Sig "a") satoshiMsg) `shouldThrow` anyErrorCall
-    evaluate (verifySig ctx (PubKey "a") (signMsg ctx keyOne satoshiMsg) satoshiMsg) `shouldThrow` anyErrorCall
-    evaluate (verifySig ctx (derivePubKey ctx keyOne) (signMsg ctx keyOne satoshiMsg) (Msg "a")) `shouldThrow` anyErrorCall
-    evaluate (exportSig ctx (Sig "a")) `shouldThrow` anyErrorCall
-    evaluate (exportCompactSig ctx (Sig "a")) `shouldThrow` anyErrorCall
-    evaluate (importCompactSig ctx (CompactSig "a")) `shouldThrow` anyErrorCall
-    evaluate (normalizeSig ctx (Sig "a")) `shouldThrow` anyErrorCall
-    evaluate (isLowS ctx (Sig "a")) `shouldThrow` anyErrorCall
-    evaluate (exportPubKey ctx True (PubKey "a")) `shouldThrow` anyErrorCall
-    evaluate (tweakAddSecKey ctx keyOne (Tweak "a")) `shouldThrow` anyErrorCall
-    evaluate (tweakMulSecKey ctx (SecKey "a") (fromString one)) `shouldThrow` anyErrorCall
-    evaluate (tweakAddPubKey ctx (PubKey "a") (fromString one)) `shouldThrow` anyErrorCall
-    evaluate (tweakMulPubKey ctx (derivePubKey ctx keyOne) (Tweak "a")) `shouldThrow` anyErrorCall
-    evaluate (tweakNegate ctx (Tweak "a")) `shouldThrow` anyErrorCall
-    evaluate (combinePubKeys ctx [derivePubKey ctx keyOne, PubKey "a"]) `shouldThrow` anyErrorCall
-    evaluate (tweakAddSecKey ctx (SecKey "a") (fromString one)) `shouldThrow` anyErrorCall
-    evaluate (tweakMulSecKey ctx keyOne (Tweak "a")) `shouldThrow` anyErrorCall
-    evaluate (tweakAddPubKey ctx (derivePubKey ctx keyOne) (Tweak "a")) `shouldThrow` anyErrorCall
-    evaluate (tweakMulPubKey ctx (PubKey "a") (fromString one)) `shouldThrow` anyErrorCall
-    evaluate (signMsgWith ctx keyOne satoshiMsg (Just "a")) `shouldThrow` anyErrorCall
-    evaluate (signSchnorr ctx (SecKey "a") satoshiMsg) `shouldThrow` anyErrorCall
-    evaluate (signSchnorr ctx keyOne (Msg "a")) `shouldThrow` anyErrorCall
-    evaluate (verifySchnorr ctx (derivePubKey ctx keyOne) (SchnorrSig "a") satoshiMsg) `shouldThrow` anyErrorCall
-    evaluate (verifySchnorr ctx (PubKey "a") (signSchnorr ctx keyOne satoshiMsg) satoshiMsg) `shouldThrow` anyErrorCall
-    evaluate (verifySchnorr ctx (derivePubKey ctx keyOne) (signSchnorr ctx keyOne satoshiMsg) (Msg "a")) `shouldThrow` anyErrorCall
-    evaluate (exportXOnlyPubKey ctx (PubKey "a")) `shouldThrow` anyErrorCall
-    evaluate (tweakAddXOnlyPubKey ctx (PubKey "a") (fromString one)) `shouldThrow` anyErrorCall
-    evaluate (tweakAddXOnlyPubKey ctx (derivePubKey ctx keyOne) (Tweak "a")) `shouldThrow` anyErrorCall
-    evaluate (tweakAddXOnlySecKey ctx (SecKey "a") (fromString one)) `shouldThrow` anyErrorCall
-    evaluate (tweakAddXOnlySecKey ctx keyOne (Tweak "a")) `shouldThrow` anyErrorCall
+    it "fails to tweak" $ do
+      tweakAddPubKey zeroKey (fromString one) `shouldBe` Nothing
+      tweakMulPubKey zeroKey (fromString one) `shouldBe` Nothing
+    it "fails to combine" $
+      combinePubKeys [derivePubKey keyOne, zeroKey] `shouldBe` Nothing
+    it "does not verify a Schnorr signature" $
+      verifySchnorr zeroKey (signSchnorr keyOne satoshiMsg) satoshiMsg `shouldBe` False
+    it "throws on x-only export" $
+      evaluate (exportXOnlyPubKey zeroKey) `shouldThrow` anyErrorCall
+    it "fails to tweak as an x-only key" $
+      tweakAddXOnlyPubKey zeroKey (fromString one) `shouldBe` Nothing
+  it "a public key off the curve fails to combine" $
+    combinePubKeys [derivePubKey keyOne, PubKey (BS.replicate 64 1)] `shouldBe` Nothing
+  it "a zero secret key throws instead of signing" $ do
+    evaluate (signMsg (SecKey (BS.replicate 32 0)) satoshiMsg) `shouldThrow` anyErrorCall
+    evaluate (derivePubKey (SecKey (BS.replicate 32 0))) `shouldThrow` anyErrorCall
+    evaluate (signSchnorr (SecKey (BS.replicate 32 0)) satoshiMsg) `shouldThrow` anyErrorCall
+  it "a zero secret key fails to tweak as an x-only key" $
+    tweakAddXOnlySecKey (SecKey (BS.replicate 32 0)) (fromString one) `shouldBe` Nothing
+  it "a tweak of n fails" $ do
+    tweakAddSecKey keyOne (Tweak (hexToBytes order)) `shouldBe` Nothing
+    tweakNegate (Tweak (hexToBytes order)) `shouldBe` Nothing
+    tweakAddXOnlySecKey keyOne (Tweak (hexToBytes order)) `shouldBe` Nothing
+    tweakAddXOnlyPubKey (derivePubKey keyOne) (Tweak (hexToBytes order)) `shouldBe` Nothing
+  it "values of the wrong length throw before reaching the library" $ do
+    evaluate (derivePubKey (SecKey "a")) `shouldThrow` anyErrorCall
+    evaluate (signMsg (SecKey "a") satoshiMsg) `shouldThrow` anyErrorCall
+    evaluate (signMsg keyOne (Msg "a")) `shouldThrow` anyErrorCall
+    evaluate (verifySig (derivePubKey keyOne) (Sig "a") satoshiMsg) `shouldThrow` anyErrorCall
+    evaluate (verifySig (PubKey "a") (signMsg keyOne satoshiMsg) satoshiMsg) `shouldThrow` anyErrorCall
+    evaluate (verifySig (derivePubKey keyOne) (signMsg keyOne satoshiMsg) (Msg "a")) `shouldThrow` anyErrorCall
+    evaluate (exportSig (Sig "a")) `shouldThrow` anyErrorCall
+    evaluate (exportCompactSig (Sig "a")) `shouldThrow` anyErrorCall
+    evaluate (importCompactSig (CompactSig "a")) `shouldThrow` anyErrorCall
+    evaluate (normalizeSig (Sig "a")) `shouldThrow` anyErrorCall
+    evaluate (isLowS (Sig "a")) `shouldThrow` anyErrorCall
+    evaluate (exportPubKey True (PubKey "a")) `shouldThrow` anyErrorCall
+    evaluate (tweakAddSecKey keyOne (Tweak "a")) `shouldThrow` anyErrorCall
+    evaluate (tweakMulSecKey (SecKey "a") (fromString one)) `shouldThrow` anyErrorCall
+    evaluate (tweakAddPubKey (PubKey "a") (fromString one)) `shouldThrow` anyErrorCall
+    evaluate (tweakMulPubKey (derivePubKey keyOne) (Tweak "a")) `shouldThrow` anyErrorCall
+    evaluate (tweakNegate (Tweak "a")) `shouldThrow` anyErrorCall
+    evaluate (combinePubKeys [derivePubKey keyOne, PubKey "a"]) `shouldThrow` anyErrorCall
+    evaluate (tweakAddSecKey (SecKey "a") (fromString one)) `shouldThrow` anyErrorCall
+    evaluate (tweakMulSecKey keyOne (Tweak "a")) `shouldThrow` anyErrorCall
+    evaluate (tweakAddPubKey (derivePubKey keyOne) (Tweak "a")) `shouldThrow` anyErrorCall
+    evaluate (tweakMulPubKey (PubKey "a") (fromString one)) `shouldThrow` anyErrorCall
+    evaluate (signMsgWith keyOne satoshiMsg (Just "a")) `shouldThrow` anyErrorCall
+    evaluate (signSchnorr (SecKey "a") satoshiMsg) `shouldThrow` anyErrorCall
+    evaluate (signSchnorr keyOne (Msg "a")) `shouldThrow` anyErrorCall
+    evaluate (verifySchnorr (derivePubKey keyOne) (SchnorrSig "a") satoshiMsg) `shouldThrow` anyErrorCall
+    evaluate (verifySchnorr (PubKey "a") (signSchnorr keyOne satoshiMsg) satoshiMsg) `shouldThrow` anyErrorCall
+    evaluate (verifySchnorr (derivePubKey keyOne) (signSchnorr keyOne satoshiMsg) (Msg "a")) `shouldThrow` anyErrorCall
+    evaluate (exportXOnlyPubKey (PubKey "a")) `shouldThrow` anyErrorCall
+    evaluate (tweakAddXOnlyPubKey (PubKey "a") (fromString one)) `shouldThrow` anyErrorCall
+    evaluate (tweakAddXOnlyPubKey (derivePubKey keyOne) (Tweak "a")) `shouldThrow` anyErrorCall
+    evaluate (tweakAddXOnlySecKey (SecKey "a") (fromString one)) `shouldThrow` anyErrorCall
+    evaluate (tweakAddXOnlySecKey keyOne (Tweak "a")) `shouldThrow` anyErrorCall
   where
     zeroKey = PubKey (BS.replicate 64 0)
 
 -- * Derived instances
 
-instanceSpec :: SpecWith Ctx
+instanceSpec :: Spec
 instanceSpec = describe "derived instances" $ do
-  it "equal values hash equally, whichever way they were built" $ \ctx ->
+  it "equal values hash equally, whichever way they were built" $
     property $ \(m :: Msg, k :: SecKey) ->
-      let p = derivePubKey ctx k
-          s = signMsg ctx k m
-          sc = signSchnorr ctx k m
-       in hash p == hash (fromJust (importPubKey ctx (exportPubKey ctx False p)))
-            && hash s == hash (fromJust (importSig ctx (exportSig ctx s)))
+      let p = derivePubKey k
+          s = signMsg k m
+          sc = signSchnorr k m
+       in hash p == hash (fromJust (importPubKey (exportPubKey False p)))
+            && hash s == hash (fromJust (importSig (exportSig s)))
             && hash k == hash (fromJust (secKey k.get))
             && hash sc == hash (fromJust (schnorrSig sc.get))
-  it "can be fully evaluated" $ \ctx -> do
-    let p = derivePubKey ctx keyOne
-        s = signMsg ctx keyOne satoshiMsg
-    ((p, s, keyOne, satoshiMsg, histTweak, exportCompactSig ctx s, signSchnorr ctx keyOne satoshiMsg) `deepseq` ())
+  it "can be fully evaluated" $ do
+    let p = derivePubKey keyOne
+        s = signMsg keyOne satoshiMsg
+    ((p, s, keyOne, satoshiMsg, histTweak, exportCompactSig s, signSchnorr keyOne satoshiMsg) `deepseq` ())
       `shouldBe` ()
