repositories {
    mavenCentral()
}

dependencies {
    // Core
    implementation("xyz.selenus:artemis-core:2.1.0")
    implementation("xyz.selenus:artemis-rpc:2.1.0")
    implementation("xyz.selenus:artemis-tx:2.1.0")
    
    // Mobile Wallet
    implementation("xyz.selenus:artemis-wallet-mwa-android:2.1.0")
    implementation("xyz.selenus:artemis-seed-vault:2.1.0")
    
    // Privacy
    implementation("xyz.selenus:artemis-privacy:2.1.0")
    
    // Add additional modules as needed
}

val adapter = MwaWalletAdapter.create(context)

// Connect to wallet
val result = adapter.connect()
if (result is WalletResult.Success) {
    val publicKey = result.publicKey
    println("Connected: ${publicKey.toBase58()}")
}

// Sign and send transaction
val signature = adapter.signAndSendTransaction(transaction)

val rpc = RpcClient.create(Cluster.MAINNET_BETA)

// Build a transfer instruction
val transferIx = SystemProgram.transfer(
    from = wallet.publicKey,
    to = recipient,
    lamports = 1_000_000_000 // 1 SOL
)

// Construct transaction
val tx = Transaction.new {
    feePayer(wallet.publicKey)
    recentBlockhash(rpc.getLatestBlockhash())
    instruction(transferIx)
}

// Sign and send
val signature = wallet.signAndSend(tx)

// Receiver generates stealth keys
val stealthKeys = StealthAddress.generateKeys()
val metaAddress = stealthKeys.toMetaAddress()

// Publish meta-address (e.g., in profile, QR code)
println("st:${metaAddress.toCompact()}")

// Sender derives one-time address
val (stealthPubkey, ephemeralPubkey) = StealthAddress.deriveAddress(metaAddress)

// Sender transfers to stealth address
val tx = SystemProgram.transfer(sender, stealthPubkey, amount)

// Receiver scans for payments and derives spending key
val spendingKey = StealthAddress.deriveSpendingKey(stealthKeys, ephemeralPubkey)

// Encrypt a memo for a recipient
val encrypted = EncryptedMemo.encrypt(
    message = "Payment for invoice #123",
    recipientPubkey = recipientPublicKey,
    type = MemoType.PAYMENT_NOTE
)

// Attach to transaction
val tx = Transaction.new {
    instruction(transferIx)
    instruction(MemoProgram.memo(encrypted.serialize()))
}

// Recipient decrypts
val decrypted = EncryptedMemo.decrypt(memoData, recipientPrivateKey)
println("Message: ${decrypted.message}")

val jupiter = JupiterClient.create()

// Get quote
val quote = jupiter.quote {
    inputMint(USDC_MINT)
    outputMint(SOL_MINT)
    amount(1_000_000) // 1 USDC
    slippageBps(50)   // 0.5%
}

println("Output: ${quote.outAmount} lamports")
println("Price impact: ${quote.priceImpactPct}%")

// Build swap transaction
val swap = jupiter.swap {
    quote(quote)
    userPublicKey(wallet.publicKey)
}

val signature = wallet.signAndSend(swap.transaction)

val idl = AnchorIdl.parse(idlJson)
val program = AnchorProgram(idl, programId, rpc)

// Build instruction
val ix = program.methods
    .instruction("initialize")
    .args(mapOf("name" to "MyToken", "decimals" to 9))
    .accounts {
        account("mint", mintPubkey)
        signer("authority", wallet.publicKey)
        program("systemProgram", SystemProgram.ID)
    }
    .build()

// Fetch account data
val state = program.account.type("TokenState").fetch(stateAddress)
println("Name: ${state.get<String>("name")}")

val nlp = NaturalLanguageBuilder.create(resolver)

val result = nlp.parse("send 1 SOL to alice.sol")

when (result) {
    is ParseResult.Success -> {
        println("Intent: ${result.intent.summary}")
        val tx = result.buildTransaction()
        wallet.signAndSend(tx)
    }
    is ParseResult.NeedsInfo -> {
        println("Missing: ${result.missing}")
    }
}

val universal = UniversalProgramClient.create(rpc)

// Discover program structure from on-chain data
val program = universal.discover(programId)

// View discovered instructions
program.instructions.forEach { instr ->
    println("${instr.name}: ${instr.discriminator.hex}")
}

// Build instruction using discovered pattern
val ix = program.instruction("transfer") {
    account("source", myWallet)
    account("destination", recipient)
    u64("amount", 1_000_000)
}

val stream = ZeroCopyAccountStream.create(wsClient)

// Subscribe with zero-copy field access
stream.subscribe(tokenAccount, TokenAccountSchema) { accessor ->
    val balance = accessor.getU64("amount")
    val owner = accessor.getPubkey("owner")
    updateUI(balance)
}

// Or use Kotlin Flow
stream.accountFlow(tokenAccount, TokenAccountSchema)
    .map { it.getU64("amount") }
    .distinctUntilChanged()
    .collect { balance -> updateBalance(balance) }

val actions = ActionsClient.create()

// Fetch action metadata
val action = actions.getAction("https://dial.to/donate/example")

println("Title: ${action.title}")
println("Description: ${action.description}")

// Execute the action
val response = actions.executeAction(action) {
    account(wallet.publicKey)
    input("amount", "1.5")
}

val signature = wallet.signAndSend(response.transaction)

// Create commitment
val (commitment, secret) = VerifiableRandomness.commit()

// Submit commitment on-chain, wait for reveal phase

// Reveal and generate verifiable random
val proof = VerifiableRandomness.reveal(secret, commitment)
val randomValue = proof.output

// Verify (anyone can verify)
val valid = VerifiableRandomness.verify(commitment, proof)