TITLE: Install CKB SDK Java with Maven DESCRIPTION: Add the CKB SDK Java dependency to your Maven `pom.xml` file to include the SDK in your project. Replace `{version}` with the desired SDK version. SOURCE: https://github.com/nervosnetwork/ckb-sdk-java/blob/master/README.md#_snippet_0 LANGUAGE: XML CODE: ``` org.nervos.ckb ckb {version} ``` ---------------------------------------- TITLE: Install CKB SDK Java with Gradle DESCRIPTION: Add the CKB SDK Java dependencies to your Gradle `build.gradle` file for project integration. Replace `{version}` with the desired SDK version. SOURCE: https://github.com/nervosnetwork/ckb-sdk-java/blob/master/README.md#_snippet_1 LANGUAGE: Groovy CODE: ``` implementation 'org.nervos.ckb:ckb:{version}' implementation 'org.nervos.ckb:core:{version}' implementation 'org.nervos.ckb:utils:{version}' ``` ---------------------------------------- TITLE: Initialize CKB RPC API Client in Java DESCRIPTION: Set up a CKB RPC API client instance to easily interact with a CKB node. This client allows calling any RPC APIs provided by CKB. SOURCE: https://github.com/nervosnetwork/ckb-sdk-java/blob/master/README.md#_snippet_2 LANGUAGE: Java CODE: ``` // Set up client. CkbRpcApi ckbAPi = new Api("http://127.0.0.1:8114"); ``` ---------------------------------------- TITLE: Sign and Send CKB Transaction with Java SDK DESCRIPTION: This snippet demonstrates the two-step process of signing a raw CKB transaction with a private key and then sending the signed transaction to a CKB node. It requires a prepared raw transaction instance of `TransactionWithScriptGroups` as input. SOURCE: https://github.com/nervosnetwork/ckb-sdk-java/blob/master/README.md#_snippet_6 LANGUAGE: Java CODE: ``` // 0. Set your private key String privateKey = "0x6c9ed03816e31..."; // 1. Sign transaction with your private key TransactionSigner.getInstance(Network.TESTNET).signTransaction(txWithScriptGroups, privateKey); // 2. Send transaction to CKB node byte[] txHash = ckbApi.sendTransaction(txWithScriptGroups.txView); System.out.println(Numeric.toHexString(txHash)); ``` ---------------------------------------- TITLE: Build CKB Transfer Transaction Manually in Java DESCRIPTION: Construct a CKB transfer transaction using the `CkbTransactionBuilder`. This builder encapsulates common logic, freeing developers from script details, transaction fee calculation, and change output management. SOURCE: https://github.com/nervosnetwork/ckb-sdk-java/blob/master/README.md#_snippet_4 LANGUAGE: Java CODE: ``` String sender = "ckt1qzda0cr08m85hc8jlnfp3zer7xulejywt49kt2rr0vthywaa50xwsq2qf8keemy2p5uu0g0gn8cd4ju23s5269qk8rg4r"; String receiver = "ckt1qzda0cr08m85hc8jlnfp3zer7xulejywt49kt2rr0vthywaa50xwsqg958atl2zdh8jn3ch8lc72nt0cf864ecqdxm9zf"; Iterator iterator = new InputIterator(sender); TransactionBuilderConfiguration configuration = new TransactionBuilderConfiguration(Network.TESTNET); configuration.setFeeRate(1000); TransactionWithScriptGroups txWithGroups = new CkbTransactionBuilder(configuration, iterator) .addOutput(receiver, 50100000000L) .setChangeOutput(sender) .build(); ``` ---------------------------------------- TITLE: Generate New CKB secp256k1_blake160 Address in Java DESCRIPTION: This example shows how to randomly generate a new CKB address, specifically the commonly used `secp256k1_blake160` type. It involves creating an ECKeyPair and then generating a corresponding Script and Address object. SOURCE: https://github.com/nervosnetwork/ckb-sdk-java/blob/master/README.md#_snippet_7 LANGUAGE: Java CODE: ``` // Generate a new address randomly ECKeyPair keyPair = Keys.createEcKeyPair(); Script script = Script.generateSecp256K1Blake160SignhashAllScript(keyPair)); Address address = new Address(script, Network.TESTNET); System.out.println(address.encode()); ``` ---------------------------------------- TITLE: Parse CKB Address String in Java DESCRIPTION: This example demonstrates how to parse an encoded CKB address string (preferably bech32m format) to retrieve its underlying script and network information. It also shows how to re-encode the address. SOURCE: https://github.com/nervosnetwork/ckb-sdk-java/blob/master/README.md#_snippet_9 LANGUAGE: Java CODE: ``` Address address = Address.decode("ckt1qyqxgp7za7dajm5wzjkye52asc8fxvvqy9eqlhp82g"); Script script = address.getScript(); Network network = address.getNetwork(); System.out.println(address.encode()); ``` ---------------------------------------- TITLE: Convert Public Key to CKB secp256k1_blake160 Address in Java DESCRIPTION: This snippet illustrates how to convert an elliptic curve public key into a `secp256k1_blake160` CKB address. The public key should be provided as a 65-length hex string (compressed format) without the '0x' prefix. SOURCE: https://github.com/nervosnetwork/ckb-sdk-java/blob/master/README.md#_snippet_8 LANGUAGE: Java CODE: ``` // The public key sent is an elliptic curve public key of compressed format - a 65-length hex (not include hex prefix 0x). byte[] publicKey = Numeric.hexStringToByteArray("0x24a501efd328e062c8675f2365970728c859c592beeefd6be8ead3d901330bc01"); Script script = Script.generateSecp256K1Blake160SignhashAllScript(publicKey); Address address = new Address(script, Network.TESTNET); System.out.println(address.encode()); ``` ---------------------------------------- TITLE: Retrieve Block Information by Hash in Java DESCRIPTION: Use the initialized CKB RPC API client to fetch block details by its hash from the CKB node. The `Numeric.hexStringToByteArray` utility converts a hexadecimal string to a byte array. SOURCE: https://github.com/nervosnetwork/ckb-sdk-java/blob/master/README.md#_snippet_3 LANGUAGE: Java CODE: ``` byte[] blockHash = Numeric.hexStringToByteArray("0x77fdd22f6ae8a717de9ae2b128834e9b2a1424378b5fc95606ba017aab5fed75"); Block block = ckbApi.getBlock(blockHash); ``` ---------------------------------------- TITLE: Signing CKB Transactions: Before and After SDK Update DESCRIPTION: This Java code snippet demonstrates the evolution of transaction signing in the CKB SDK. The 'Before' section shows the older approach using `MercuryScriptGroup` and `Secp256k1SighashBuilder` for manual signing. The 'Now' section illustrates the simplified process with the new `TransactionSigner` and `ScriptGroup`, requiring only the transaction with script groups and the private key for signing. SOURCE: https://github.com/nervosnetwork/ckb-sdk-java/blob/master/docs/migration-guide.md#_snippet_5 LANGUAGE: Java CODE: ``` // Before: static Map addressWithKey = new HashMap<>(); // omit: put private key to `addressWithKey` TransactionCompletionResponse txResponse = api.buildSimpleTransferTransaction(payload); List scriptGroups = txResponse.getScriptGroup(); Secp256k1SighashBuilder signBuilder = new Secp256k1SighashBuilder(txResponse.txView); for (MercuryScriptGroup sg : scriptGroups) { signBuilder.sign(sg, addressWithKey.get(sg.getAddress())); } Transaction tx = signBuilder.buildTx(); String hash = api.sendTransaction(tx); // Now: TransactionWithScriptGroups txWithScriptGroups = api.buildSimpleTransferTransaction(payload); TransactionSigner.getInstance(Network.TESTNET) .signTransaction(txWithScriptGroups, "0x6c9ed038....", "0x369dfe..."); // sign with private key byte[] txHash = api.sendTransaction(txWithScriptGroups.txView); ``` ---------------------------------------- TITLE: Parse CKB Address in Java DESCRIPTION: The new CKB Java SDK unifies address parsing and decoding into a single `Address` class, replacing multiple deprecated utility classes like `AddressParser`. This snippet demonstrates how to decode an encoded address string to retrieve the `Script` and `Network`. SOURCE: https://github.com/nervosnetwork/ckb-sdk-java/blob/master/docs/migration-guide.md#_snippet_0 LANGUAGE: Java CODE: ``` String encoded = "ckt1qzda..." // Before: AddressParseResult result = AddressParser.parse(encoded); Script script = result.script; Network network = result.network; // Now: Address address = Address.decode(encoded); Script script = address.getScript(); Network network = address.getNetwork(); ``` ---------------------------------------- TITLE: Encode CKB Address in Java DESCRIPTION: The new CKB Java SDK streamlines address encoding by providing an `encode()` method directly on the `Address` object. This replaces the static `AddressGenerator.generate()` method used in previous versions, simplifying the process of converting a `Script` and `Network` into an encoded address string. SOURCE: https://github.com/nervosnetwork/ckb-sdk-java/blob/master/docs/migration-guide.md#_snippet_1 LANGUAGE: Java CODE: ``` // Before: String encoded = AddressGenerator.generate(network, script); // Now: Address address = new Address(script, network); String encoded = address.encode(); ``` ---------------------------------------- TITLE: Build CKB Transfer Transaction with Mercury API in Java DESCRIPTION: Utilize the Mercury API to build a CKB transfer transaction. Mercury provides a high-level JSON-RPC interface for simplified transaction creation and asset management, requiring a deployed Mercury server. SOURCE: https://github.com/nervosnetwork/ckb-sdk-java/blob/master/README.md#_snippet_5 LANGUAGE: Java CODE: ``` String sender = "ckt1qzda0cr08m85hc8jlnfp3zer7xulejywt49kt2rr0vthywaa50xwsq0yvcdtsu5wcr2jldtl72fhkruf0w5vymsp6rk9r"; String receiver = "ckt1qzda0cr08m85hc8jlnfp3zer7xulejywt49kt2rr0vthywaa50xwsqvglkprurm00l7hrs3rfqmmzyy3ll7djdsujdm6z"; long ckbAmount = AmountUtils.ckbToShannon(100); // Convert CKB to Shannon (1 CKB = 10^8 Shannon) SimpleTransferPayloadBuilder builder = new SimpleTransferPayloadBuilder(); builder.addFrom(sender); builder.addTo(receiver, ckbAmount); builder.assetInfo(AssetInfo.newCkbAsset()); // Get an unsigned raw transaction with the help of Mercury MercuryApi mercuryApi = new DefaultMercuryApi("http://127.0.0.1:8116", false); TransactionWithScriptGroups txWithScriptGroups = mercuryApi.buildSimpleTransferTransaction(builder.build()); ``` ---------------------------------------- TITLE: Representing CKB Hashes in Java DESCRIPTION: The new CKB Java SDK changes the representation of 32-byte hashes from `String` to `byte[]` to align with CKB's internal data types. This change affects all instances where hashes are used, requiring updates to variable types and method signatures. SOURCE: https://github.com/nervosnetwork/ckb-sdk-java/blob/master/docs/migration-guide.md#_snippet_2 LANGUAGE: Java CODE: ``` // Before: String hash = tx.computeHash(); // Now: byte[] hash = tx.computeHash(); ``` ---------------------------------------- TITLE: Handling CKB Numeric Types in Java DESCRIPTION: The new CKB Java SDK aligns numeric type representations with CKB RPC types: `Uint32` maps to `int`, `Uint64` to `long`, and `Uint128` to `BigInteger`. Since CKB numbers are unsigned and Java's `int` and `long` are signed, specific `Long` utility methods like `compareUnsigned` should be used for unsigned operations, especially for fields like `Capacity`. SOURCE: https://github.com/nervosnetwork/ckb-sdk-java/blob/master/docs/migration-guide.md#_snippet_3 LANGUAGE: Java CODE: ``` // Before: capacity is a BigInteger if (capacity.compareTo(BigInteger.valueOf(140L)) >= 0) { // do something } // Now: capacity is a long if (Long.compareUnsigned(capacity, 140L) >= 0) { // do something } ``` ---------------------------------------- TITLE: Migrating CKB SDK Java Package Imports DESCRIPTION: Several important packages and classes have been relocated in the new CKB Java SDK to consolidate types. For instance, classes previously in `org.nervos.ckb.type.transaction` are now directly under `org.nervos.ckb.type`. Developers should update their import statements and class references accordingly. SOURCE: https://github.com/nervosnetwork/ckb-sdk-java/blob/master/docs/migration-guide.md#_snippet_4 LANGUAGE: Java CODE: ``` // Before: import org.nervos.ckb.type.transaction; // Now: import org.nervos.ckb.type; // Transaction class is in `org.nervos.ckb.type.transaction` before but now in `org.nervos.ckb.type`. Transaction tx = api.getTransaction(txHash).transaction; ```