# Welcome to Joey Wallet!

Joey Wallet is the ultimate self-custodial mobile wallet for the XRP Ledger (XRPL), designed for seamless, secure, and lightning-fast interactions with the blockchain. With support for WalletConnect, Joey Wallet empowers users to manage their XRP and other XRPL tokens, interact with dApps, and take full control of their crypto assets—all from the palm of their hand.

### Why Joey Wallet?

* Self-Custodial Security: You hold your private keys, ensuring full control over your assets with no third-party interference. Joey Wallet uses industry-standard encryption to keep your funds safe.
* Lightning-Fast Transactions: Leverage the XRP Ledger’s 3-5 second transaction settlement for instant transfers, swaps, and dApp interactions.
* WalletConnect Integration: Seamlessly connect to XRPL-based dApps with QR code scanning, enabling secure and intuitive interactions.
* Sleek & Intuitive UI: A clean, user-friendly interface makes managing your portfolio, viewing seed phrases, and transacting effortless.
* Privacy First: No tracking, no nonsense—your data stays yours.
* Multi-Platform: Available on iOS and Android for managing your assets on the go.

> "Joey Wallet isn't just another wallet—it's the future of self-custody on XRPL. Cleanest UI I've ever seen!" —@Cobb\_XRPL

### Get Started with Joey Wallet

#### For Users

1. Download Joey Wallet: Available on [iOS](https://t.co/OffywzJ1ey) and [Android](https://t.co/lRPUfho6nt).
2. Create or Import a Wallet: Set up a new wallet in \~5-10 seconds or import an existing one using your seed phrase. Unlike other wallets, Joey Wallet lets you view your seed phrase anytime for added convenience.
3. Fund Your Wallet: Transfer XRP or other XRPL tokens from an exchange like Coinbase or another wallet (e.g., Xaman). Follow this [tutorial](https://t.co/7EvlkGWBgs) for step-by-step guidance.
4. Explore the XRPL: Send, receive, swap, or connect to dApps using WalletConnect.

{% hint style="info" %}
Note: The XRP Ledger requires a 1 XRP reserve to activate a new account. This ensures your account is verified and ready to transact.
{% endhint %}

#### For Developers

Joey Wallet’s open-source API and WalletConnect integration make it easy to connect your dApp to the XRP Ledger. See the Developer Documentation section below for details.


# Getting Started

Joey Wallet’s documentation is designed to help developers integrate the wallet into their dApps quickly and efficiently. Below is a rundown of the key sections in the Joey Wallet Developer Documentation, inspired by resources like [XRPL.org](http://XRPL.org) and Ledger’s Developer Portal.

#### 1. Introduction to Joey Wallet

* Overview: Learn about Joey Wallet’s core features, including its self-custodial nature, WalletConnect support, and compatibility with the XRP Ledger and Xahau Network.
* Why Joey Wallet?: Understand the benefits of integrating with Joey Wallet, such as its seamless UI/UX, fast onboarding, and robust security.
* Use Cases: Explore how Joey Wallet supports payments, DeFi, NFT trading, and other XRPL-based applications.

#### 2. Getting Started

* Setup Guide: Instructions for setting up a development environment, including required tools (e.g., Node.js, npm) and access to XRPL Testnet credentials for testing.
* WalletConnect Integration: A step-by-step guide to connecting Joey Wallet to your dApp using WalletConnect’s open-source protocol.
* API Overview: Introduction to Joey Wallet’s API and SDK for signing transactions and interacting with the XRPL.

See [here](/overview/quick-start) for our quick start, step-by-step guidelines.

#### 3. WalletConnect Integration

* What is WalletConnect?: A protocol for securely connecting mobile wallets to dApps via QR code-based authentication, ensuring private keys remain on the user’s device.
* Supported Wallets: Joey Wallet supports WalletConnect for seamless dApp interactions, similar to MetaMask or Trust Wallet for Ethereum-based dApps.
* Integration Steps:

  To get started with the Joey Wallet Provider, follow the steps below:

  1. **Install the Package:**

     Use pnpm to install the package:

     ```bash
     pnpm install @joey-wallet/wc-client
     ```
  2. **Initialize the Provider:**

     Initialize the provider using your credentials provided on the Reown Dashboard.
  3. **Manage Connections:**

     Use provider actions for handling connections:

     * `connect`
     * `generate`

     Utilize the provided `joey-modal` and `joey-button` components for seamless integration.

  By following these steps, you'll be set up to handle basic interactions with the Joey Wallet efficiently.

See [here](/integration/install) for our integration guidelines.

#### 4. Testing and Debugging

* Testnet Access: Use XRPL Testnet to develop and test your dApp without risking real funds. Generate Testnet credentials via [XRPL.org](http://XRPL.org).
* Troubleshooting: Common issues and solutions, such as handling WalletConnect connection errors or transaction failures.
* Best Practices: Guidelines for optimizing dApp performance and ensuring compatibility with Joey Wallet.

#### 5. Tutorials and Examples

* Step-by-Step Tutorials: Guides for common tasks, such as sending XRP, swapping tokens, or integrating with XRPL dApps like xrp.cafe.
* Sample Projects: Downloadable code examples for building XRPL dApps with Joey Wallet integration. (ie. wc-toolkit.joeywallet.xyz, joey-signer.vercel.app)
* Community Resources: Links to the XRPL developer community and forums for additional support.

See [here](https://github.com/Joey-Wallet/wc-client/tree/main/playground) for our playground of a few sample projects.

#### . Security and Best Practices

* Key Management: How Joey Wallet encrypts and stores private keys locally, audited by top firms.
* User Privacy: Ensuring no tracking or data collection, aligning with Joey Wallet’s privacy-first ethos.
* Secure Development: Tips for building secure dApps, including input validation and secure API calls.


# Quick Start

Here’s a concise guide to integrating Joey Wallet into your XRPL-based dApp using WalletConnect

{% hint style="info" %}
Do you have an existing that dapp that already supports WalletConnect? See [here](/overview/add-to-existing-project) for  details on how to add Joey Wallet.
{% endhint %}

1. Set Up Your Development Environment: 

* Install Node.js and npm. ◦ Set up a project with a framework like React, NextJS or plain Typescript/Javascript.

{% hint style="warning" %}
In this example, we will be using NextJS and pnpm
{% endhint %}

* Install our joey provider:

```bash
pnpm install @joey-wallet/wc-client
```

2. Obtain your Reown Project Identification:

Go to [Reown Dashboard](https://dashboard.reown.com/) and configure your projects details. Once finished, copy your Reown ProjectId.

3. Configure your Joey `provider`:

Create a configuration file for your provider.

```jsx
// File: ./src/app/config.ts
import type { Config } from '@joey-wallet/wc-client';

export default {
	// Required
  projectId: process.env['NEXT_PUBLIC_PROJECT_ID'],
  // Optional - Add your projects details
  metadata: {
    name: 'Joey Example Project',
    description:
      'A sample project using walletconnect and Joey Wallet.',
    url: "http://localhost:3000",
    icons: ['/assets/favicon.ico'],
    redirect: {
      universal: "http://localhost:3000",
    },
  },
} as Config
```

View [here](https://github.com/Joey-Wallet/wc-client/blob/main/packages/core/src/typings/config.ts) for a more thorough explanation for all the acceptable configuration parameters for the provider.

4. Create, import your config file, and include the context provider around your page components:

```jsx
// File: ./src/app/page.tsx
'use client';

import * as React from 'react';
import { advanced } from '@joey-wallet/wc-client/react';

import config from './config';

const { Provider: WcProvider, useProvider } = advanced.default;
export { useProvider };

export const Provider = (props: React.PropsWithChildren) => (
  <WcProvider config={config}>{props.children}</WcProvider>
);

export default function Page() {
  return (
    <Provider>
      {/*  Your page components here  */}
    </Provider>
  )
}
```

5. Handling Wallet Events and Actions:

The first thing to do - connect to WalletConnect using Joey Wallet! See below for an example using the `connect` action included in the provider:

```jsx
// File: ./src/app/component.tsx
'use client';

import * as React from 'react';
import { useProvider } from './page';

export default function Component() {
  const { actions, session, accounts } = useProvider();

  const handleConnect = async () => {
    const connect = await actions.connect();
    if (connect.error) throw connect.error;
    // You have been connected using wallet connect.
    // Now you can start interacting with the XRP Ledger.
    // ...
  };

  return (
    <div>
      {!session && (
        <button type="button" onClick={handleConnect}>
          Connect
        </button>
      )}
      {session && (
        <div>
           <span>Successfully connected!</span>
          {accounts && accounts.map((account,index) => (
		          <div key={index}>{account}</div>
		          )
	         )}
        </div>
      )}
    </div>
  );
}
```

After the `connect` button is clicked, the WalletConnect modal will open and ask for the user to sign-in using Joey Wallet. Once the user approves the interaction, the connection will be complete and you can proceed to issuing transaction request.

6. Interact with the XRP Ledger and Joey Wallet

Issue your first sign request!

```jsx
// File: ./src/app/signer.tsx
'use client';

import * as React from 'react';
import xrpl from 'xrpl';
import core from '@joey-wallet/wc-client/core';

import { useProvider } from './page';

export default function Signer() {
  const { provider, session, chain, accounts } = useProvider();
  const [response, setResponse] = React.useState<string | undefined>();

  const handleSign = async () => {
    try {
      if (!provider) throw Error('Provider not ready for request.');

      const address = accounts?.map((account) => account.replace(chain, ''))?.[0];
      if (!address) throw Error('Could not determine address for request');

      const tx_json: xrpl.Payment = {
        TransactionType: 'Payment',
        Account: address,
        Destination: 'ra5nK24KXen9AHvsdFTKHSANinZseWnPcX',
        Amount: {
          currency: 'USD',
          value: '1',
          issuer: 'rf1BiGeXwwQoi8Z2ueFYTEXSwuJYfV2Jpn',
        },
        Fee: '12',
        Flags: 2147483648,
        Sequence: 2,
      };

      const response = await core.methods.signTransaction({
        provider,
        chainId: chain,
        request: {
          tx_json,
          options: { autofill: true, submit: true },
        },
      });

      setResponse(JSON.stringify(response, null, 2));
    } catch (e: any) {
      console.error(e);
      return new Error(e.message);
    }
  };

  return (
    <div>
      {session && (
        <button type="button" onClick={handleSign}>
          Submit
        </button>
      )}
      {response && (
        <div>
          <span>Received a response from Joey Wallet!</span>
          {response}
        </div>
      )}
    </div>
  );
}

```

For a complete list of embedded methods, see here: <https://github.com/Joey-Wallet/wc-client/tree/main/packages/core/src/methods>

{% hint style="info" %}
Pro Tip: Leverage Joey Wallet’s integration with platforms like [xrp.cafe](http://xrp.cafe) and [firstledger.net](http://firstledger.net) for real-world testing.
{% endhint %}


# Add to Existing Project

Add Joey Wallet to a project that already supports WalletConnect

If you already have a project with WalletConnect integration and would like to add support for Joey Wallet, this is the page for you!

### Prerequisites&#x20;

Before we get started... Joey Wallet has been tested using the `latest` recommended packages provided by Reown:

* `@walletconnect/universal-provider`  (session mgmt and requests)
* `@reown/appkit`  (modal)

{% hint style="warning" %}
If you are not supporting the latest versions of these packages, or using depreciated packages from `@walletconnect`, Joey Wallet may still work but performance and reliability is not guaranteed.  \
\
It is recommended that you migrate your project to the dependencies above, and verify that you using the latest published versions.
{% endhint %}

### Integration&#x20;

* Add Joey Wallet to your preferred wallets list on the Appkit Modal

{% hint style="info" %}
Joey Wallet ProjectId: `d9f5432e932c6fad8e19a0cea9d4a3372a84aed16e98a52e6655dd2821a63404`
{% endhint %}

* Review the networks supported by Joey Wallet [here](/integration/supported-networks) and make sure that your wallet-connect client contains these namespaces.

### Other Details

If you need to add a dedicated Joey button or QR code to your site, some of the information below might be useful.

#### Supported QR code contents

```typescript
Conventional: `${uri}`
Joey-Specific: `${uri}`

// wc:60b4991652e56dc0892721711db95886c9f166ced36cb8a60a759b61e89194ae@2?relay-protocol=irn&symKey=6dcd83bed7292707fd03befef27616958a02e574bdff8784937c1cf584fdd206&expiryTimestamp=1753908348
```

#### Supported deeplinking syntax

```typescript
Universal: `wc://${uri}`
Joey-specific: `joey://settings/wc?uri=${encodeURIComponent(uri)}`

// joey://settings/wc?uri=wc%3A60b4991652e56dc0892721711db95886c9f166ced36cb8a60a759b61e89194ae%402%3Frelay-protocol%3Dirn%26symKey%3D6dcd83bed7292707fd03befef27616958a02e574bdff8784937c1cf584fdd206%26expiryTimestamp%3D1753908348
```

<br>


# Install

### Installation

To integrate `wc-client` into your decentralized application (DApp), install it using your preferred package manager: pnpm, npm, or yarn. Run one of the following commands in your project directory:

```bash
# Using pnpm (recommended for faster installs)
pnpm add @joey-wallet/wc-client
```

```bash
# Using npm
npm install @joey-wallet/wc-client
```

```bash
# Using yarn
yarn add @joey-wallet/wc-client
```

> Note: Ensure your project includes `@walletconnect/universal-provider` as a dependency, as `wc-client` builds on it for WalletConnect functionality. If not already included, you can install it alongside `wc-client`

**Next Steps:**

After installation, you can initialize `wc-client` in your DApp to connect to the XRP Ledger via WalletConnect. Refer to the Quick Start section for a basic example of setting up the client, or explore the Playground directory for advanced use cases, including session management and transaction handling with Joey Wallet.


# Configuration

### Configuration Options

The `wc-client` Provider requires a configuration object to initialize WalletConnect and connect to the XRP Ledger. Below is an example configuration file and a detailed explanation of available options, including the metadata field for WalletConnect project details.

```tsx
// File: ./src/common/wc-config.ts
import { Config } from '@joey-wallet/wc-client/react';
import core from '@joey-wallet/wc-client/core';

const chains = core.constants.chains;

export default {
    /**
   * WalletConnect Project ID from Reown Cloud
   * @see https://cloud.reown.com
   */
  projectId: 'YOUR_WALLETCONNECT_PROJECT_ID', // Obtain from https://cloud.reown.com
  /**
   * Enhanced namespaces for the provider communication
   * Client needs a little more information for the chain information required by AppKit
   * Defaults to xrpl namespace
   */
  namespaces: chains.xrplNamespace,
  /**
   * Default chain for connection - set to active chain on initialization
   * If the network is changed, a new chain will need to be set (ie. setActive)
   * Defaults to first detected chain in namespaces
   */
  defaultChain: chains.xrpl.mainnet.id,
  /**
   * Wallet details for the preferred wallets for the modal and other interactions
   * Client reequired more information for deeplinking optimizations
   * Joey wallet will be included in this list if not provided
   */
  walletDetails: [{
      name: 'Joey Wallet',
      projectId: 'd9f5432e932c6fad8e19a0cea9d4a3372a84aed16e98a52e6655dd2821a63404',
      deeplinkFormat: 'joey://settings/wc?uri=',
  }],
    /**
   * Enable logging for troubleshooting.
   * @default false
   */
  verbose: true, // Enable debug logging (Optional)
  /**
   * Configure session data persistence.
   * The client uses persists session data using IndexDB
   * @default undefined
   */
  storage: {
    enabled: true, // Persist session data
    custom: null, // Optional: Custom storage implementation
  },
  /**
   * Project metadata for connection details - shown within the WalletKit
   * @see https://cloud.reown.com
   */
  metadata: {
    name: 'Your DApp Name',
    description: 'A decentralized application for XRP Ledger interactions',
    url: 'https://your-dapp.com',
    icons: ['https://your-dapp.com/icon.png'],
    redirect: 'https://your-dapp.com/wc', // Universal link for web
  },
} as Config;
```

For the latest configuration options, view within codebase [here](https://github.com/Joey-Wallet/wc-client/blob/main/packages/core/src/typings/config.ts).<br>

**Next Steps:**

After understanding the configuration options, go to the Reown Dashbord to get your projects credentials. A Project ID is required for the WalletConnect integration to work properly with our provider. <br>


# Actions

The `wc-client` abstracts away the complexities of the WalletConnect packages, and boils the interactions down to a handful of `actions` that are accessible in the client and provider.

* [connect](/integration/actions/connect)
* [disconnect](/integration/actions/disconnect)
* [reconnect](/integration/actions/reconnect)
* [generate](/integration/actions/generate)


# Connect

The provider comes with a `connect` action that establishes a new connection to WalletConnect.&#x20;

```typescript
// Some where within your codebase...

const { actions, session, accounts } = useProvider();

const response = await actions.connect()
```

#### Inputs (Optional)

You can optionally pass in the `chain` , `pairing.topic` , or `openModal` directives.&#x20;

```typescript
{
  chain: string;
  pairing?: { topic: string };
  openModal?: boolean;
}
```

#### Return Type

The method will resolve with the active session if a connection is established by the user.

<pre class="language-typescript"><code class="lang-typescript"><strong>Promise&#x3C;{
</strong>    data: SessionTypes.Struct || null
    error: Error || null
}>
</code></pre>

#### Example usage:

```jsx
// File: ./src/app/component.tsx
'use client';

import * as React from 'react';
import { useProvider } from './page';

export default function Component() {
  const { actions, session, accounts } = useProvider();

  const handleConnect = async () => {
    const response = await actions.connect();
    if (response.error) throw response.error;
    // You have been connected using wallet connect.
    // Now you can start interacting with the XRP Ledger.
    // ...
  };

  return (
    <div>
      {!session && (
        <button type="button" onClick={handleConnect}>
          Connect
        </button>
      )}
      {session && (
        <div>
           <span>Successfully connected!</span>
              {accounts && accounts.map((account,index) => (
		<div key={index}>{account}</div>
	      )
            )}
        </div>
      )}
    </div>
  );
}
```


# Disconnect

The provider comes with a `disconnect` action that disconnects from the active session (if connected).&#x20;

```typescript
// Some where within your codebase...

const { actions, session, accounts } = useProvider();

const response = await actions.disconnect()
```

#### Example usage:

```jsx
// File: ./src/app/component.tsx
'use client';

import * as React from 'react';
import { useProvider } from './page';

export default function Component() {
  const { actions, session, accounts } = useProvider();

  const handleDisconnect = async () => {
    await actions.disconnect();
    // You have been connected using wallet connect.
    // Now you can start interacting with the XRP Ledger.
    // ...
  };

  return (
    <div>
      {session && (
        <button type="button" onClick={handleDisconnect}>
          Disconnect
        </button>
      )}
    </div>
  );
}
```


# Reconnect

The provider comes with a `reconnect` action that establishes a new connection to WalletConnect (with an existing or stored session).&#x20;

```typescript
// Some where within your codebase...

const { actions } = useProvider();

const response = await actions.reconnect(session)
```

#### Input

This action requires the session to reconnect.

```typescript
session: SessionTypes.Struct // WalletConnect Session
```

#### Return Type

The method will resolve if a connection is re-established by the user.

<pre class="language-typescript"><code class="lang-typescript"><strong>Promise&#x3C;void>
</strong></code></pre>

#### Example usage:

```jsx
// File: ./src/app/component.tsx
'use client';

import * as React from 'react';
import { useProvider } from './page';

export default function Component() {
  const { actions, session, accounts } = useProvider();

  const handleReconnect = async () => {
    const response = await actions.reconnect(session);
    if (response.error) throw response.error;
    // You have been connected using wallet connect.
    // Now you can start interacting with the XRP Ledger.
    // ...
  };

  return (
    <div>
      <button type="button" onClick={handleReconnect}>
        Reconnect
      </button>
      {session && (
        <div>
           <span>Successfully connected!</span>
              {accounts && accounts.map((account,index) => (
		<div key={index}>{account}</div>
	      )
            )}
        </div>
      )}
    </div>
  );
}
```


# Generate

The provider comes with a `generate` action that creates a connection URI and deeplink for custom wallet buttons and actions.&#x20;

```typescript
// Some where within your codebase...

const { actions } = useProvider();

const response = await actions.generate()
```

#### Input (Optional)

This action does not require any inputs (similar to the \`connect\` action), but allows for a \`walletId\` parameter which will automatically generate a custom URI and deeplink for a targeted wallet.&#x20;

{% hint style="info" %}
The `walletId` passed into the generate action has to match one of the wallet provided in the provider conifuration `walletDetails`. If not, the action will fallback to default wc syntax for the generated uri and deeplink (ie: wc://)
{% endhint %}

```typescript
{
    walletId?: string;    
    chain?: string;
    walletId?: string;
    pairing?: { topic: string };
    openModal?: boolean;
}
```

#### Return Type

The method will resolve if a connection is re-established by the user.

```typescript
Promise<{
    uri: string;
    deeplink: string;
}>
```

#### Example usage:

```jsx
// File: ./src/app/component.tsx
'use client';

import * as React from 'react';
import { useProvider } from './page';

import core from '@joey-wallet/wc-client/core';

const wallets = core.constants.wallets;

export default function Component() {
  const { actions, session, accounts } = useProvider();

const handleGenerate = () => {
  const generate = await actions.generate({
    walletId: wallets.joey.projectId,
  });

  // Get raw uri from generate function and manufacture deeplink for mobile
  const uri = generate.data?.uri;
  const deeplink = generate.data?.deeplink;

  if (isMobile) {
    const openDeeplink = (link: string) => (window.location.href = link);
    if (deeplink) openDeeplink(deeplink);
  } else {
    openModal && triggerModal(true);
  }

  return new Promise((resolve, reject) => {
    // Listen for connect event to capture session and URI
    const onConnect = () => {
      resolve(true);
      // Clean up listener
      provider.off('connect', onConnect);
    };

    // Handle provider errors
    const onError = () => {
      triggerModal(false); // Close modal on error
      reject(new Error(`Failed to connect`));
      provider.off('error', onError);
    };

    // Register event listeners
    provider.on('connect', onConnect);
    provider.on('error', onError);
  });
};

  return (
    <div>
      <button type="button" onClick={handleGenerate}>
        Generate
      </button>
      {session && (
        <div>
           <span>Successfully connected!</span>
              {accounts && accounts.map((account,index) => (
		<div key={index}>{account}</div>
	      )
            )}
        </div>
      )}
    </div>
  );
}
```


# Supported Networks

Joey Wallet currently supports the following networks:

* **XRP Ledger**: Mainnet, Testnet, Devnet

More networks will be supported in the near future. Stay tuned for updates on expanded network compatibility!


# XRP Ledger

## Joey Wallet supports sign requests for the XRP Ledger.

Here is an example of the enhanced namespace (XRPL) supported within `Joey Wallet` and the `wc-client`:&#x20;

```typescript
  [
    xrpl,
    {
      chains: [{
        id: 'xrpl:0',
        name: 'XRPL',
        http: ['https://s1.ripple.com:51234/'],
        ws: ['wss://s1.ripple.com/'],
        nativeCurrency: { name: 'XRP', symbol: 'XRP', decimals: 6 },
        explorers: [{ name: 'XRPL Explorer', url: 'https://livenet.xrpl.org/' }],
        isDev: false,
      }],
      events: [],
      methods: ['xrpl_signTransaction','xrpl_signTransactionFor','xrpl_signTransactionBatch','xrpl_signTransactionFee'],
    },
  ],
```

To view all of the supported XRP Ledger namespaces and chains, reference our codebase [here](https://github.com/Joey-Wallet/wc-client/blob/main/packages/core/src/common/constants/chains/xrpl.ts).\
\ <br>


# Chains

For the XRP Ledger, we support the Mainnet (xrpl:0), Testnet (xrpl:1) and Devnet (xrpl:2).&#x20;

* **Mainnet** (xrpl:0)&#x20;

```typescript
const mainnet: typings.ChainDetails = {
  id: 'xrpl:0',
  name: 'XRPL',
  http: ['https://s1.ripple.com:51234/'],
  ws: ['wss://s1.ripple.com/'],
  nativeCurrency: { name: 'XRP', symbol: 'XRP', decimals: 6 },
  explorers: [{ name: 'XRPL Explorer', url: 'https://livenet.xrpl.org/' }],
  isDev: false,
};
```

* **Testnet** (xrpl:1)&#x20;

```typescript
const testnet: typings.ChainDetails = {
  id: 'xrpl:1',
  name: 'XRPL Testnet',
  http: ['https://s.altnet.rippletest.net:51234/'],
  ws: ['wss://s.altnet.rippletest.net:51234/'],
  nativeCurrency: { name: 'XRP', symbol: 'XRP', decimals: 6 },
  explorers: [{ name: 'XRPL Testnet Explorer', url: 'https://testnet.xrpl.org/' }],
  isDev: true,
};
```

* **Devnet** (xrpl:2)&#x20;

```typescript
const devnet: typings.ChainDetails = {
  id: 'xrpl:2',
  name: 'XRPL Devnet',
  http: ['https://s.devnet.rippletest.net:51234/'],
  ws: ['wss://s.devnet.rippletest.net:51234/'], 
  nativeCurrency: { name: 'XRP', symbol: 'XRP', decimals: 6 },
  explorers: [{ name: 'XRPL Devnet Explorer', url: 'https://devnet.xrpl.org/' }],
  isDev: true,
};
```


# Methods

### Supported Methods

For the XRP Ledger, we support the following methods:&#x20;

* [xrpl\_signTransaction](/integration/supported-networks/xrp-ledger/methods/xrpl_signtransaction)
* [xrpl\_signTransactionFor](/integration/supported-networks/xrp-ledger/methods/xrpl_signtransactionfor)
* [xrpl\_signTransactionBulk](/integration/supported-networks/xrp-ledger/methods/xrpl_signtransactionbulk)

{% hint style="info" %}
All methods and abstracted functions are included in the `wc-client`
{% endhint %}

### Example (using `wc-client`)

```typescript
import core from '@joey-wallet/wc-client/core';
const methods = core.methods
```

```typescript
const sign = async () => {
  try {
    const response = await methods.signTransaction({
      provider,
      chainId: 'xrpl:0',
      request: {
        tx_json: {
          TransactionType: 'AccountSet',
          Account: account?.split(':')[2] as string,
        },
        options: { autofill: true, submit: true },
      },
    });

    setResponse(JSON.stringify(response));
  } catch (e: any) {
    console.error(e);
    if (e.message) setResponse(e.message);
    console.error(`error: ${e}`);
  }
};
```


# xrpl\_signTransaction

#### Request structure:&#x20;

```typescript
{
  tx_json: xrpl.Transaction;
  fee?: xrpl.Payment;
  includesFee?: boolean;
  options?: { autofill?: boolean; submit?: boolean };
}
```

#### Usage:

```typescript
provider.request(
    {
      method: 'xrpl_signTransaction',
      params: {
        tx_json: {}, // XRP Ledger transaction object
        options: { autofill: true; submit: true };
      },
    },
    chainId: 'xrpl:0' // xrpl:0, xrpl:1, xrpl:2
);
```

#### Response

```typescript
tx_json: xrpl.TransactionAndMetadata;
```

#### Example using `wc-client`:

```typescript
import core from '@joey-wallet/wc-client/core';
const methods = core.methods

const response = await methods.signTransaction({
  provider,
  chainId: chain,
  request: {
    tx_json: {
      TransactionType: 'AccountSet',
      Account: 'rUmoi1vt8apeKsqFYKMRSiMvWixFDMC8Jz',
    },
    options: { autofill: true, submit: true },
  },
});
```


# xrpl\_signTransactionFor

#### Request structure:&#x20;

```typescript
{  
  tx_signer: string;
  tx_json: xrpl.Transaction;
  options?: { autofill?: boolean; submit?: boolean };
}
```

#### Usage:

```typescript
provider.request(
    {
      method: 'xrpl_signTransactionFor',
      params: {
        tx_signer: 'r.....', // XRP Address
        tx_json: {}, // XRP Ledger transaction object
        options: { autofill: true; submit: true };
      },
    },
    chainId: 'xrpl:0' // xrpl:0, xrpl:1, xrpl:2
);
```

#### Response

```typescript
tx_json: xrpl.TransactionAndMetadata;
```

#### Example using `wc-client`:

```typescript
import core from '@joey-wallet/wc-client/core';
const methods = core.methods

const response = await methods.signTransaction({
  provider,
  chainId: chain,
  request: {
    tx_signer: 'rUmoi1vt8apeKsqFYKMRSiMvWixFDMC8Jz',
    tx_json: {
      TransactionType: 'AccountSet',
      Account: 'rUmoi1vt8apeKsqFYKMRSiMvWixFDMC8Jz'
    },
    options: { autofill: true, submit: true },
  },
});
```


# xrpl\_signTransactionBulk

#### Request structure:&#x20;

```typescript
{  
  txns: xrpl.Transaction[];
  fee?: xrpl.Payment;
  includesFee?: boolean;
  options?: { autofill?: boolean; submit?: boolean };
}
```

#### Usage:

```typescript
provider.request(
    {
      method: 'xrpl_signTransactionBulk',
      params: {
        txns: [], // Array of XRPL transaction objects
        fee: {}, // XRPL Payment Object
        includesFee: true
        options: { autofill: true; submit: true };
      },
    },
    chainId: 'xrpl:0' // xrpl:0, xrpl:1, xrpl:2
);
```

#### Response

```typescript
txns: xrpl.TransactionAndMetadata[];
```

#### Example using `wc-client`:

```typescript
import core from '@joey-wallet/wc-client/core';
const methods = core.methods

const response = await methods.signTransactionBulk({
  provider,
  chainId: chain,
  request: {
    txns: [
      {
        TransactionType: 'AccountSet',
        Account: 'rUmoi1vt8apeKsqFYKMRSiMvWixFDMC8Jz',
      },
      {
        TransactionType: 'AccountSet',
        Account:'rUmoi1vt8apeKsqFYKMRSiMvWixFDMC8Jz',
      },
    ],
    options: { autofill: true, submit: true },
  },
});
```


# Events


# Deeplinking


# Call-to-Action

Join the XRP Ledger Ecosystem

Joey Wallet makes it easier than ever to engage with the XRP Ledger’s fast, cost-effective, and decentralized ecosystem. Whether you’re a user looking to manage your XRP or a developer building the next big dApp, Joey Wallet has you covered.

* 🦘 Get Joey Wallet Today: [iOS](https://t.co/OffywzJ1ey) or [Android](https://t.co/lRPUfho6nt)
* 🧑‍💻 Integrate Joey Wallet into your project: [Here](/integration/install)
* Community: Join the XRPL developer community at [XRPL.org](https://xrpl.org/) or follow [@JoeyWallet](https://t.co/CHfWZqVriw) on X for updates.

> “Joey Wallet is going to onboard the masses. The UI is clean, the setup is smooth, the experience is effortless.” —@echodatruth


# Signer-Tool

> Tagline: Securely Sign XRP Ledger Transactions with Joey Wallet
>
> URL: [joey-signer.vercel.app](https://joey-signer.vercel.app/)&#x20;

### Overview

Joey Signer is a lightweight, secure tool designed for developers to interact with Joey Wallet for signing XRP Ledger (XRPL) transactions. Built to streamline transaction authorization, Joey Signer ensures private keys remain on the user’s device, maintaining the self-custodial ethos of Joey Wallet. Whether you’re building a dApp or integrating payment flows, Joey Signer simplifies transaction signing with a clean API and robust security

### Key Features

* Secure Signing: Transactions are signed on-device using Joey Wallet’s encrypted key storage, ensuring private keys never leave the user’s phone.
* Broad Transaction Support: Supports all XRPL transaction types, including Payments, Trustlines, Escrows, and AMM interactions.
* WalletConnect Integration: Seamlessly connects to dApps via WalletConnect, enabling QR code-based authentication.
* Developer-Friendly API: Easy-to-use endpoints for submitting and signing transactions.
* Open-Source: Fully transparent codebase, for security and reliability.


# Payment Requests

> Tagline: Simplify XRPL Payments with Seamless Requests

### Overview

The Joey Payment Request Tool enables developers and merchants to issue payment requests to Joey Wallet users on the XRP Ledger. Designed for speed and ease, this tool allows businesses to generate standardized payment requests that users can approve via Joey Wallet, leveraging the XRPL’s 3-5 second transaction settlement for near-instant payments.

### Key Features

* Standardized Requests: Create payment requests with predefined amounts, destinations, and memos.
* WalletConnect Support: Users approve requests securely via QR code scanning in Joey Wallet.
* Customizable: Add metadata like invoice IDs or product details for seamless merchant integration.
* Low Fees: Leverage XRPL’s minimal transaction costs (fractions of a cent).
* Multi-Asset Support: Request payments in XRP or any XRPL-issued token.


# Universal Links

> Tagline: Connect Seamlessly with Standardized XRPL URIs

### Overview

Joey Wallet adopts the XLS-32d standard for generating universal links and QR codes, enabling standardized interactions across the XRP Ledger ecosystem. Powered by StandardConnect, a initiative tackling interoperability within XRP Ledger, these links simplify payments, dApp connections, and transaction requests. XLS-32d offers robust features compared to other URI schemes, ensuring flexibility and future-proofing for developers and users.


# Reusable Components