tessl/pypi-xrpl-py
A complete Python library for interacting with the XRP Ledger blockchain, providing transaction creation, account management, and comprehensive XRPL protocol support
core.mddocs/
Core Cryptographic Operations
Low-level cryptographic functions, address encoding/decoding, binary transaction encoding, and fundamental XRPL constants that form the foundation of XRPL interactions.
Capabilities
Cryptographic Key Operations
Generate seeds, derive keypairs, and perform cryptographic signing operations using Ed25519 or secp256k1 algorithms.
from xrpl.core.keypairs import (
generate_seed, derive_keypair, derive_classic_address,
sign, is_valid_message
)
def generate_seed(
algorithm: CryptoAlgorithm = CryptoAlgorithm.ED25519,
entropy: bytes = None
) -> str:
"""
Generate a cryptographic seed for creating keypairs.
Args:
algorithm: Cryptographic algorithm to use
entropy: Optional entropy bytes for seed generation
Returns:
Base58-encoded seed string
"""
def derive_keypair(seed: str, algorithm: CryptoAlgorithm = None) -> tuple[str, str]:
"""
Derive a public/private keypair from a seed.
Args:
seed: Base58-encoded seed string
algorithm: Cryptographic algorithm (inferred from seed if not provided)
Returns:
Tuple of (public_key_hex, private_key_hex)
"""
def derive_classic_address(public_key: str) -> str:
"""
Derive XRPL classic address from public key.
Args:
public_key: Hex-encoded public key
Returns:
Classic address string
"""
def sign(message: bytes, private_key: str) -> str:
"""
Sign a message with a private key.
Args:
message: Message bytes to sign
private_key: Hex-encoded private key
Returns:
Hex-encoded signature
"""
def is_valid_message(message: bytes, signature: str, public_key: str) -> bool:
"""
Verify a message signature.
Args:
message: Original message bytes
signature: Hex-encoded signature
public_key: Hex-encoded public key
Returns:
True if signature is valid
"""Address Encoding and Decoding
Convert between different XRPL address formats and encode/decode various XRPL identifiers.
from xrpl.core.addresscodec import (
encode_classic_address, decode_classic_address,
classic_address_to_xaddress, xaddress_to_classic_address,
is_valid_classic_address, is_valid_xaddress,
ensure_classic_address,
encode_seed, decode_seed,
encode_account_public_key, decode_account_public_key,
encode_node_public_key, decode_node_public_key
)
def encode_classic_address(public_key: str, tag: int = None, is_test: bool = False) -> str:
"""
Encode a classic XRPL address from public key.
Args:
public_key: Hex-encoded public key
tag: Optional destination tag
is_test: Whether this is a test network address
Returns:
Classic address string
"""
def decode_classic_address(address: str) -> bytes:
"""
Decode a classic address to its raw bytes.
Args:
address: Classic address string
Returns:
Address bytes
"""
def classic_address_to_xaddress(address: str, tag: int = None, is_test_network: bool = False) -> str:
"""
Convert classic address to X-address format.
Args:
address: Classic address string
tag: Optional destination tag
is_test_network: Whether this is a test network
Returns:
X-address string
"""
def xaddress_to_classic_address(xaddress: str) -> tuple[str, int, bool]:
"""
Convert X-address to classic address format.
Args:
xaddress: X-address string
Returns:
Tuple of (classic_address, tag, is_test_network)
"""
def is_valid_classic_address(address: str) -> bool:
"""Check if string is a valid classic address format."""
def is_valid_xaddress(address: str) -> bool:
"""Check if string is a valid X-address format."""
def ensure_classic_address(address: str) -> str:
"""
Ensure address is in classic format, converting from X-address if needed.
Args:
address: Address in any valid format
Returns:
Classic address string
"""Binary Transaction Encoding
Encode and decode XRPL transactions to/from binary format for signing and network transmission.
from xrpl.core.binarycodec import (
encode, decode,
encode_for_signing, encode_for_multisigning,
encode_for_signing_batch, encode_for_signing_claim
)
def encode(transaction_object: dict) -> str:
"""
Encode transaction object to binary hex format.
Args:
transaction_object: Transaction as dictionary
Returns:
Hex-encoded binary transaction
"""
def decode(hex_string: str) -> dict:
"""
Decode binary transaction data to transaction object.
Args:
hex_string: Hex-encoded binary transaction
Returns:
Transaction object as dictionary
"""
def encode_for_signing(transaction: dict) -> str:
"""
Encode transaction for signing (adds signing prefix).
Args:
transaction: Transaction object
Returns:
Hex-encoded transaction ready for signing
"""
def encode_for_multisigning(transaction: dict, signing_account: str) -> str:
"""
Encode transaction for multisigning.
Args:
transaction: Transaction object
signing_account: Account address doing the signing
Returns:
Hex-encoded transaction ready for multisigning
"""
def encode_for_signing_batch(transactions: list[dict]) -> list[str]:
"""
Encode multiple transactions for batch signing.
Args:
transactions: List of transaction objects
Returns:
List of hex-encoded transactions ready for signing
"""Constants and Types
from xrpl.constants import (
SEED_LENGTH, XRPL_ALPHABET,
ISO_CURRENCY_REGEX, HEX_REGEX, HEX_CURRENCY_REGEX, HEX_MPTID_REGEX,
MIN_IOU_EXPONENT, MAX_IOU_EXPONENT, MAX_IOU_PRECISION,
MIN_IOU_MANTISSA, MAX_IOU_MANTISSA,
IOU_DECIMAL_CONTEXT, DROPS_DECIMAL_CONTEXT
)
# Cryptographic algorithm options
class CryptoAlgorithm(str, Enum):
ED25519 = "ed25519"
SECP256K1 = "secp256k1"
# Regex patterns for validation
ISO_CURRENCY_REGEX: Pattern[str] # Matches ISO currency codes like "USD"
HEX_REGEX: Pattern[str] # Matches hex strings
HEX_CURRENCY_REGEX: Pattern[str] # Matches hex-encoded currencies (40 chars)
HEX_MPTID_REGEX: Pattern[str] # Matches MPT IDs (48 hex chars)
# IOU amount constants
SEED_LENGTH: int # Standard seed length
MIN_IOU_EXPONENT: int = -96
MAX_IOU_EXPONENT: int = 80
MAX_IOU_PRECISION: int = 16
MIN_IOU_MANTISSA: int = 10**15
MAX_IOU_MANTISSA: int = 10**16 - 1
# Decimal contexts for precise arithmetic
IOU_DECIMAL_CONTEXT: Context # For IOU amounts
DROPS_DECIMAL_CONTEXT: Context # For XRP dropsExceptions
class XRPLAddressCodecException(XRPLException):
"""Exception for address codec operations."""
class XRPLBinaryCodecException(XRPLException):
"""Exception for binary codec operations."""
class XRPLKeypairsException(XRPLException):
"""Exception for keypair operations."""Usage Examples
Creating a New Wallet from Scratch
from xrpl.core.keypairs import generate_seed, derive_keypair, derive_classic_address
from xrpl import CryptoAlgorithm
# Generate a new seed
seed = generate_seed(CryptoAlgorithm.ED25519)
print(f"Seed: {seed}")
# Derive keypair from seed
public_key, private_key = derive_keypair(seed)
print(f"Public key: {public_key}")
# Derive address from public key
address = derive_classic_address(public_key)
print(f"Address: {address}")Address Format Conversions
from xrpl.core.addresscodec import (
classic_address_to_xaddress, xaddress_to_classic_address,
is_valid_classic_address, ensure_classic_address
)
# Convert classic to X-address
classic_addr = "rN7n7otQDd6FczFgLdSqtcsAUxDkw6fzRH"
xaddr = classic_address_to_xaddress(classic_addr, tag=12345, is_test_network=True)
print(f"X-address: {xaddr}")
# Convert back to classic
classic_addr2, tag, is_test = xaddress_to_classic_address(xaddr)
print(f"Classic: {classic_addr2}, Tag: {tag}, TestNet: {is_test}")
# Validate address formats
print(f"Valid classic: {is_valid_classic_address(classic_addr)}")
# Ensure classic format (converts X-address if needed)
classic_addr3 = ensure_classic_address(xaddr)
print(f"Ensured classic: {classic_addr3}")Binary Transaction Encoding
from xrpl.core.binarycodec import encode, decode, encode_for_signing
from xrpl.models.transactions import Payment
# Create a payment transaction
payment = Payment(
account="rN7n7otQDd6FczFgLdSqtcsAUxDkw6fzRH",
destination="rLNaPoKeeBjZe2qs6x52yVPZpZ8td4dc6w",
amount="1000000",
sequence=1,
fee="12"
)
# Encode to binary format
binary_tx = encode(payment.to_dict())
print(f"Binary transaction: {binary_tx}")
# Decode back to transaction object
decoded_tx = decode(binary_tx)
print(f"Decoded transaction: {decoded_tx}")
# Encode for signing (adds signing prefix)
signing_blob = encode_for_signing(payment.to_dict())
print(f"Signing blob: {signing_blob}")Install with Tessl CLI
npx tessl i tessl/pypi-xrpl-py