mcpField
X
xrpl-dev

xrpl-dev

github.com/xrpl-commonsDevelopment5153 installsUpdated 37w ago
Repository

About xrpl-dev

xrpl-dev is a development skill for building and reviewing XRPL applications across frontend, transaction, asset, and interoperability work. It provides opinionated stack choices and XRPL-specific implementation and security guidance.

Key features

  1. 01XRPL project scaffolding recommendations
  2. 02Wallet connection and signing guidance
  3. 03SDK choices by programming language
  4. 04Transaction and account correctness practices
  5. 05Token, NFT, DEX, and AMM workflows
  6. 06Testing and security review guidance

Use cases

  1. 01Starting a new XRPL application
  2. 02Implementing wallet connection and signing
  3. 03Building or submitting XRPL transactions
  4. 04Reviewing token or cross-chain integrations

Install

Copy the command and run it in a terminal.

$npx skills add https://github.com/xrpl-commons/xrpl-dev-skills --skill xrpl-dev

After installing, type/xrpl-devin Claude Code to confirm it loaded.

Bundled files

References and scripts installed along with SKILL.md.

client-sdk.md
dex-amm.md
frontend.md
interoperability.md
nfts.md
payments.md
resources.md
security.md
tokens.md

Details

From the project README

XRPL Development Skill

What this Skill is for

Use this Skill when the user asks for:

  • XRPL dApp development (any language/framework)
  • Scaffolding a new XRPL project
  • Frontend wallet connection (Crossmark, Xaman, GemWallet)
  • Account creation, funding, and management
  • Transaction building, signing, and submission
  • Token operations (TrustLines, issued currencies, MPTs)
  • NFT operations (XLS-20 NFTokens)
  • DEX interactions (offers, order books, path finding)
  • AMM (Automated Market Maker) operations
  • Cross-chain interoperability (Axelar bridge, XRPL EVM sidechain)
  • Payment channels, escrows, and checks
  • Security review of XRPL transactions and integrations

Default stack decisions (opinionated)

  1. Scaffolding: create-xrp

    • For new projects, start with npx create-xrp my-app.
    • Scaffolds a Turborepo monorepo with Next.js (React) or Nuxt (Vue).
    • Pre-configured: xrpl-connect wallet connection, network switching, Tailwind CSS, transaction UI.
    • Smart contract support is experimental — skip it by default.

  2. Client SDK: xrpl.js first (JavaScript/TypeScript)

    • Use xrpl for all new JS/TS client code.
    • For Python projects, use xrpl-py.
    • For Java/Kotlin, use xrpl4j.

  3. Frontend: xrpl-connect first

    • Use xrpl-connect for all wallet connection and signing UX.
    • Framework-agnostic web component (<xrpl-wallet-connector>), works with React, Vue, Next.js, Nuxt, vanilla JS.
    • Built-in adapters for Xaman, Crossmark, GemWallet, WalletConnect, and Ledger.
    • Event-driven WalletManager handles connection state, session persistence, and auto-reconnect.

  4. Network: testnet for development

    • Always default to testnet (wss://s.altnet.rippletest.net:51233).
    • Use devnet for experimental/amendment features.
    • Never hardcode mainnet endpoints in development code.

  5. Transaction signing: local or wallet-delegated

    • For backend/scripts: sign locally, never send secrets over the network.
    • For frontend: delegate signing to the connected wallet.
    • For production backends: prefer custodial signing services or hardware wallets.

  6. Account management: reserves-aware

    • Always check and communicate reserve requirements before operations.
    • Base reserve (currently 10 XRP) + owner reserve (2 XRP per owned object).
    • Warn users when operations will lock up reserves.

  7. Error handling: explicit

    • Always check validated status, not just submission tesSUCCESS.
    • Handle tec* codes (claimed-but-failed) differently from tef*/tem* codes.
    • Implement retry logic for terQUEUED and tefPAST_SEQ.

Operating procedure (how to execute tasks)

1. Classify the task layer
  • Scaffolding — new project setup
  • Frontend/wallet layer — wallet connection, signing UX, displaying state
  • Client/scripts layer — building or sending transactions, querying ledger state
  • Token/asset layer — TrustLines, issued currencies, NFTs, MPTs
  • DEX/AMM layer — offers, order books, AMM pools, path finding
  • Interoperability layer — Axelar bridge, EVM sidechain
  • Security review — cross-cutting concern
2. Pick the right building blocks
  • New projects: npx create-xrp to scaffold (Next.js or Nuxt)
  • Frontend: xrpl-connect (WalletManager + web component) + xrpl for state queries
  • JS/TS backend/scripts: xrpl package
  • Python projects: xrpl-py
  • Cross-chain: Axelar GMP via XRPL Payment memos
3. Implement with XRPL-specific correctness

Always be explicit about:

  • network (mainnet / testnet / devnet) + WebSocket endpoint
  • account reserves (base + owner reserves) and their implications
  • transaction fees (auto-filled vs explicit, fee escalation)
  • sequence numbers (auto-filled vs explicit, for multi-tx workflows)
  • LastLedgerSequence (always set for reliable submission)
  • flags and field requirements per transaction type
  • trust line limits and issuer relationships
  • NFT transfer fees and broker mechanics
4. Add tests
  • Unit test transaction building and serialization.
  • Integration test against testnet (use faucet for funding).
  • Frontend: test wallet connection and signing flows with mocked providers.
5. Deliverables expectations

When you implement changes, provide:

  • exact files changed + diffs
  • commands to install/build/test
  • a short "risk notes" section for anything touching signing, fees, reserves, or asset transfers

Content Sources

This skill incorporates best practices from:

Progressive disclosure (read when needed)

Comments

Markdown supported