Back to Slide Me Digital
Developer Hub · XRPL Native

SLD Developer Docs

SLD is an issued token on the XRP Ledger. There is no proprietary API to learn — you integrate using the standard XRPL libraries, public rippled nodes, and the issuer address below.

Currency code
SLD
Issuer address
rsTR3LHTE5m3QvG2YKhg7tCTRiQJwx8LZj
Mainnet WebSocket
wss://xrplcluster.com
Mainnet JSON-RPC
https://xrplcluster.com
Testnet WebSocket
wss://s.altnet.rippletest.net:51233
Explorer
https://livenet.xrpl.org

Before you integrate — read this.

  • No proprietary API. SLD is a standard issued token on the XRP Ledger. You interact with it using public XRPL nodes and official libraries — the same way you would with any other XRPL token.
  • Test first, always. Every code example on this page works on testnet. Run your integration againsts.altnet.rippletest.netand get free test XRP from the faucet before touching mainnet.
  • You control your keys. Never share seed phrases or secret keys with any service. The wallets and SDKs listed below sign transactions locally on the user's device.
  • Verify on-chain. Every SLD transaction is permanently recorded on the XRPL. Always confirm balances, trustlines, and payments using theofficial exploreror account_lines / tx commands.
  • Not financial advice. This documentation is for technical integration purposes only. It does not constitute investment, legal, or tax advice. DYOR.
  • Issuer address is public. rsTR3LHTE5m3QvG2YKhg7tCTRiQJwx8LZj is a live XRPL account. You can inspect its activity, settings, and issued balances on any XRPL explorer at any time.

Quickstart

Connect to a public XRPL node, set a trustline to the SLD issuer, then send a Payment denominated in SLD. Everything below uses real XRPL transaction types — no proprietary API.

  1. Step 01
    Install xrpl.js

    npm install xrpl. Works in Node, browsers, and edge runtimes.

  2. Step 02
    Connect to a node

    Use xrplcluster.com for mainnet, or rippletest.net for free testnet XRP via the faucet.

  3. Step 03
    Set SLD trustline

    Submit a TrustSet transaction from the user wallet pointing to the SLD issuer address.

  4. Step 04
    Send a Payment

    Submit a Payment with Amount = { currency, issuer, value }. Settles in ~4 seconds.

trustset.ts · set the SLD trustline (xrpl.js)
Copy
import { Client, Wallet } from "xrpl";

const client = new Client("wss://xrplcluster.com");
await client.connect();

const wallet = Wallet.fromSeed(process.env.USER_SEED!); // user's secret seed

const tx = await client.autofill({
  TransactionType: "TrustSet",
  Account: wallet.address,
  LimitAmount: {
    currency: "SLD",
    issuer: "rsTR3LHTE5m3QvG2YKhg7tCTRiQJwx8LZj",
    value: "1000000000", // max SLD this wallet is willing to hold
  },
});

const signed = wallet.sign(tx);
const result = await client.submitAndWait(signed.tx_blob);

console.log("TrustSet result:", result.result.meta);
await client.disconnect();
send-sld.ts · send SLD from one wallet to another
Copy
import { Client, Wallet, xrpToDrops } from "xrpl";

const client = new Client("wss://xrplcluster.com");
await client.connect();

const sender = Wallet.fromSeed(process.env.SENDER_SEED!);

const payment = await client.autofill({
  TransactionType: "Payment",
  Account: sender.address,
  Destination: "rRecipientAddressHere",
  Amount: {
    currency: "SLD",
    issuer: "rsTR3LHTE5m3QvG2YKhg7tCTRiQJwx8LZj",
    value: "25",            // 25 SLD
  },
  // Optional: pay the network fee in drops (1 XRP = 1,000,000 drops)
  Fee: xrpToDrops("0.00001"),
});

const signed = sender.sign(payment);
const result = await client.submitAndWait(signed.tx_blob);

console.log("tx hash:", result.result.hash);
console.log("validated:", result.result.validated);
await client.disconnect();
balance.ts · read an SLD balance
Copy
import { Client } from "xrpl";

const client = new Client("wss://xrplcluster.com");
await client.connect();

const res = await client.request({
  command: "account_lines",
  account: "rWalletAddressHere",
  peer: "rsTR3LHTE5m3QvG2YKhg7tCTRiQJwx8LZj",   // only return the SLD trustline
  ledger_index: "validated",
});

const sld = res.result.lines.find(l => l.currency === "SLD");
console.log("SLD balance:", sld?.balance ?? "0");
await client.disconnect();

XRPL Methods You'll Use

These are real rippled commands. They work against any public XRPL node — including the ones listed above — over JSON-RPC or WebSocket. Full reference: xrpl.org/public-api-methods.

MethodTransportDescription
account_linesJSON-RPC / WebSocketList trustlines on an account — use to confirm a wallet holds the SLD trustline and read its balance.
account_infoJSON-RPC / WebSocketFetch base XRP balance, sequence number, and account flags. Required before signing any transaction.
account_txJSON-RPC / WebSocketPaginated history of every transaction affecting an account. Filter client-side for SLD Payments.
submitJSON-RPC / WebSocketSubmit a signed transaction blob (Payment, TrustSet, etc.) to the network.
txJSON-RPC / WebSocketLook up a transaction by hash and confirm it is validated on a closed ledger.
subscribeWebSocket onlyStream live ledger events — subscribe to the SLD issuer address to push reward / payment notifications.
book_offersJSON-RPC / WebSocketRead the XRPL DEX order book for the SLD/XRP pair (and other quoted assets).

Client Libraries

Official XRPL Foundation libraries. They handle binary serialization, signing, autofill of fees / sequences, and WebSocket reconnection for you.

send_sld.py · same Payment, in Python (xrpl-py)
Copy
from xrpl.clients import JsonRpcClient
from xrpl.wallet import Wallet
from xrpl.models.transactions import Payment
from xrpl.models.amounts import IssuedCurrencyAmount
from xrpl.transaction import autofill_and_sign, submit_and_wait

client = JsonRpcClient("https://xrplcluster.com")
sender = Wallet.from_seed(os.environ["SENDER_SEED"])

payment = Payment(
    account=sender.address,
    destination="rRecipientAddressHere",
    amount=IssuedCurrencyAmount(
        currency="SLD",
        issuer="rsTR3LHTE5m3QvG2YKhg7tCTRiQJwx8LZj",
        value="25",
    ),
)

signed = autofill_and_sign(payment, client, sender)
result = submit_and_wait(signed, client)
print(result.result["hash"])

Live Events (no webhooks needed)

XRPL is push-native — subscribe to the SLD issuer address over WebSocket and you'll receive every Payment, TrustSet, and OfferCreate the moment the ledger closes (~4s). Forward those to your own webhook system if you need durable delivery.

subscribe.ts · stream SLD activity
Copy
import { Client } from "xrpl";

const client = new Client("wss://xrplcluster.com");
await client.connect();

await client.request({
  command: "subscribe",
  accounts: ["rsTR3LHTE5m3QvG2YKhg7tCTRiQJwx8LZj"],
});

client.on("transaction", (event) => {
  const tx = event.transaction;
  if (tx.TransactionType === "Payment") {
    console.log("SLD payment:", {
      from: tx.Account,
      to: tx.Destination,
      amount: tx.Amount,
      hash: event.transaction.hash,
      ledger: event.ledger_index,
    });
    // forward to your own /webhooks/sld endpoint here
  }
});

Build with SLD

Everything you need is on-chain. Read the SLD token doc for supply, fees, and issuer policy — then ship.