XRPLF/xrpl4j

Letzte erfasste Quellaktivität: 22. Mai 2026 um 20:52

SkillsMP-Katalog aktualisiert: 2. November 2026 um 18:02

gesammelte Skills: 1

GitHub-Stars: 135
GitHub-Forks: 88

Mit einem KI-Assistenten installieren

Diesen Prompt kopieren und in den verwendeten KI-Assistenten einfügen.

Follow https://skillsmp.com/skill-install/prompt.md to install Agent Skills from https://github.com/XRPLF/xrpl4j.

README des Repositorys

README-Quelldatei: README.md

README-Quelldatei lesen

Vollständige README anzeigen

# xrpl4j: A 100% Java SDK for the XRP Ledger [![codecov][codecov-image]][codecov-url] [![issues][github-issues-image]][github-issues-url] [![javadoc-core](https://javadoc.io/badge2/org.xrpl/xrpl4j-core/javadoc.svg?color=blue)](https://javadoc.io/doc/org.xrpl/xrpl4j-core/latest/index.html) [![javadoc-client](https://javadoc.io/badge2/org.xrpl/xrpl4j-client/javadoc.svg?color=blue)](https://javadoc.io/doc/org.xrpl/xrpl4j-client/latest/index.html) This project is a pure Java implementation of an SDK that works with the XRP Ledger. This library supports XRPL key and address generation, transaction serialization and signing, provides useful Java bindings for XRP Ledger objects and `rippled` request/response objects, and also provides a JSON-RPC client for interacting with XRPL nodes. ## Documentation - [Get Started Using Java](https://xrpl.org/get-started-using-java.html): a tutorial for building a very simple XRP Ledger-connected app. - Example usage can be found in the `xrpl4j-integration-tests` module [here](https://github.com/XRPLF/xrpl4j/tree/main/xrpl4j-integration-tests/src/test/java/org/xrpl/xrpl4j/tests). ## Usage ### Requirements - JDK 1.8 or higher - A Java project manager such as Maven or Gradle ### Maven Installation You can use one or more xrpl4j modules in your Maven project by using the current [BOM](https://howtodoinjava.com/maven/maven-bom-bill-of-materials-dependency/) like this: ``` <dependencyManagement> <dependencies> <dependency> <groupId>org.xrpl</groupId> <artifactId>xrpl4j-bom</artifactId> <version>5.0.0</version> <type>pom</type> <scope>import</scope> </dependency> </dependencies> </dependencyManagement> ``` Then you can add one or both of the `xrpl4j-core` and `xrpl4j-client` modules found in the BOM to your `pom.xml`. For example: ``` <dependencies> ... <dependency> <groupId>org.xrpl</groupId> <artifactId>xrpl4j-core</artifactId> </dependency> <dependency> <groupId>org.xrpl</groupId> <artifactId>xrpl4j-client</artifactId> </dependency> ... </dependencies> ``` See the [`xrpl4j-client` README](./xrpl4j-client/README.md) for details on configuring `XrplClient`, including how to supply a pooled HTTP client. ### Core Objects This library provides Java objects modeling [XRP Ledger Objects](https://xrpl.org/ledger-data-formats.html), [Transactions](https://xrpl.org/transaction-formats.html), and [request parameters](https://xrpl.org/request-formatting.html)/[response results](https://xrpl.org/response-formatting.html) for the [rippled API](https://xrpl.org/public-rippled-methods.html). The objects in this module are annotated with `@Value.Immutable` from the [immutables library](https://immutables.github.io/), which generates immutable implementations with builders, copy constructors, and other useful boilerplate code. For example, the following code constructs an `EscrowCreate` object, which represents an [EscrowCreate](https://xrpl.org/escrowcreate.html) Transaction: ```java EscrowCreate escrowCreate = EscrowCreate.builder() .account(Address.of("rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn")) .fee(XrpCurrencyAmount.ofDrops(12)) .sequence(UnsignedInteger.ONE) .amount(XrpCurrencyAmount.ofDrops(10000)) .destination(Address.of("rsA2LpzuawewSBQXkiju3YQTMzW13pAAdW")) .destinationTag(UnsignedInteger.valueOf(23480)) .cancelAfter(UnsignedLong.valueOf(533257958)) .finishAfter(UnsignedLong.valueOf(533171558)) .condition(CryptoConditionReader.readCondition( BaseEncoding.base16() .decode("A0258020E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855810100")) ) .sourceTag(UnsignedInteger.valueOf(11747)) .build(); ``` These objects can be serialized to, and deserialized from, `rippled` JSON representations using the provided Jackson `ObjectMapper`, which can be instantiated using [`ObjectMapperFactory`](./xrpl4j-core/src/main/java/org/xrpl/xrpl4j/model/jackson/ObjectMapperFactory.java). Using the `EscrowCreate` object created above, it is then possible to use the supplied `ObjectMapper` to serialize to JSON like this: ```java ObjectMapper objectMapper = ObjectMapperFactory.create(); String json = objectMapper.writerWithDefaultPrettyPrinter().writeValueAsString(escrowCreate); System.out.println(json); ``` Which produces the following output: ``` { "Account" : "rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn", "Fee" : "12", "Sequence" : 1, "SourceTag" : 11747, "Flags" : 2147483648, "Amount" : "10000", "Destination" : "rsA2LpzuawewSBQXkiju3YQTMzW13pAAdW", "DestinationTag" : 23480, "CancelAfter" : 533257958, "FinishAfter" : 533171558, "Condition" : "A0258020E3B0C44298FC1C149AFBF4C8996FB92427AE41E4649B934CA495991B7852B855810100", "TransactionType" : "EscrowCreate" } ``` ### Public/Private Key Material Most operations using this library require some sort of private key material. Broadly speaking, the library supports two mechanisms: (1) in-memory private keys, and (2) in-memory _references_ to private keys where the actual private key material lives in an external system (e.g., keys in a Hardware Security Module, or HSM). In Java, this is modeled using the [`PrivateKeyable`](./xrpl4j-core/src/main/java/org/xrpl/xrpl4j/crypto/keys/PrivateKeyable.java) interface, which has two subclasses: [`PrivateKey`](./xrpl4j-core/src/main/java/org/xrpl/xrpl4j/crypto/keys/PrivateKey.java) and [`PrivateKeyReference`](./xrpl4j-core/src/main/java/org/xrpl/xrpl4j/crypto/keys/PrivateKeyReference.java). #### In-Memory Private Keys (`PrivateKey`) `PrivateKey` represents a private key held in memory, existing in the same JVM that is executing xrpl4j code. This key variant can be useful in the context of an android or native application, but is likely not suitable for server-side application because private key material is held in-memory (for these scenarios, consider using a remote service like an HSM). For use-cases that require private keys to exist inside the running JVM, the following examples shows how to generate a keypair, and also how to derive an XRPL address from there: ```java import org.xrpl.xrpl4j.crypto.keys.KeyPair; import org.xrpl.xrpl4j.crypto.keys.PrivateKey; import org.xrpl.xrpl4j.crypto.keys.PublicKey; import org.xrpl.xrpl4j.crypto.keys.Seed; import org.xrpl.xrpl4j.model.transactions.Address; Seed seed = Seed.ed25519Seed(); // <-- Generates a random seed. KeyPair keyPair = seed.deriveKeyPair(); // <-- Derive a KeyPair from the seed. PrivateKey privateKey = keyPair.privateKey(); // <-- Derive a privateKey from the KeyPair. PublicKey publicKey = keyPair.publicKey(); // <-- Derive a publicKey from the KeyPair. Address address = publicKey.deriveAddress(); // <-- Derive an address from the publicKey ``` #### Private Key References (`PrivateKeyReference`) For applications with higher-security requirements, private-key material can be stored outside the JVM using an external system that can simultaneously manage the key material and also perform critical signing operations without exposing key material to the outside world (e.g., an HSM or cloud service provider). For these scenarios, `PrivateKeyReference` can be used. This library does not provide an implementation that interacts with any particular external signing service or HSM. However, developers wishing to support such interactions should extend `PrivateKeyReference` for the particular external service, and implement [SignatureService](./xrpl4j-core/src/main/java/org/xrpl/xrpl4j/crypto/signing/SignatureService.java) for their `PrivateKeyReference` type. interface. In addition, [FauxGcpKmsSignatureServiceTest](./xrpl4j-core/src/test/java/org/xrpl/xrpl4j/crypto/signing/faux/FauxGcpKmsSignatureServiceTest.java) and [FauxAwsKmsSignatureServiceTest](./xrpl4j-core/src/test/java/org/xrpl/xrpl4j/crypto/signing/faux/FauxAwsKmsSignatureServiceTest.java) illustrate faux variants of a simulated external key provider that can also be used for further guidance. ### Signing and Verifying Transactions The main interface used to sign and verify transactions is [SignatureService](./xrpl4j-core/src/main/java/org/xrpl/xrpl4j/crypto/signing/SignatureService.java), which has two concrete implementations: [`BcSignatureService`](./xrpl4j-core/src/main/java/org/xrpl/xrpl4j/crypto/signing/bc/BcSignatureService.java) and [`BcDerivedKeySignatureService`](./xrpl4j-core/src/main/java/org/xrpl/xrpl4j/crypto/signing/bc/BcDerivedKeySignatureService.java). The first uses in-memory private key material to perform signing and validation operations, while the latter can be used to derive multiple private keys using a single entropy source combined with differing unique key identifiers (e.g., User Ids). #### Construct and Sign an XRP Payment: The following example illustrates how to construct a payment transaction, sign it using an in-memory private key, and then submit that transaction to the XRP Ledger for processing and validation: ```java import org.xrpl.xrpl4j.client.XrplClient; import org.xrpl.xrpl4j.crypto.keys.PrivateKey; import org.xrpl.xrpl4j.crypto.keys.Seed; import org.xrpl.xrpl4j.crypto.signing.SignatureService; import org.xrpl.xrpl4j.crypto.signing.SingleSignedTransaction; import org.xrpl.xrpl4j.model.client.transactions.SubmitResult; import org.xrpl.xrpl4j.model.transactions.Address; import org.xrpl.xrpl4j.crypto.signing.bc.BcSignatureService; import org.xrpl.xrpl4j.model.transactions.Payment; // Construct a SignatureService that uses in-memory Keys (see SignatureService.java for alternatives). SignatureService signatureService = new BcSignatureService(); // Sender (using ed25519 key) Seed seed = Seed.ed25519Seed(); // <-- Generates a random seed. PrivateKey senderPrivateKey = seed.deriveKeyPair().privateKey(); // Receiver (using secp256k1 key) Address receiverAddress = Address.of("r9cZA1mLK5R5Am25ArfXFmqgNwjZgnfk59"); // Construct a Payment Payment payment = ...; // See V3 ITs for examples. SingleSignedTransaction<Payment> signedTransaction = signatureService.sign(sourcePrivateKey,payment); SubmitResult<Payment> result = xrplClient.submit(signedTransaction); assert result.engineResult().equals("tesSUCCESS"); ``` ### Codecs This library relies upon two important sub-modules called Codecs (One for the XRPL binary encoding, and one for XRPL canonical JSON encoding). Read more about each here: - [Binary Codec](https://github.com/XRPLF/xrpl4j/tree/main/xrpl4j-core/src/main/java/org/xrpl/xrpl4j/codec/binary/README.md) - [Address Codec](https://github.com/XRPLF/xrpl4j/tree/main/xrpl4j-core/src/main/java/org/xrpl/xrpl4j/codec/addresses/README.md) ## Development ### Project Structure Xrpl4j is structured as a Maven multi-module project, with the following modules: - **xrpl4j-core**: [![javadoc](https://javadoc.io/badge2/org.xrpl/xrpl4j-core/javadoc.svg?color=blue)](https://javadoc.io/doc/org.xrpl/xrpl4j-core) - Provides core primitives like seeds, public/private keys definitions (supports secp256k1 and ed25519 key types and signing algorithms), signature interfaces, address and binary codecs etc. Also provides Java objects which model XRP Ledger objects, as well as request parameters and response results for the `rippled` websocket and JSON RPC APIs. - Provides a Jackson `ObjectMapper` with JSON bindings that serialize and deserialize to and from the JSON representation of XRPL Transactions; this is used to move to and from the canonical binary format of the XRP Ledger. - **xrpl4j-client**: [![javadoc](https://javadoc.io/badge2/org.xrpl/xrpl4j-client/javadoc.svg?color=blue)](https://javadoc.io/doc/org.xrpl/xrpl4j-client) - Provides an example `rippled` JSON RPC client which can be used to communicate with a `rippled` node - **xrpl4j-integration-tests**: - Contains the project's integration tests, which also serve as valuable xrpl4j usage examples for common XRPL flows. You can build and test the entire project locally using maven from the command line: ``` mvn clean install ``` To build the project while skipping Integration tests, use the following command: ``` mvn clean install -DskipITs ``` To build the project while skipping Unit and Integration tests, use the following command: ``` mvn clean install -DskipITs -DskipTests ``` ### Running integration tests against a private xrpld image By default the local integration tests start an `xrpld` node via Testcontainers using the public image `rippleci/xrpld:develop`. To run them against a private xrpld image, set the `XRPLD_DOCKER_IMAGE` environment variable before invoking Maven: ``` XRPLD_DOCKER_IMAGE=registry.gitlab.com/ripple/xrpledger/xrpld_package_deploy/xrpld-private:private-3.3.0-rc2 mvn clean install ``` `RippledContainer` reads `XRPLD_DOCKER_IMAGE` (falling back to the public image when it is unset). For a private registry, run `docker login` first so Testcontainers can reuse the credentials when pulling. In CI the image is selected from a committed config file, `.github/xrpld-image.env`. Set `XRPLD_PRIVATE_VERSION` to a version (without the `private-` prefix, for example `XRPLD_PRIVATE_VERSION=3.3.0-rc2`) and every workflow run — including pull request runs — resolves the private image, logs into the GitLab registry (via the `.github/actions/xrpld-login` composite action, shared by all of those jobs), and exports `XRPLD_DOCKER_IMAGE` to the local-integration-test jobs. Leave it empty to use the default public image. Private pulls require the repository variable `GITLAB_REGISTRY_USERNAME` and repository secret `GITLAB_REGISTRY_TOKEN` (a GitLab deploy token with `read_registry` access); these are not exposed to fork pull requests, so a private version must be tested from a branch in this repository. [codecov-image]: https://codecov.io/gh/XRPLF/xrpl4j/branch/main/graph/badge.svg [codecov-url]: https://codecov.io/gh/XRPLF/xrpl4j [github-issues-image]: https://img.shields.io/github/issues/XRPLF/xrpl4j.svg [github-issues-url]: https://github.com/XRPLF/xrpl4j/issues

README des Repositorys wird geladen…

Skills in diesem Repository

Softwareentwickler

1 Berufskategorien · 100% klassifiziert

Skill

Beruf

Beschreibung

Aktualisiert

batch-deps-upgrade

Softwareentwickler

Batch all open Dependabot dependency upgrade PRs into a single PR

Quellsprache: Englisch

2026-05-22

Es werden 1 von 1 gesammelten Skills angezeigt.