OpenDLT Accumulate Python SDK

Production-ready Python SDK for the Accumulate blockchain protocol. Supports all signature types, V2/V3 API endpoints, and provides a high-level signing API with automatic version tracking.

Features

• Multi-Signature Support: Ed25519, RCD1, BTC, ETH, RSA-SHA256, ECDSA-SHA256
• Smart Signing: Automatic signer version tracking with SmartSigner
• Complete Protocol: All 33 transaction types and account operations
• Cross-Platform: Pure Python implementation
• Network Ready: Mainnet, Testnet (Kermit), and local DevNet support

Installation

pip install accumulate-sdk-opendlt

Or install from source:

git clone https://github.com/opendlt/accumulate-python-client.git
cd accumulate-python-client/unified
pip install -e ".[dev]"

Quick Start

from accumulate_client import Accumulate
from accumulate_client.crypto.ed25519 import Ed25519KeyPair

# Connect to Kermit testnet
client = Accumulate(
    "https://kermit.accumulatenetwork.io/v2",
    v3_endpoint="https://kermit.accumulatenetwork.io/v3",
)

# Generate key pair and derive lite account URLs
kp = Ed25519KeyPair.generate()
lid = kp.derive_lite_identity_url()
lta = kp.derive_lite_token_account_url("ACME")

print(f"Lite Identity: {lid}")
print(f"Lite Token Account: {lta}")

# Query account
account = client.query(lta)
print(f"Account: {account}")

API Levels

The SDK provides three levels of abstraction:

SmartSigner + TxBody (Recommended for most use cases)

SmartSigner handles the full sign/submit/poll lifecycle. Under the hood it:

1. Queries the signer version from the network
2. Binary-encodes signature metadata, transaction header, and body
3. Computes tx_hash = SHA256(SHA256(header) + SHA256(body))
4. Computes and signs preimage = SHA256(initiator + tx_hash)
5. Assembles the JSON envelope and submits via V3 JSON-RPC
6. Polls until the transaction is delivered or fails

TxBody is a static factory that returns correctly-structured body dicts.

from accumulate_client import Accumulate
from accumulate_client.crypto.ed25519 import Ed25519KeyPair
from accumulate_client.convenience import SmartSigner, TxBody

client = Accumulate("https://kermit.accumulatenetwork.io")
kp = Ed25519KeyPair.generate()
lid = kp.derive_lite_identity_url()
lta = kp.derive_lite_token_account_url("ACME")

signer = SmartSigner(client.v3, kp, lid)

result = signer.sign_submit_and_wait(
    principal=lta,
    body=TxBody.send_tokens_single(
        to_url="acc://recipient.acme/tokens",
        amount="100000000",  # 1 ACME
    ),
    memo="Payment",
)

if result.success:
    print(f"Transaction delivered: {result.txid}")

Supported Signature Types

Signer classes are in accumulate_client.signers.

Transaction Builders

Build transactions using the TxBody class:

from accumulate_client.convenience import TxBody

# Send tokens
TxBody.send_tokens_single(to_url="acc://...", amount="100000000")

# Add credits
TxBody.add_credits(recipient="acc://...", amount=1000000, oracle=oracle_price)

# Create ADI
TxBody.create_identity(url="acc://my-adi.acme", key_book_url="acc://my-adi.acme/book", public_key_hash=key_hash)

# Create token account
TxBody.create_token_account(url="acc://my-adi.acme/tokens", token_url="acc://ACME")

# Create custom token
TxBody.create_token(url="acc://my-adi.acme/mytoken", symbol="MTK", precision=8)

# Write data
TxBody.write_data(entries_hex=[data_hex])

Network Endpoints

from accumulate_client import Accumulate

# Public networks
mainnet = Accumulate.mainnet()
testnet = Accumulate.testnet()

# Kermit testnet (explicit endpoints)
kermit = Accumulate(
    "https://kermit.accumulatenetwork.io/v2",
    v3_endpoint="https://kermit.accumulatenetwork.io/v3",
)

# Local development
devnet = Accumulate.devnet()

Examples

See examples/v3/ for complete working examples:

Run any example:

python examples/v3/example_01_lite_identities.py

Project Structure

src/accumulate_client/
├── facade.py          # Accumulate unified client (V2/V3)
├── convenience.py     # SmartSigner, TxBody, QuickStart, binary encoding helpers
├── crypto/            # Key pair implementations (Ed25519, Secp256k1)
├── signers/           # Signature type classes (Ed25519, RCD1, BTC, ETH)
├── tx/                # Transaction builders and header options
├── types.py           # Protocol types (103 types)
├── enums.py           # Protocol enums (14 enums)
└── runtime/           # URL handling, codecs, validation
examples/
└── v3/                # V3 API examples (13 examples, multiple API levels)
tests/
├── unit/              # Unit tests
├── integration/       # Network integration tests
└── conformance/       # Cross-implementation compatibility

Development

Running Tests

pytest tests/                    # All tests
pytest tests/unit/               # Unit tests only
pytest tests/integration/        # Integration tests (requires network)

Code Quality

ruff check src/
mypy src/
ruff format src/

Self-Check

python tooling/scripts/selfcheck.py

Expected output:

Status: PASS
Checks: 11/11 passed (100.0%)
Enums=14, Types=103, Signatures=16, Transactions=33, API methods=35

Error Handling

from accumulate_client.runtime.errors import (
    AccumulateError,
    ValidationError,
    NetworkError,
)

try:
    result = client.submit(envelope)
except ValidationError as e:
    print(f"Validation error: {e}")
except NetworkError as e:
    print(f"Network error: {e}")
except AccumulateError as e:
    print(f"API error: {e.code} - {e}")

License

MIT License - see LICENSE for details.

Links

• Accumulate Protocol
• API Documentation
• Kermit Testnet Explorer