from ordex.chain.chainparams import oxc_mainnet, oxg_mainnet
from ordex.wallet.address import generate_keypair

# OrdexCoin address
kp = generate_keypair(oxc_mainnet())
print(f"OXC P2PKH: {kp['p2pkh']}")    # X...
print(f"OXC P2SH:  {kp['p2sh']}")     # 7...
print(f"OXC Bech32: {kp['p2wpkh']}")  # oxc1...
print(f"OXC WIF:    {kp['wif']}")

# OrdexGold address
kp = generate_keypair(oxg_mainnet())
print(f"OXG P2PKH: {kp['p2pkh']}")    # G...
print(f"OXG Bech32: {kp['p2wpkh']}")  # oxg1...

from ordex.chain.chainparams import oxc_mainnet
from ordex.wallet.hd import HDWallet
from ordex.wallet.bip39 import mnemonic_to_seed

# From mnemonic
mnemonic = "abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about"
wallet = HDWallet.from_mnemonic(oxc_mainnet(), mnemonic)

# Derive addresses
account = wallet.derive_account(0)
external = wallet.derive_external_chain(account)
addr = wallet.derive_address(external, 0)

print(f"Address: {addr['p2pkh']}")
print(f"Path: {addr['path']}")  # m/44'/0'/0'/0/0

from ordex.wallet.signing import create_signed_transaction
from ordex.core.key import PrivateKey

# Create and sign a transaction
privkey = PrivateKey.generate()

inputs = [
    ('0000...0000', 0, 100000000),  # (prevout_hash, prevout_index, amount)
]
outputs = [
    ('Xu9T...nQw', 50000000),  # (address, amount in satoshis)
]

tx = create_signed_transaction(inputs, outputs, privkey)
print(f"Signed txid: {tx.txid().hex()}")

from ordex.rpc import OrdexServices, create_services

# Initialize all services
services = create_services([{
    "url": "http://localhost:8332",
    "user": "rpcuser",
    "password": "rpcpass"
}])

# Use services
fees = services.mempool.get_fees()
tip = services.blocks.get_tip()
stats = services.get_stats()

from ordex.rpc.client import RpcClient
from ordex.wallet.utxo import UTXO, CoinSelector, CoinSelectionStrategy

rpc = RpcClient()

# Get UTXOs from node
result = rpc.listunspent(minconf=1)
utxos = [UTXO.from_rpc(u) for u in result]

# Select coins using greedy strategy
selector = CoinSelector(strategy=CoinSelectionStrategy.GREEDY)
result = selector.select(utxos, target_amount=50000000, fee_per_byte=1)

print(f"Selected {len(result.utxos)} UTXOs")
print(f"Total: {result.total_amount} satoshis")
print(f"Fee: {result.fee} satoshis")

from ordex.rpc.client import RpcClient
from ordex.wallet.utxo import WalletManager, CoinSelectionStrategy
from pathlib import Path

rpc = RpcClient()

# Create manager with persistent storage
manager = WalletManager(rpc, storage_path=Path("./wallets"))

# Create multiple wallets
manager.create_wallet("Savings", "wallet_savings", addresses=["XvX26g..."])
manager.create_wallet("Spending", "wallet_spending")

# Generate addresses for spending wallet
manager.generate_address("wallet_spending")

# Sync and get stats
stats = manager.sync_wallet("wallet_savings")
print(stats.summary())

# Full report
print(manager.full_stats_report())

from ordex.rpc.client import RpcClient

rpc = RpcClient("http://127.0.0.1:25175", "rpcuser", "rpcpass")
info = rpc.getblockchaininfo()
print(f"Chain: {info['chain']}, Height: {info['blocks']}")

import asyncio
from ordex.chain.chainparams import oxc_mainnet
from ordex.net.connection import NodeConnection

async def main():
    conn = NodeConnection("127.0.0.1", 25174, oxc_mainnet())
    await conn.connect()
    await conn.handshake()
    print(f"Peer: {conn.peer_version.user_agent}")
    await conn.close()

asyncio.run(main())

import asyncio
from ordex.chain.chainparams import oxc_mainnet
from ordex.net.connection import NodeConnection
from ordex.net.sync import BlockSynchronizer

async def main():
    conn = NodeConnection("127.0.0.1", 25174, oxc_mainnet())
    await conn.connect()
    await conn.handshake()
    
    sync = BlockSynchronizer(conn, oxc_mainnet())
    headers = await sync.download_headers(peer_height=800000)
    print(f"Downloaded {len(headers)} headers")
    
    await conn.close()

asyncio.run(main())