Xây dựng ứng dụng di động đúc cNFT trong chưa đầy 5 phút

Nội dung chính

Hướng dẫn này trình bày cách xây dựng một ứng dụng Android để đúc NFT (token không thể thay thế). Mục tiêu là giúp người dùng dễ dàng chụp ảnh và đúc NFT nén trên Solana. Để thực hiện điều này, chúng ta sẽ sử dụng Helius Mint API. API này giúp đúc NFT nén nhanh hơn và giảm thiểu mã soạn sẵn, tiết kiệm đáng kể thời gian và công sức lập kế hoạch. Ứng dụng Android của chúng ta sẽ được viết bằng Kotlin và Jetpack Compose.

NFT nén là gì?

NFT nén (cNFT) sử dụng cơ chế nén trạng thái và cây Merkle đồng thời để giảm chi phí lưu trữ. NFT nén có chi phí thấp hơn 2,400-24,000 lần so với phiên bản không nén, trong khi vẫn giữ nguyên cấu trúc.

Điều kiện tiên quyết

Trước khi bắt đầu hướng dẫn này, bạn nên có kiến thức cơ bản về phát triển Android bằng Kotlin và quen thuộc với Solana.

Công cụ

• Android Studio: Giraffe | Phiên bản 2022.3.1
• Trình giả lập hoặc thiết bị di động: Dùng để kiểm thử ứng dụng. Hãy đảm bảo đã cài đặt một ứng dụng ví tương thích với MWA (khuyến nghị dùng Solfare).

Khóa API

Để sử dụng Helius Mint API, bạn cần có khóa API. Sau đây là cách lấy khóa:

1. Truy cậpCổng thông tin dành cho nhà phát triển Helius.
2. Tạo tài khoản bằng ví Solana, tài khoản Google hoặc GitHub.
3. Sau khi đăng nhập, làm theo hướng dẫn để tạo khóa API.
4. Hãy lưu trữ khóa này an toàn vì khóa sẽ được dùng để thực hiện các lệnh gọi API trong suốt hướng dẫn.

Xây dựng ứng dụng

Bước 1: Thiết lập dự án

Chúng tôi đã chuẩn bị một cơ sở mã khởi đầu cho dự án này. 

Để bắt đầu, hãy làm theo các bước sau:

1. Truy cập gói khởi đầu trên GitHub.
2. Fork kho lưu trữ và sao chép kho này vào môi trường cục bộ.

Sau khi có mã nguồn trên máy, hãy tiếp tục với các bước sau:

1. Mở dự án trong Android Studio.
2. Chờ Gradle hoàn tất quá trình build.
3. Chạy mã.

Khám phá ứng dụng khởi đầu để làm quen với các tính năng. Hãy chú ý đến nút kết nối ví được tích hợp trong ứng dụng. Nút này cho phép bạn kết nối với bất kỳ ứng dụng ví nào tương thích với Mobile Wallet Adapter (MWA). Mobile Wallet Adapter (MWA) là một đặc tả giao thức để kết nối dApp di động với ứng dụng ví di động, cho phép giao tiếp phục vụ giao dịch Solana và ký thông điệp. Mobile Wallet Adapter hỗ trợ các ví này. Ngoài ra, bạn sẽ thấy nút "Chụp ảnh", hiện cho phép bạn chụp một bức ảnh.

Để lưu trữ khóa API Helius an toàn trong cơ sở mã, hãy mở tệp local.properties và thêm khóa API. Tệp này được thiết kế riêng để chứa thông tin nhạy cảm và được Git bỏ qua, nhờ đó bảo mật khóa API của bạn.

api_key=<your-api-key>

Tiếp theo, chúng ta sẽ viết logic để đúc ảnh đã chụp thành NFT nén (cNFT).

Bước 2: Logic đúc NFT

Mục tiêu của chúng ta là tích hợp nút "Chụp ảnh" với chức năng camera. Việc tích hợp nút này sẽ cho phép người dùng chụp ảnh và đúc ảnh thành NFT. Chúng tôi đã cung cấp mã khởi đầu để mở camera và chụp ảnh. Bây giờ, chúng ta sẽ tập trung vào việc tạo một hàm để quản lý quá trình đúc NFT.‍

Helius Mint API

Phương thức này đúc một NFT nén. Khi được thực thi, phương thức sẽ tạm dừng cho đến khi giao dịch được xác nhận. Quá trình này có thể mất đến 60 giây khi mạng hoạt động cao điểm. Truy cậptài liệu để tìm hiểu thêm.

Trước tiên, hãy mở java/com/example/hmint/MainViewModel.kt và tạo hàm mintCNft trong lớp MainViewModel:

@HiltViewModel
class MainViewModel @Inject constructor(
    private val walletAdapter: MobileWalletAdapter,
    private val walletConnectionUseCase: WalletConnectionUseCase,
) : ViewModel() {
    
    // ...

    fun mintCNft(imageUri: Uri, nftName: String, user: String) =
        viewModelScope.launch {
            _state.update {
                _state.value.copy(
                    isLoading = true,
                )
            }
        }

}

‍Chúng ta sẽ khởi tạo một coroutine để xử lý logic đúc NFT trong hàm này. Trước tiên, chúng ta sẽ lấy khóa API, định nghĩa các biến cần thiết và requestBody. Sau đó, bạn có thể tùy chỉnh requestBody để bổ sung các thuộc tính và dữ liệu theo yêu cầu:

withContext(viewModelScope.coroutineContext + Dispatchers.IO) {
    val apiKey = System.getProperty("api_key") ?: ""
    val url = URL("https://mainnet.helius-rpc.com/?api-key=$apiKey")
    val mediaType = "application/json".toMediaTypeOrNull()
    val requestBody = """
        {
            "jsonrpc": "2.0",
            "id": "helius-test",
            "method": "mintCompressedNft",
            "params": {
                "name": "$nftName",
                "symbol": "HM",
                "owner": "$user",
                "description": "This is a test cNFT minted by hMint app",
                "attributes": [
                    {
                        "trait_type": "hMint",
                        "value": "1"
                    }
                ],
                "imageUrl": "$imageUri",
                "sellerFeeBasisPoints": 6900
            }
        }
        ""${'"'}.trimIndent()
                                    
}

‍Tiếp theo, chúng ta sẽ tạo yêu cầu và khởi tạo một OkHttpClient:

val body = requestBody.toRequestBody(mediaType)
val request = Request.Builder()
    .url(url)
    .post(body)
    .addHeader("accept", "application/json")
    .addHeader("content-type", "application/json")
    .build()
val client = OkHttpClient()

‍Trước khi gọi client, hãy định nghĩa phản hồi trong một lớp dữ liệu. Tạo một package mới có tên data và một tệp mới NFTResponse.kt bên trong package đó để định nghĩa cấu trúc của phản hồi nhận được từ lệnh gọi API.

package com.example.hmint.data

data class NftMintResponse(
    val jsonrpc: String,
    val id: String,
    val result: MintResult
)

data class MintResult(
    val signature: String,
    val minted: Boolean,
    val assetId: String
)

‍Sau đó, trong lớp MainViewModel, hãy bổ sung một giá trị cho mintResponse vào lớp dữ liệu WalletViewState. Chúng ta sẽ cập nhật giá trị này khi nhận được phản hồi:

data class WalletViewState(
    // ...
    val mintResponse: String = ""
)

‍Quay lại hàm mintCNft, chúng ta sẽ sử dụng client để thực thi yêu cầu, đồng thời xử lý các lỗi hoặc phản hồi tương ứng. Khi nhận được phản hồi, chúng ta sẽ dùng Gson để phân tích dữ liệu vào lớp dữ liệu NFTMintResponse đã tạo trước đó, rồi cập nhật giá trị của mintResponse tương ứng:

client.newCall(request).enqueue(object : Callback {
    override fun onFailure(call: Call, e: IOException) {
        // Handle failure
        e.printStackTrace()
        Log.d(TAG, "NFT Mint Failed")
        _state.update {
            _state.value.copy(
                isLoading = false,
                mintResponse = "Mint Failed"
            )
        }
    }

    override fun onResponse(call: Call, response: Response) {
        if (response.isSuccessful) {
            val responseBody = response.body?.string() ?: ""
            val gson = Gson()
            val nft = gson.fromJson(responseBody, NftMintResponse::class.java)
            Log.d(TAG, "NFT Mint Successful: $nft")
            _state.update {
                _state.value.copy(
                    isLoading = false,
                    mintResponse = "Minted Successfully"
                )
            }

        } else {
            // Handle non-successful response
            Log.d(TAG, "NFT Mint Failed: ${response.code}")
            _state.update {
                _state.value.copy(
                    isLoading = false,
                    mintResponse = "Minted Failed"
                )
            }
        }
    }
})

‍Trong UI, chúng ta muốn cung cấp phản hồi cho người dùng về kết quả của hàm đúc NFT. Vì vậy, hãy mở java/com/example/hmint/composables/MintButton.kt, nơi chứa composable cùng mã UI và logic chụp ảnh. Trong MintButton, nơi chúng ta đã khai báo cameraLauncher, hãy gọi hàm mintCNft. Ngoài ra, hãy thêm mã để hiển thị Toast khi mintResponse được cập nhật.

@Composable
fun MintButton(
    mainViewModel: MainViewModel = hiltViewModel()
) {

    val cameraLauncher =
        rememberLauncherForActivityResult(ActivityResultContracts.TakePicture()) {
            // ...
            mainViewModel.mintCNft(uri, "hMint", viewState.userAddress)
        }

    
    viewState.mintResponse.let { message ->
        if(message.isNotEmpty()){
            Toast.makeText(LocalContext.current, message, Toast.LENGTH_SHORT).show()
        }
    }

    // ...
}

Bước 3: Chạy ứng dụng

‍Chúng ta đã hoàn tất giai đoạn viết mã, vì vậy hãy chạy ứng dụng. Trước tiên, hãy kết nối ví, sau đó chụp ảnh và theo dõi ứng dụng đúc NFT cho bạn một cách liền mạch.

Kết luận

Bạn đã làm rất tốt! Bạn đã phát triển thành công một ứng dụng Android cho phép người dùng đúc NFT nén. Nhờ Helius Mint API, việc đúc cNFT trở nên đơn giản hơn bao giờ hết và chỉ cần một lệnh gọi duy nhất.

Tiếp theo là gì?

Ứng dụng này vẫn còn rất nhiều điều để khám phá và cải tiến. Một trong số đó là tích hợp DAS API. API Tiêu chuẩn Tài sản Kỹ thuật số (DAS) là một đặc tả và hệ thống mã nguồn mở, cung cấp giao diện hợp nhất để tương tác với các tài sản kỹ thuật số, bao gồm token và NFT. API này hỗ trợ nhiều loại tài sản, bao gồm token có thể thay thế, NFT tiêu chuẩn và NFT nén.  Bằng cách sử dụng API, bạn có thể truy xuất tất cả NFT nén đã đúc và hiển thị chúng trong ứng dụng, giúp người dùng có cái nhìn toàn diện về tài sản kỹ thuật số của mình.

Tài nguyên liên quan

Để nâng cao chuyên môn về phát triển Android bằng Jetpack Compose, tích hợp blockchain Solana và tương tác với API, hãy khám phá các tài nguyên sau:

• Jetpack Compose
• Solana Mobile Adapter trong Kotlin
• Dependency injection bằng Hilt
• OkHttpClient trong Android
• Nén dữ liệu trên Solana
• Helius MINT API

Nếu cần trợ giúp hoặc hỗ trợ, đừng ngần ngại liên hệ với chúng tôi trên Discord. Cơ sở mã hoàn chỉnh có sẵn trên GitHub để bạn tham khảo thêm.

‍