PrivateKey

32-byte secp256k1 private key

32-byte secp256k1 private key used for signing transactions and ECDH key derivation.

Overview

PrivateKey is a specialized Bytes32 type representing a secp256k1 private key. It's used for transaction signing and deriving shared secrets via ECDH.

Definition

class PrivateKey(Bytes32):
    """32-byte secp256k1 private key."""

Inheritance

• Inherits from Bytes32

• Inherits all validation and construction methods from Bytes32

• Always exactly 32 bytes

Construction

PrivateKey can be constructed from:

• Hex strings (with or without "0x" prefix)

• Raw bytes objects

• Integer values

Parameters

Parameter	Type	Required	Description
val	bytes | str | int	Yes	The value to convert to a 32-byte private key

Raises

• ValueError - If the resulting length is not exactly 32 bytes

Examples

From Hex String

from seismic_web3 import PrivateKey

# With 0x prefix
private_key = PrivateKey("0x1234567890abcdef" + "0" * 48)

# From environment variable
import os
private_key = PrivateKey.from_hex_str(os.environ["PRIVATE_KEY"])

Generate Random Private Key

import os
from seismic_web3 import PrivateKey

# Generate cryptographically secure random key
private_key = PrivateKey(os.urandom(32))

Use with Client

import os
from seismic_web3 import create_wallet_client, PrivateKey, SEISMIC_TESTNET

private_key = PrivateKey.from_hex_str(os.environ["PRIVATE_KEY"])

w3 = create_wallet_client(
    rpc_url="https://gcp-1.seismictest.net/rpc",
    chain=SEISMIC_TESTNET,
    account=private_key,
)

Use with EIP-712 Signing

import os
from seismic_web3 import sign_seismic_tx_eip712, PrivateKey

# Build unsigned transaction
unsigned_tx = ...  # UnsignedSeismicTx

# Sign with private key
private_key = PrivateKey.from_hex_str(os.environ["PRIVATE_KEY"])
signed_tx = sign_seismic_tx_eip712(unsigned_tx, private_key)

Security Considerations

• Never log or print private keys - They provide full control over the account

• Store securely - Use environment variables or secure key management systems

• Use OS-provided randomness - os.urandom() for key generation

• Avoid hardcoding - Never commit private keys to source control

Methods

from_hex_str()

Create a PrivateKey from a hex string, with or without a 0x prefix.

@staticmethod
def from_hex_str(hex_string: str) -> PrivateKey:

Parameters

Parameter	Type	Required	Description
hex_string	str	Yes	Hex-encoded private key, with or without "0x" prefix

Returns

• PrivateKey — A new 32-byte private key instance

Example

import os
from seismic_web3 import PrivateKey

# From environment variable (handles 0x prefix automatically)
pk = PrivateKey.from_hex_str(os.environ["PRIVATE_KEY"])

# From a literal hex string
pk = PrivateKey.from_hex_str("0xac0974bec39a17e36ba4a6b4d238ff944bacb478cbed5efcae784d7bf4f2ff80")

---

to_0x_hex()

Inherited from Bytes32. Returns the hex string representation with "0x" prefix. Use carefully with private keys.

Properties

• Immutable - Cannot be modified after construction

• Hashable - Can be used as dictionary keys

• 32 bytes - Always exactly 32 bytes

• Compatible with bytes - Passes isinstance(x, bytes) checks

Notes

• Used exclusively for secp256k1 curve operations

• Compatible with eth_keys.PrivateKey after conversion: eth_keys.PrivateKey(bytes(private_key))

• No validation is performed on the mathematical validity of the key (i.e., no check that 0 < key < n)

See Also

• hex_to_bytes - General-purpose hex string to bytes conversion

• Bytes32 - Parent type

• CompressedPublicKey - Corresponding public key type

• sign_seismic_tx_eip712 - Sign transactions with private key

• create_wallet_client - Create client with private key

• EncryptionState - Derives keys from private key