XELIS Python SDK

Note: This SDK is for testing purposes and is not final. Features and implementations are subject to change.

A comprehensive Python library for interacting with the XELIS blockchain.

Features

• Wallet Operations - Send, receive, check balances
• Smart Contracts - Deploy and interact with contracts
• Daemon Client - Query blockchain data (blocks, transactions, network info)
• Event Monitoring - Subscribe to contract events
• Network Utilities - Network status, statistics, monitoring
• Transaction Builder - Fluent API for complex transactions
• Transaction Parser - Parse and export transaction data
• Price Converter - XEL price fetching and conversion
• Testing Framework - Unit test contracts locally
• CLI Tool - Command-line interface
• Utilities - Address validation, formatting, parameter builders

Installation

pip install xelis-sdk

Or install from source:

git clone https://github.com/YourUsername/xelis-python-sdk.git
cd xelis-python-sdk
pip install -e .

Quick Start

Wallet Operations

from xelis_sdk import Wallet

# Connect to wallet RPC
wallet = Wallet.connect_rpc(
    url="http://127.0.0.1:8081/json_rpc",
    username="myuser",
    password="mypassword"
)

# Get balance
balance = wallet.get_balance_xel()
print(f"Balance: {balance} XEL")

# Send XEL
result = wallet.send("xet:destination_address", 10.0)
print(f"TX Hash: {result['hash']}")

Daemon Queries

from xelis_sdk import DaemonClient

daemon = DaemonClient("http://127.0.0.1:8080/json_rpc")

# Get network info
info = daemon.get_info()
print(f"Height: {info['topoheight']}")
print(f"Difficulty: {info['difficulty']}")

# Get block
block = daemon.get_block_at_topoheight(1000)

# Get transaction
tx = daemon.get_transaction("tx_hash_here")

Smart Contracts

from xelis_sdk import Wallet, Contract
from xelis_sdk.utils import string_param, u64_param

wallet = Wallet.connect_rpc()

# Deploy contract
result = Contract.deploy(wallet, "MyContract.silex")
contract_address = result['contract']

# Interact with contract
contract = Contract(wallet, contract_address, entry_ids={
    "register": 25,
    "transfer": 26
})

result = contract.call(
    "register",
    parameters=[string_param("myname")],
    deposit_amount=10.0
)

Transaction Builder

from xelis_sdk import Wallet, TransactionBuilder

wallet = Wallet.connect_rpc()

# Build complex transaction
tx = TransactionBuilder(wallet)
tx.add_transfer("xet:address1", 5.0)
tx.add_transfer("xet:address2", 3.0)
tx.set_extra_data("Payment")
result = tx.build_and_send()

Event Monitoring

from xelis_sdk import DaemonClient, EventMonitor

daemon = DaemonClient()
monitor = EventMonitor(daemon, "contract_address")

@monitor.on("Register")
def on_register(event):
    print(f"New registration: {event}")

monitor.start()

Network Utilities

from xelis_sdk import Network

network = Network.testnet()

# Get status
status = network.get_status()
print(status)

# Get statistics
stats = network.get_block_stats()
print(f"Avg block time: {stats.avg_block_time}s")

Price Conversion

from xelis_sdk import PriceConverter

converter = PriceConverter()

# Get price
price = converter.get_price()
print(f"XEL: ${price.xel_usd}")

# Convert
usd = converter.xel_to_usd(100)
print(f"100 XEL = ${usd}")

Address Validation

from xelis_sdk import validate_address, get_network_from_address

# Validate address
if validate_address("xet:abc123..."):
    print("Valid address")

# Get network
network = get_network_from_address("xet:abc123...")
print(f"Network: {network}")  # "testnet"

Testing Contracts

from xelis_sdk import TestWallet, TestContract, ContractTestCase, run_tests

class TokenTests(ContractTestCase):
    def test_transfer(self):
        wallet1 = self.create_wallet(balance=1000)
        wallet2 = self.create_wallet(balance=0)
        contract = self.create_contract(entry_ids={"transfer": 0})
        
        contract.deploy(wallet1)
        contract.call(wallet1, "transfer", [], return_value=True)
        
        self.assert_call_count(contract, 1, "transfer")

run_tests(TokenTests)

CLI Tool

# Get network info
python -m xelis_cli info

# Check balance
python -m xelis_cli balance

# Send XEL
python -m xelis_cli send xet:address 10.0

# Get price
python -m xelis_cli price --amount 100

# Generate contract template
python -m xelis_cli template token --name MyToken --symbol MTK

Module Reference

Core Modules

Module	Description
Wallet	Wallet operations (balance, send, receive)
Contract	Smart contract interaction and deployment
RPCClient	Low-level RPC communication

Extended Modules

Module	Description
DaemonClient	Blockchain data queries
EventMonitor	Contract event monitoring
Network	Network status and utilities
TransactionBuilder	Fluent transaction building
TransactionParser	Transaction parsing and export
PriceConverter	Price fetching and conversion

Testing

Module	Description
TestWallet	Mock wallet for testing
TestContract	Contract test harness
ContractTestCase	Test case base class

Utilities

Function	Description
validate_address()	Validate XELIS address
string_param()	Build string parameter
u64_param()	Build u64 parameter
format_xel()	Format atomic units to XEL
parse_xel()	Convert XEL to atomic units

Requirements

• Python 3.8+
• requests

Related Projects

• XELIS Name Service (XNS) - Decentralized naming
• XELIS Contracts - Standard smart contracts
• XELIS Discord Bot - Discord integration
• XELIS Faucet - Testnet faucet

Contributing

See CONTRIBUTING.md for guidelines.

License

MIT License - See LICENSE for details.

Disclaimer

This SDK is provided for testing and development purposes. Always test thoroughly on testnet before using on mainnet. The developers are not responsible for any loss of funds.