from cdk import Wallet, WalletConfig, Database, CurrencyUnit
import asyncio

async def main():
    # Create an in-memory database for testing
    database = Database.memory()

    config = WalletConfig(
        target_proof_count= None
    )

    # Create wallet
    wallet = Wallet(
        "https://mint.example.com",
        CurrencyUnit.SAT(),
        "slot destroy disagree air autumn cigar fade hat black cherry repair scrub",
        database,
        config,
    )


    # Get mint information
    mint_info = await wallet.get_mint_info()
    print(f"Mint: {mint_info.name}")

    # Request a mint quote
    quote = await wallet.mint_quote(amount=100, description="Test deposit")
    print(f"Pay this invoice: {quote.request}")

    # Check balance
    balance = await wallet.total_balance()
    print(f"Balance: {balance} sats")


loop = asyncio.new_event_loop()
loop.run_until_complete(main())

from cdk import Wallet, WalletConfig, Database, CurrencyUnit

# Create SQLite database
database = await Database.sqlite("/path/to/wallet.db")

# Create wallet configuration
config = WalletConfig(
    target_proof_count=3  # Optional: target number of proofs
)

# Initialize wallet
wallet = Wallet(
	"https://mint.example.com",
	CurrencyUnit.SAT(),
	"slot destroy disagree air autumn cigar fade hat black cherry repair scrub",
	database,
	config,
)

from cdk import SendOptions, ReceiveOptions


# Send tokens
send_opts = SendOptions(
    memo="Payment for coffee",
    include_fees=True
)
token = await wallet.send(amount=50, send_options=send_opts)
print(f"Token: {token}")

# Receive tokens
receive_opts = ReceiveOptions(
    signature_flag="all"  # Verify all proofs
)
amount_received = await wallet.receive(token, receive_opts)
print(f"Received: {amount_received} sats")

# Create melt quote for Lightning payment
melt_quote = await wallet.melt_quote(
    invoice="lnbc...",  # Lightning invoice
    description="Outgoing payment"
)

# Execute the melt
result = await wallet.melt(melt_quote.quote_id)
print(f"Payment preimage: {result.preimage}")

from cdk import Mnemonic

# Generate new mnemonic
mnemonic = Mnemonic.generate(word_count=12)
print(f"Mnemonic: {mnemonic.phrase()}")

# Restore from existing mnemonic
existing = Mnemonic.from_string("word1 word2 ... word12")
seed = existing.to_seed(passphrase="")  # Optional passphrase

from cdk import TransactionDirection

# List all transactions
transactions = await wallet.list_transactions()
for tx in transactions:
    print(f"Amount: {tx.amount}, Date: {tx.created_at}")

# Filter by direction
sent = wallet.list_transactions(direction=TransactionDirection.OUTGOING)
received = wallet.list_transactions(direction=TransactionDirection.INCOMING)

# Get specific transaction
tx = wallet.get_transaction(transaction_id)

from cdk import ProofState

# Get proofs by state
pending = await wallet.get_proofs_by_state([ProofState.PENDING])
spent = await wallet.get_proofs_by_state([ProofState.SPENT])

# Check reserved balance
reserved = await wallet.reserved_balance()
print(f"Reserved: {reserved} sats")

from cdk import Database

# Create PostgreSQL database connection
database = Database.postgres(
    connection_string="postgresql://user:pass@localhost/cdk_wallet"
)

wallet = Wallet(
	"https://mint.example.com",
	CurrencyUnit.SAT(),
	"slot destroy disagree air autumn cigar fade hat black cherry repair scrub",
	database,
	config,
)