Introducing Jot - new Polkadot SDK for Java

Tech Talk
1

Hey everyone :waving_hand:

I’m excited to share Jot, a new open-source Polkadot SDK for Java - built to make it easy for Java developers to connect to the network, query on-chain data, and submit transactions in a type-safe, fluent way.

Whether you’re writing backend services, integration tools, or exchange infrastructure, Jot lets you work directly with Polkadot entirely from Java — no manual SCALE encoding required.

:glowing_star: What is Jot?

Jot is a high-level SDK that wraps Polkadot’s RPC, metadata, and SCALE layers into a clean, developer-friendly API - similar in style to Polkadot-JS or PAPI, but designed specifically for the JVM ecosystem.

It provides:

  • :package: Core SDK: full support for SCALE codec, metadata parsing, and RPC abstraction

  • :key: Wallets & Signing: sr25519 and ed25519 signing, both offline and in-memory

  • :brain: Query API: typed accessors for runtime storage, constants, and system properties

  • :gear: Transaction Builder: create, sign, and submit extrinsics with one call

  • :bell: Subscriptions: listen to finalized heads, events, and custom subscriptions

  • :toolbox: Examples & Docs: runnable examples for queries, transfers, and offline signing

:sparkles: Example

Here’s how it feels to use Jot:

// Query balance
AccountInfo info = api.query().storage().accountInfo(account);

// Transfer funds
Call call = api.tx().balances().transferKeepAlive(to, amount);
String hash = call.signAndSend(wallet.getSigner());

// Subscribe to finalized heads
api.subscribe().finalizedHeads(h -> System.out.println("New head: " + h));

:test_tube: Getting Started

The easiest way to get started is by using the Maven dependency.

<dependency>
  <groupId>com.method5</groupId>
  <artifactId>jot</artifactId>
  <version>1.0.2</version>
</dependency>

You can then start using the SDK immediately:

try (PolkadotWs api = new PolkadotWs("wss://polkadot.api.onfinality.io/public-ws"))
{
  System.out.println("Connected to chain: " + api.query().system().chain());
  System.out.println("Genesis hash: " + api.query().chain().genesisBlockHash());
}

:books: Documentation & Quickstart:
:backhand_index_pointing_right: https://methodfive.github.io/jot/

:laptop: Source Code:
:backhand_index_pointing_right: https://github.com/methodfive/jot

:puzzle_piece: Why Jot?

Java remains one of the most widely used languages in fintech, enterprise, and backend infrastructure - but until now, there wasn’t a modern SDK for connecting Java applications to substrate based networks.

Jot bridges that gap with:

  • A modern, high-level API for Polkadot interaction

  • Strong test coverage (>90%) and robust metadata caching for performance

  • Comprehensive examples and docs that work out of the box

  • Clean Maven integration for easy setup in any JVM project

:rocket: Roadmap

We’re actively improving Jot and plan to continue expanding its capabilities. We are looking into adding android support next!

:speech_balloon: Get Involved

We’d love feedback and collaboration from the Polkadot developer community - especially from teams building JVM-based tooling, exchanges, or analytics services.

Feel free to:

  • :star: Star the repo and try the examples

  • :bug: Open issues or suggestions on GitHub

  • :light_bulb: Share ideas for how Jot could help your project

Jot brings the Polkadot ecosystem to Java - the language of enterprise and infrastructure.

If you’re a Java or Kotlin developer curious about Polkadot, this is your gateway in. :rocket:

6 Likes
2

not a java dev but stars are free

1 Like
3

I have just started using it for my side-project developed in Java and I like it a lot!

The docs are not very detailed and could be improved. I could not find there how to hash something.

However, I was able to find everything I needed in the java-docs. ^^

1 Like
4

Very excited about this! :tada:

Two questions:

  1. Is this SDK meant to be used exclusively on Polkadot/Polkadot Hub? Or will it allow support for any Substrate-based chain (solochain, parachain, etc.)?
  2. I noticed these ExtrinsicSigner and SignedExtrinsicBuilder classes, which are final (and therefore not extensible). I’m wondering why they are final?
    This is an approach closer to the Polkadot-JS “static” extrinsic building, that, while it works for most cases, fails to cover the parachains that have TransactionExtensions other than the default ones.
    I think a better, more standard approach, would be following an extensible PolkadotSigner-style for these extrinsic builders, that works for standard extrinsics, but can be customized by parachains that need it (we do need it).
    Let me know when this approach is possible, so we can use jot in the future. :wink:

cc/ @carlosala @josep here’s a potential chance to promote the standardization of this approach.

1 Like
5

Thanks for the ping @pandres95 and for raising this.

We are, indeed, trying to standarize a more powerful and library agnostic way of creating extrinsics. Please have a look at this RFC and also this forum post. :folded_hands:

2 Likes
7

Thanks for the feedback @RostislavLitovkin

We will extend the docs to include common utility class usage.

8

@pandres95 It’s designed for any substrate based chain, not just polkadot itself.

I’ll remove the final on the signer classes so they can be extended. I don’t remember why we did this originally. But also feel free also to push any updates if you need changes they will get merged in. It would be great to have parachain support!

2 Likes