XRPL-GO

https://github.com/xrplf/xrpl-go
Admin
XRPL-GO is a Go library that provides a comprehensive implementation for interacting with the XRP...
Tokens:53,911
Snippets:472
Trust Score:9
License:MIT
Update:5 months ago
Show doc for...
Tokens:
Raw
### Install Dependencies and Run Tests

Source: https://github.com/xrplf/xrpl-go/blob/main/CONTRIBUTING.md

Installs project dependencies, runs linting, and executes tests. Ensure Go 1.22.0 or later is installed.

```bash
git clone https://github.com/Peersyst/xrpl-go

# Install dependencies
go mod tidy

# Run linting
make lint

# Run tests
make test-ci
```

--------------------------------

### Install Go Dependencies

Source: https://github.com/xrplf/xrpl-go/blob/main/README.md

Installs project dependencies. Use `go mod tidy` for global installation or `go mod vendor` to install them locally in a `vendor` directory.

```bash
go mod tidy
```

```bash
go mod vendor
```

--------------------------------

### Start Local Development Server

Source: https://github.com/xrplf/xrpl-go/blob/main/docs/README.md

Starts a local development server for the website. Changes are reflected live without a server restart.

```bash
$ yarn start
```

--------------------------------

### Example: OfferCreate with Flags

Source: https://github.com/xrplf/xrpl-go/blob/main/docs/docs/xrpl/flag.md

Demonstrates setting and checking flags on an OfferCreate transaction. It shows how to set the TfSell flag and then verify its presence, as well as confirm the absence of the TfFillOrKill flag.

```go
package main

import (
	"fmt"

	"github.com/Peersyst/xrpl-go/xrpl/flag"
	"github.com/Peersyst/xrpl-go/xrpl/transaction"
)

func main() {
	offer := transaction.OfferCreate{
		BaseTx: transaction.BaseTx{
			Account: "rPT1Sjq2YGrBMTttX4GZHjKu9dyfzbpAYe",
		},
		TakerGets: nil,
		TakerPays: nil,
	}

	// Set the sell flag on the offer
	offer.SetSellFlag()

	// Check whether the sell flag is set
	if flag.Contains(offer.Flags, transaction.TfSell) {
		fmt.Println("Offer is a sell offer")
	}

	// Check whether the fill-or-kill flag is set (it is not)
	if !flag.Contains(offer.Flags, transaction.TfFillOrKill) {
		fmt.Println("Offer is not fill-or-kill")
	}
}
```

--------------------------------

### Install Project Dependencies

Source: https://github.com/xrplf/xrpl-go/blob/main/docs/README.md

Installs project dependencies using Yarn. This is the first step before running any other commands.

```bash
$ yarn
```

--------------------------------

### Complete XRPL Wallet and Transaction Workflow

Source: https://github.com/xrplf/xrpl-go/blob/main/docs/docs/xrpl/wallet.md

A comprehensive example demonstrating wallet generation, payment transaction creation, and signing, including necessary imports and error handling.

```go
package main

import (
	"fmt"
	"log"

	"github.com/Peersyst/xrpl-go/pkg/crypto"
	"github.com/Peersyst/xrpl-go/xrpl/transaction"
	"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
	"github.com/Peersyst/xrpl-go/xrpl/wallet"
)

func main() {
	wallet, err := wallet.New(crypto.ED25519())
	if err != nil {
		log.Fatal(err)
	}

	payment := transaction.Payment{
		BaseTx: transaction.BaseTx{
			Account: wallet.ClassicAddress,
		},
		Destination: "rJ96831v5JXxna35JYvsW9VRmENwq23ib9",
		Amount:      types.XRPCurrencyAmount(10000000),
		DeliverMax:  types.XRPCurrencyAmount(10000000),
	}

	bl, hash, err := wallet.Sign(payment.Flatten())
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println("Tx blob: ", bl)
	fmt.Println("Tx hash: ", hash)
}
```

--------------------------------

### Start Local Rippled Node (arm64)

Source: https://github.com/xrplf/xrpl-go/blob/main/CLAUDE.md

Start a local rippled node for integration testing on Linux systems with arm64 architecture.

```bash
make run-localnet-linux/arm64
```

--------------------------------

### Import and Use xrpl-go SDK

Source: https://github.com/xrplf/xrpl-go/blob/main/docs/docs/installation.md

Import the xrpl package and create a new WebSocket client to connect to the XRPL testnet. This example demonstrates connecting to the testnet and handling potential errors.

```go
package main

import (
	"fmt"

	"github.com/Peersyst/xrpl-go/xrpl/faucet"
	"github.com/Peersyst/xrpl-go/xrpl/websocket"
)

func main() {
	client := websocket.NewClient(
		websocket.NewClientConfig().
			WithHost("wss://s.altnet.rippletest.net:51233").
			WithFaucetProvider(faucet.NewTestnetFaucetProvider()),
	)
	defer client.Disconnect()

	if err := client.Connect(); err != nil {
		fmt.Println(err)
		return
	}
}
```

--------------------------------

### Start Local Rippled Node (amd64)

Source: https://github.com/xrplf/xrpl-go/blob/main/CLAUDE.md

Start a local rippled node for integration testing on Linux systems with amd64 architecture.

```bash
make run-localnet-linux/amd64
```

--------------------------------

### Payment Channel Authorization Example

Source: https://github.com/xrplf/xrpl-go/blob/main/docs/docs/xrpl/wallet.md

Example demonstrating how to use the `AuthorizeChannel` function to generate a signature for redeeming XRP from a payment channel.

```APIDOC
```go
package main

import (
	"fmt"
	"log"

	"github.com/Peersyst/xrpl-go/xrpl/wallet"
)

func main() {
	// Example-only seed for testnet demos. Do not commit real seeds or use this in production.
	wallet, err := wallet.FromSeed("snGHNrPbHrdUcszeuDEigMdC1Lyyd", "")
	if err != nil {
		log.Fatal(err)
	}

	// Authorize redemption of 1 XRP (1,000,000 drops) from a payment channel
	channelID := "5DB01B7FFED6B67E6B0414DED11E051D2EE2B7619CE0EAA6286D67A3A4D5BDB3"
	amount := "1000000" // 1 XRP in drops

	signature, err := wallet.AuthorizeChannel(channelID, amount, wallet)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println("Authorization signature:", signature)
}
```
```

--------------------------------

### Send Payment Transaction Example

Source: https://github.com/xrplf/xrpl-go/blob/main/docs/docs/xrpl/websocket.md

This example demonstrates how to send a payment transaction on the XRPL testnet using the websocket client. It covers wallet creation, funding, transaction construction, signing, and submission with waiting for ledger inclusion.

```go
package main

import (
	"fmt"
	"strconv"

	"github.com/Peersyst/xrpl-go/xrpl/currency"
	"github.com/Peersyst/xrpl-go/xrpl/faucet"
	"github.com/Peersyst/xrpl-go/xrpl/transaction"
	"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
	"github.com/Peersyst/xrpl-go/xrpl/wallet"
	"github.com/Peersyst/xrpl-go/pkg/crypto"
	"github.com/Peersyst/xrpl-go/xrpl/websocket"
)

func main() {

	// Create a new websocket client with a testnet faucet provider
	client := websocket.NewClient(
		websocket.NewClientConfig().
			WithHost("wss://s.altnet.rippletest.net:51233").
			WithFaucetProvider(faucet.NewTestnetFaucetProvider()),
	)
	defer client.Disconnect()

	// Connect to the testnet
	if err := client.Connect(); err != nil {
		fmt.Println(err)
		return
	}

	// Check if the client is connected
	if !client.IsConnected() {
		return
	}

	// Create a new wallet with the ed25519 algorithm
	w, err := wallet.New(crypto.ED25519())
	if err != nil {
		fmt.Println(err)
		return
	}

	// Fund the wallet with the testnet faucet
	if err := client.FundWallet(&w); err != nil {
		fmt.Println(err)
		return
	}

	// Convert the amount to drops
	xrpAmount, err := currency.XrpToDrops("1")
	if err != nil {
		fmt.Println(err)
		return
	}

	xrpAmountInt, err := strconv.ParseInt(xrpAmount, 10, 64)
	if err != nil {
		fmt.Println(err)
		return
	}

	p := &transaction.Payment{
		BaseTx: transaction.BaseTx{
			Account: types.Address(w.GetAddress()),
		},
		Destination: "rPT1Sjq2YGrBMTttX4GZHjKu9dyfzbpAYe",
		Amount:      types.XRPCurrencyAmount(xrpAmountInt),
		DeliverMax:  types.XRPCurrencyAmount(xrpAmountInt),
	}

	flattenedTx := p.Flatten()

	// Autofill the transaction with the client's config
	if err := client.Autofill(&flattenedTx); err != nil {
		fmt.Println(err)
		return
	}

	// Sign the transaction with the wallet
	txBlob, _, err := w.Sign(flattenedTx)
	if err != nil {
		fmt.Println(err)
		return
	}

	// Submit the transaction to the network and wait for it to be included in a ledge
	res, err := client.SubmitTxBlobAndWait(txBlob, false)
	if err != nil {
		fmt.Println(err)
		return
	}
}
```

--------------------------------

### Execute Unit and Integration Tests

Source: https://github.com/xrplf/xrpl-go/blob/main/AGENTS.md

Run comprehensive unit tests with 'make test-ci' (clean cache, parallel) or 'make test-all' (standard). Execute package-specific tests like 'make test-binary-codec'. For integration tests, start a local rippled node using 'make run-localnet-linux/amd64' or 'make run-localnet-linux/arm64', then run tests with 'make test-integration-localnet'.

```bash
# Unit tests
make test-ci        # Run all unit tests (CI mode, clean cache, parallel)
make test-all       # Run all unit tests (standard mode)

# Package-specific tests
make test-binary-codec   # Test binary-codec package
make test-address-codec  # Test address-codec package
make test-keypairs       # Test keypairs package
make test-xrpl           # Test xrpl package

# Integration tests (require running network)
make run-localnet-linux/amd64       # Start local rippled node (amd64)
make run-localnet-linux/arm64       # Start local rippled node (arm64)
make test-integration-localnet      # Run integration tests on localnet
make test-integration-devnet        # Run integration tests on devnet
make test-integration-testnet       # Run integration tests on testnet
```

--------------------------------

### Download xrpl-go Package

Source: https://github.com/xrplf/xrpl-go/blob/main/docs/docs/installation.md

Use this command to download the latest version of the xrpl-go package into your Go workspace. Ensure you have Go installed and a Go workspace set up.

```bash
go get github.com/Peersyst/xrpl-go
```

--------------------------------

### Run Linter

Source: https://github.com/xrplf/xrpl-go/blob/main/README.md

Executes the project's linter. This command will automatically install `golangci-lint` if it's not already present, ensuring consistency with CI/CD workflows.

```bash
make lint
```

--------------------------------

### Send a Payment Transaction with XRPL RPC

Source: https://github.com/xrplf/xrpl-go/blob/main/docs/docs/xrpl/rpc.md

This example demonstrates how to send a payment transaction to the XRPL testnet using the rpc package. It covers client configuration, wallet creation, funding, transaction construction, autofilling, signing, and submission.

```go
package main

import (
	"fmt"
	"strconv"

	"github.com/Peersyst/xrpl-go/xrpl/currency"
	"github.com/Peersyst/xrpl-go/xrpl/faucet"
	"github.com/Peersyst/xrpl-go/xrpl/rpc"
	"github.com/Peersyst/xrpl-go/pkg/crypto"
	"github.com/Peersyst/xrpl-go/xrpl/transaction"
	"github.com/Peersyst/xrpl-go/xrpl/transaction/types"
	"github.com/Peersyst/xrpl-go/xrpl/wallet"
)

func main() {

	// Create a new rpc client config with a testnet faucet provider
	cfg, err := rpc.NewClientConfig(
		"https://s.altnet.rippletest.net:51234/",
		rpc.WithMaxFeeXRP(5.0),
		rpc.WithFeeCushion(1.5),
		rpc.WithFaucetProvider(faucet.NewTestnetFaucetProvider()),
	)
	if err != nil {
		panic(err)
	}

	// Create a new rpc client with the config
	client := rpc.NewClient(cfg)

	// Create a new wallet with the ed25519 algorithm
	w, err := wallet.New(crypto.ED25519())
	if err != nil {
		fmt.Println(err)
		return
	}

	// Fund the wallet with the testnet faucet
	if err := client.FundWallet(&w); err != nil {
		fmt.Println(err)
		return
	}

	// Convert the amount to drops
	xrpAmount, err := currency.XrpToDrops("1")
	if err != nil {
		fmt.Println(err)
		return
	}

	xrpAmountInt, err := strconv.ParseInt(xrpAmount, 10, 64)
	if err != nil {
		fmt.Println(err)
		return
	}

	p := &transaction.Payment{
		BaseTx: transaction.BaseTx{
			Account: types.Address(w.GetAddress()),
		},
		Destination: "rPT1Sjq2YGrBMTttX4GZHjKu9dyfzbpAYe",
		Amount:      types.XRPCurrencyAmount(xrpAmountInt),
		DeliverMax:  types.XRPCurrencyAmount(xrpAmountInt),
	}

	flattenedTx := p.Flatten()

	// Autofill the transaction with the client's config
	if err := client.Autofill(&flattenedTx); err != nil {
		fmt.Println(err)
		return
	}

	// Sign the transaction with the wallet
	txBlob, _, err := w.Sign(flattenedTx)
	if err != nil {
		fmt.Println(err)
		return
	}

	// Submit the transaction to the network and wait for it to be included in a ledger
	res, err := client.SubmitTxBlobAndWait(txBlob, false)
	if err != nil {
		fmt.Println(err)
		return
	}
}

```

--------------------------------

### Generate Seed with Specific Entropy

Source: https://github.com/xrplf/xrpl-go/blob/main/docs/docs/upgrading-from-v0.1.x-to-v0.2.0.md

When providing entropy, it must be exactly 16 raw bytes. This example uses `crypto.ED25519`.

```go
entropy := []byte{
	0x00, 0x01, 0x02, 0x03,
	0x04, 0x05, 0x06, 0x07,
	0x08, 0x09, 0x0A, 0x0B,
	0x0C, 0x0D, 0x0E, 0x0F,
}

seed, err := keypairs.GenerateSeed(entropy, crypto.ED25519(), nil)
```

--------------------------------

### Example: Authorize Payment Channel Redemption

Source: https://github.com/xrplf/xrpl-go/blob/main/docs/docs/xrpl/wallet.md

Demonstrates how to authorize the redemption of 1 XRP from a payment channel using a wallet generated from a seed. Remember to use secure seeds in production.

```go
package main

import (
	"fmt"
	"log"

	"github.com/Peersyst/xrpl-go/xrpl/wallet"
)

func main() {
	// Example-only seed for testnet demos. Do not commit real seeds or use this in production.
	wallet, err := wallet.FromSeed("snGHNrPbHrdUcszeuDEigMdC1Lyyd", "")
	if err != nil {
		log.Fatal(err)
	}

	// Authorize redemption of 1 XRP (1,000,000 drops) from a payment channel
	channelID := "5DB01B7FFED6B67E6B0414DED11E051D2EE2B7619CE0EAA6286D67A3A4D5BDB3"
	amount := "1000000" // 1 XRP in drops

	signature, err := wallet.AuthorizeChannel(channelID, amount, wallet)
	if err != nil {
		log.Fatal(err)
	}

	fmt.Println("Authorization signature:", signature)
}
```

--------------------------------

### Create and Submit Batch Transaction

Source: https://context7.com/xrplf/xrpl-go/llms.txt

This snippet shows how to bundle multiple payment transactions into a single atomic Batch transaction. Inner transactions must have the `TfInnerBatchTxn` flag set and empty `Fee`/`SigningPubKey`. This example uses a single sender account.

```go
package main

import (
    "fmt"

    "github.com/Peersyst/xrpl-go/pkg/crypto"
    "github.com/Peersyst/xrpl-go/xrpl/faucet"
    "github.com/Peersyst/xrpl-go/xrpl/rpc"
    rpctypes "github.com/Peersyst/xrpl-go/xrpl/rpc/types"
    "github.com/Peersyst/xrpl-go/xrpl/transaction"
    txntypes "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
    "github.com/Peersyst/xrpl-go/xrpl/wallet"
)

func main() {
    cfg, _ := rpc.NewClientConfig(
        "https://s.devnet.rippletest.net:51234/",
        rpc.WithFaucetProvider(faucet.NewDevnetFaucetProvider()),
    )
    client := rpc.NewClient(cfg)

    sender, _   := wallet.New(crypto.ED25519())
    receiver, _ := wallet.New(crypto.ED25519())
    client.FundWallet(&sender)

    innerPay := func(amount int64) txntypes.RawTransaction {
        p := &transaction.Payment{
            BaseTx: transaction.BaseTx{
                Account:         sender.GetAddress(),
                TransactionType: transaction.PaymentTx,
                Flags:           txntypes.TfInnerBatchTxn,
            },
            Amount:      txntypes.XRPCurrencyAmount(amount),
            Destination: receiver.GetAddress(),
        }
        return txntypes.RawTransaction{RawTransaction: p.Flatten()}
    }

    batch := &transaction.Batch{
        BaseTx: transaction.BaseTx{Account: sender.GetAddress()},
        RawTransactions: []txntypes.RawTransaction{
            innerPay(5_000_000),
            innerPay(3_000_000),
        },
    }
    batch.SetAllOrNothingFlag()

    flatBatch := batch.Flatten()
    if err := client.Autofill(&flatBatch); err != nil {
        panic(err)
    }

    res, err := client.SubmitTxAndWait(flatBatch, &rpctypes.SubmitOptions{
        Autofill: false,
        Wallet:   &sender,
    })
    if err != nil {
        panic(err)
    }
    fmt.Printf("Batch hash: %s  validated: %t\n", res.Hash.String(), res.Validated)
}
```

--------------------------------

### Create Client with Custom Options

Source: https://github.com/xrplf/xrpl-go/blob/main/docs/docs/xrpl/rpc.md

Demonstrates creating an XRPL RPC client configuration with custom options, including a specific faucet provider and fee cushion.

```go
cfg, err := rpc.NewClientConfig("https://s.altnet.rippletest.net:51234/",
	rpc.WithFaucetProvider(faucet.NewTestnetFaucetProvider()),
	rpc.WithFeeCushion(1.5),
)
if err != nil {
	// ...
}
client := rpc.NewClient(cfg)
```

--------------------------------

### Import XRPL Go Faucet Package

Source: https://github.com/xrplf/xrpl-go/blob/main/docs/docs/xrpl/faucet.md

Import the faucet package to use its functionalities. This is the initial step before initializing any faucet providers.

```go
import "github.com/Peersyst/xrpl-go/xrpl/faucet"
```

--------------------------------

### Set Trustline and Issue Tokens with xrpl-go

Source: https://context7.com/xrplf/xrpl-go/llms.txt

This Go program demonstrates how to set up a trust line for an issued currency and then make a payment. It requires funding two wallets and then executing a TrustSet transaction followed by a Payment transaction.

```go
package main

import (
    "fmt"

    "github.com/Peersyst/xrpl-go/pkg/crypto"
    "github.com/Peersyst/xrpl-go/xrpl/faucet"
    "github.com/Peersyst/xrpl-go/xrpl/rpc"
    "github.com/Peersyst/xrpl-go/xrpl/transaction"
    "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
    "github.com/Peersyst/xrpl-go/xrpl/wallet"
)

func signAndSubmit(client *rpc.Client, w *wallet.Wallet, tx interface{ Flatten() transaction.FlatTransaction }) error {
    flat := tx.Flatten()
    if err := client.Autofill(&flat); err != nil {
        return err
    }
    blob, _, err := w.Sign(flat)
    if err != nil {
        return err
    }
    res, err := client.SubmitTxBlobAndWait(blob, false)
    if err != nil {
        return err
    }
    fmt.Printf("Hash: %s  Validated: %t\n", res.Hash.String(), res.Validated)
    return nil
}

func main() {
    cfg, _ := rpc.NewClientConfig(
        "https://s.altnet.rippletest.net:51234/",
        rpc.WithFaucetProvider(faucet.NewTestnetFaucetProvider()),
    )
    client := rpc.NewClient(cfg)

    issuer, _ := wallet.New(crypto.ED25519())
    holder, _ := wallet.New(crypto.ED25519())
    client.FundWallet(&issuer)
    client.FundWallet(&holder)

    // Holder sets trust line for FOO issued by issuer
    ts := &transaction.TrustSet{
        BaseTx: transaction.BaseTx{Account: holder.GetAddress()},
        LimitAmount: types.IssuedCurrencyAmount{
            Currency: "FOO",
            Issuer:   issuer.GetAddress(),
            Value:    "10000000000",
        },
    }
    signAndSubmit(client, &holder, ts)

    // Issuer sends 50 FOO to holder
    p := &transaction.Payment{
        BaseTx:      transaction.BaseTx{Account: issuer.GetAddress()},
        Amount:      types.IssuedCurrencyAmount{Currency: "FOO", Issuer: issuer.GetAddress(), Value: "50"},
        Destination: holder.GetAddress(),
    }
    signAndSubmit(client, &issuer, p)
}
```

--------------------------------

### Import Server Package

Source: https://github.com/xrplf/xrpl-go/blob/main/docs/docs/xrpl/queries.md

Import the server package to interact with the rippled server for information such as server status and fees.

```go
import "github.com/Peersyst/xrpl-go/xrpl/queries/server"
```

--------------------------------

### Create and Configure RPC Client

Source: https://context7.com/xrplf/xrpl-go/llms.txt

Creates an HTTP/JSON-RPC client for XRPL nodes. Configure with options like fee limits, retry behavior, timeouts, and faucet providers.

```go
package main

import (
    "fmt"
    "time"

    "github.com/Peersyst/xrpl-go/xrpl/faucet"
    "github.com/Peersyst/xrpl-go/xrpl/rpc"
)

func main() {
    cfg, err := rpc.NewClientConfig(
        "https://s.altnet.rippletest.net:51234/",
        rpc.WithFaucetProvider(faucet.NewTestnetFaucetProvider()),
        rpc.WithTimeout(15*time.Second),
        rpc.WithMaxFeeXRP(1.0),
        rpc.WithFeeCushion(1.5),
        rpc.WithMaxRetries(3),
        rpc.WithRetryDelay(500*time.Millisecond),
        rpc.WithMaxResponseSize(32*1024*1024), // 32 MiB
    )
    if err != nil {
        panic(err)
    }

    client := rpc.NewClient(cfg)
    fmt.Println("RPC client ready:", client != nil)
}
```

--------------------------------

### GenerateSeed

Source: https://github.com/xrplf/xrpl-go/blob/main/docs/docs/keypairs.md

Generates a base58-encoded seed from provided entropy, a cryptographic algorithm, and a randomizer. If entropy is nil or empty, random entropy is generated. The seed starts with the character 's'.

```APIDOC
## GenerateSeed

### Description
Generate a seed that can be used to generate keypairs. You can provide exactly 16 raw entropy bytes or let the function generate random entropy by passing nil or an empty byte slice and providing a randomizer. The result is a base58-encoded seed, which starts with the character `s`.

### Function Signature
```go
func GenerateSeed(entropy []byte, alg interfaces.KeypairCryptoAlg, r interfaces.Randomizer) (string, error)
```

### Parameters
- **entropy** ([]byte) - Optional - Exactly 16 raw entropy bytes. If nil or empty, random entropy is generated.
- **alg** (interfaces.KeypairCryptoAlg) - Required - The cryptographic algorithm to use (e.g., crypto.SECP256K1()).
- **r** (interfaces.Randomizer) - Optional - A randomizer instance (e.g., random.NewRandomizer()). If entropy is nil or empty, this is used for random entropy generation.

### Returns
- **string**: The base58-encoded seed.
- **error**: An error if the seed generation fails.
```

--------------------------------

### Create XRPL RPC Client

Source: https://github.com/xrplf/xrpl-go/blob/main/docs/docs/xrpl/rpc.md

Initializes a new XRPL RPC client configuration with a given URL and creates a client instance. The configuration can be further customized using various options.

```go
cfg, err := rpc.NewClientConfig("<url>")
if err != nil {
	// ...
}
client := rpc.NewClient(cfg)
```

--------------------------------

### Import NFT Package

Source: https://github.com/xrplf/xrpl-go/blob/main/docs/docs/xrpl/queries.md

Import the nft package to query NFT buy and sell offers on the XRPL.

```go
import "github.com/Peersyst/xrpl-go/xrpl/queries/nft"
```

--------------------------------

### Import Utility Package

Source: https://github.com/xrplf/xrpl-go/blob/main/docs/docs/xrpl/queries.md

Import the utility package for general XRPL utility functions like generating random numbers and pinging the server.

```go
import "github.com/Peersyst/xrpl-go/xrpl/queries/utility"
```

--------------------------------

### Deterministic Seed Generation from Passphrase

Source: https://github.com/xrplf/xrpl-go/blob/main/docs/docs/upgrading-from-v0.1.x-to-v0.2.0.md

For deterministic seed generation using a passphrase, derive exactly 16 bytes externally before calling `GenerateSeed`. This example uses SHA512.

```go
sum := sha512.Sum512([]byte(passphrase))
seed, err := keypairs.GenerateSeed(sum[:addresscodec.FamilySeedLength], crypto.ED25519(), nil)
```

--------------------------------

### Submit XRP Payment Transaction

Source: https://context7.com/xrplf/xrpl-go/llms.txt

Constructs, autofills, signs, and submits an XRP payment transaction, waiting for ledger confirmation. Requires wallet setup and transaction details.

```go
package main

import (
    "fmt"

    "github.com/Peersyst/xrpl-go/pkg/crypto"
    "github.com/Peersyst/xrpl-go/xrpl/faucet"
    "github.com/Peersyst/xrpl-go/xrpl/rpc"
    "github.com/Peersyst/xrpl-go/xrpl/transaction"
    "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
    "github.com/Peersyst/xrpl-go/xrpl/wallet"
)

func main() {
    cfg, _ := rpc.NewClientConfig(
        "https://s.altnet.rippletest.net:51234/",
        rpc.WithFaucetProvider(faucet.NewTestnetFaucetProvider()),
    )
    client := rpc.NewClient(cfg)

    sender, _ := wallet.New(crypto.ED25519())
    receiver, _ := wallet.New(crypto.ED25519())
    client.FundWallet(&sender)

    // XRP payment: 10 XRP (10,000,000 drops)
    pay := &transaction.Payment{
        BaseTx:      transaction.BaseTx{Account: sender.GetAddress()},
        Amount:      types.XRPCurrencyAmount(10_000_000),
        Destination: receiver.GetAddress(),
    }

    flat := pay.Flatten()
    if err := client.Autofill(&flat); err != nil {
        panic(err)
    }
    blob, _, err := sender.Sign(flat)
    if err != nil {
        panic(err)
    }
    res, err := client.SubmitTxBlobAndWait(blob, false)
    if err != nil {
        panic(err)
    }
    fmt.Printf("Hash:      %s\nValidated: %t\n", res.Hash.String(), res.Validated)
    // Output:
    // Hash:      A1B2C3...
    // Validated: true
}
```

--------------------------------

### Import Oracle Package

Source: https://github.com/xrplf/xrpl-go/blob/main/docs/docs/xrpl/queries.md

Import the oracle package to retrieve aggregate price data from XRPL oracles.

```go
import "github.com/Peersyst/xrpl-go/xrpl/queries/oracle"
```

--------------------------------

### Importing XRPL API v1 Account Queries in Go

Source: https://github.com/xrplf/xrpl-go/blob/main/docs/docs/xrpl/queries.md

Demonstrates how to import the v1 version of the account queries package for specific API version usage.

```go
import accountv1 "github.com/Peersyst/xrpl-go/xrpl/queries/account/v1"
```

--------------------------------

### Import XRPL Hash Package

Source: https://github.com/xrplf/xrpl-go/blob/main/docs/docs/xrpl/hash.md

Import the hash package to use its hashing functions for XRPL transactions.

```go
import "github.com/Peersyst/xrpl-go/xrpl/hash"
```

--------------------------------

### Submit Transaction with Wallet and Autofill using xrpl-go

Source: https://context7.com/xrplf/xrpl-go/llms.txt

This Go snippet shows how to submit a transaction using `client.SubmitTxAndWait`, which combines signing, autofill, submission, and waiting. It's useful when the wallet is known at submission time.

```go
package main

import (
    "encoding/hex"
    "fmt"

    "github.com/Peersyst/xrpl-go/examples/clients"
    "github.com/Peersyst/xrpl-go/pkg/crypto"
    rpcTypes "github.com/Peersyst/xrpl-go/xrpl/rpc/types"
    "github.com/Peersyst/xrpl-go/xrpl/transaction"
    "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
    "github.com/Peersyst/xrpl-go/xrpl/wallet"
)

func main() {
    client := clients.GetTestnetRPCClient()

    w, _ := wallet.New(crypto.ED25519())
    client.FundWallet(&w)

    as := &transaction.AccountSet{
        BaseTx: transaction.BaseTx{Account: w.GetAddress()},
        Domain: types.Domain(hex.EncodeToString([]byte("example.com"))),
    }
    flat := as.Flatten()

    res, err := client.SubmitTxAndWait(flat, &rpcTypes.SubmitOptions{
        Wallet:   &w,
        Autofill: true,
    })
    if err != nil {
        panic(err)
    }
    fmt.Printf("AccountSet hash: %s  validated: %t\n", res.Hash.String(), res.Validated)
}
```

--------------------------------

### XRP Payment Transaction

Source: https://context7.com/xrplf/xrpl-go/llms.txt

The canonical flow for submitting a signed XRP or issued-currency payment: construct the transaction struct, call `Flatten()` to get a `FlatTransaction` map, `Autofill` to fill in `Sequence`/`Fee`/`LastLedgerSequence`, `wallet.Sign` to produce the hex blob, and `SubmitTxBlobAndWait` to submit and wait for ledger confirmation.

```APIDOC
## XRP Payment Transaction — `transaction.Payment` + `client.Autofill` + `wallet.Sign` + `client.SubmitTxBlobAndWait`

The canonical flow for submitting a signed XRP or issued-currency payment: construct the transaction struct, call `Flatten()` to get a `FlatTransaction` map, `Autofill` to fill in `Sequence`/`Fee`/`LastLedgerSequence`, `wallet.Sign` to produce the hex blob, and `SubmitTxBlobAndWait` to submit and wait for ledger confirmation.

### Method
1. `transaction.Payment` (Constructor)
2. `Flatten()` (Method on `transaction.Payment`)
3. `client.Autofill()`
4. `wallet.Sign()`
5. `client.SubmitTxBlobAndWait()`

### Parameters
- `transaction.Payment` requires `BaseTx`, `Amount`, and `Destination`.
- `client.Autofill` takes a `FlatTransaction`.
- `wallet.Sign` takes a `FlatTransaction`.
- `client.SubmitTxBlobAndWait` takes the signed transaction blob.

### Request Example
```go
// Assuming client, sender, and receiver are initialized

// XRP payment: 10 XRP (10,000,000 drops)
pay := &transaction.Payment{
    BaseTx:      transaction.BaseTx{Account: sender.GetAddress()},
    Amount:      types.XRPCurrencyAmount(10_000_000),
    Destination: receiver.GetAddress(),
}

flat := pay.Flatten()
if err := client.Autofill(&flat); err != nil {
    panic(err)
}
blob, _, err := sender.Sign(flat)
if err != nil {
    panic(err)
}
res, err := client.SubmitTxBlobAndWait(blob, false)
if err != nil {
    panic(err)
}
fmt.Printf("Hash:      %s\nValidated: %t\n", res.Hash.String(), res.Validated)
```

### Response
- `client.SubmitTxBlobAndWait` returns a `rpc.SubmitResult` which includes `Hash` and `Validated` status.
```

--------------------------------

### Run GolangCI-Lint and Fix Formatting

Source: https://github.com/xrplf/xrpl-go/blob/main/AGENTS.md

Use 'make lint' to run golangci-lint, which auto-installs if missing. Use 'make lint-fix' to automatically format code with gofmt.

```bash
make lint           # Run golangci-lint (auto-installs if missing)
make lint-fix       # Run gofmt to fix formatting issues
```

--------------------------------

### Generate Coverage Reports and Run Benchmarks

Source: https://github.com/xrplf/xrpl-go/blob/main/AGENTS.md

Generate a unit test coverage report by running 'make coverage-unit'. Execute performance benchmarks using 'make benchmark'.

```bash
# Coverage and benchmarks
make coverage-unit   # Generate coverage report (coverage.html)
make benchmark       # Run benchmarks
```

--------------------------------

### Importing Default XRPL Account Queries in Go

Source: https://github.com/xrplf/xrpl-go/blob/main/docs/docs/xrpl/queries.md

Shows the standard import path for the account queries package, which defaults to the latest API version.

```go
import "github.com/Peersyst/xrpl-go/xrpl/queries/account"
```

--------------------------------

### Fund Wallet on Testnet using XRPL Go

Source: https://github.com/xrplf/xrpl-go/blob/main/docs/docs/xrpl/faucet.md

Initialize the Testnet faucet provider and use it to fund a specified wallet address. This is useful for testing on the XRPL testnet.

```go
testnetFaucet := faucet.NewTestnetFaucetProvider()

err := testnetFaucet.FundWallet("rJ96831v5JXxna35JYvsW9VRmENwq23ib9")
if err != nil {
    // ...
}
```

--------------------------------

### Run All Unit Tests (Standard Mode)

Source: https://github.com/xrplf/xrpl-go/blob/main/CLAUDE.md

Execute all unit tests using the standard mode.

```bash
make test-all
```

--------------------------------

### Import Crypto Package for Wallet Generation

Source: https://github.com/xrplf/xrpl-go/blob/main/docs/docs/xrpl/wallet.md

Import the crypto package to specify the algorithm when generating a random wallet.

```go
import "github.com/Peersyst/xrpl-go/xrpl/crypto"
```

--------------------------------

### Create WebSocket Client

Source: https://context7.com/xrplf/xrpl-go/llms.txt

Creates a WebSocket client using a fluent configuration builder. Requires explicit Connect() and Disconnect() calls. Supports auto-reconnect and stream event handlers.

```go
package main

import (
    "fmt"

    "github.com/Peersyst/xrpl-go/xrpl/faucet"
    "github.com/Peersyst/xrpl-go/xrpl/websocket"
)

func main() {
    client := websocket.NewClient(
        websocket.NewClientConfig().
            WithHost("wss://s.altnet.rippletest.net:51233").
            WithFaucetProvider(faucet.NewTestnetFaucetProvider()).
            WithMaxReconnects(5).
            WithMaxResponseSize(0), // disable size cap
    )

    defer func() {
        if err := client.Disconnect(); err != nil {
            fmt.Println("disconnect error:", err)
        }
    }()

    if err := client.Connect(); err != nil {
        panic(err)
    }
    fmt.Println("connected:", client.IsConnected())
}
```

--------------------------------

### Connect to XRPL WebSocket Server

Source: https://github.com/xrplf/xrpl-go/blob/main/docs/docs/xrpl/websocket.md

Demonstrates connecting to the XRPL devnet using the WebSocket client. Ensure to defer disconnection and handle potential connection errors.

```go
client := websocket.NewClient(websocket.NewClientConfig().WithHost("wss://s.altnet.rippletest.net:51233"))
defer client.Disconnect()

err := client.Connect()
if err != nil {
    // ...
}

if !client.IsConnected() {
    // ...
}
```

--------------------------------

### Fund Wallet on Devnet using XRPL Go

Source: https://github.com/xrplf/xrpl-go/blob/main/docs/docs/xrpl/faucet.md

Initialize the Devnet faucet provider and use it to fund a specified wallet address. Ensure the wallet address is valid.

```go
devnetFaucet := faucet.NewDevnetFaucetProvider()

err := devnetFaucet.FundWallet("rJ96831v5JXxna35JYvsW9VRmENwq23ib9")
if err != nil {
    // ...
}
```

--------------------------------

### Import Path Package

Source: https://github.com/xrplf/xrpl-go/blob/main/docs/docs/xrpl/queries.md

Import the path package to interact with XRPL paths and order books.

```go
import "github.com/Peersyst/xrpl-go/xrpl/queries/path"
```

--------------------------------

### Import XRPL Time Package

Source: https://github.com/xrplf/xrpl-go/blob/main/docs/docs/xrpl/time.md

Import the XRPL time package to use its conversion functions.

```go
import "github.com/Peersyst/xrpl-go/xrpl/time"
```

--------------------------------

### Import XRPL Flag Package

Source: https://github.com/xrplf/xrpl-go/blob/main/docs/docs/xrpl/flag.md

Import the flag package to use its utility functions.

```go
import "github.com/Peersyst/xrpl-go/xrpl/flag"
```

--------------------------------

### Create and Submit Multisigned Transaction

Source: https://context7.com/xrplf/xrpl-go/llms.txt

This snippet demonstrates registering a signer list, building a payment transaction, and then signing and submitting it as a multisigned transaction. Ensure all co-signers have their seeds available and the master account has the signer list set up.

```go
package main

import (
    "fmt"
    "maps"

    "github.com/Peersyst/xrpl-go/xrpl"
    "github.com/Peersyst/xrpl-go/xrpl/faucet"
    ledger "github.com/Peersyst/xrpl-go/xrpl/ledger-entry-types"
    "github.com/Peersyst/xrpl-go/xrpl/rpc"
    "github.com/Peersyst/xrpl-go/xrpl/transaction"
    "github.com/Peersyst/xrpl-go/xrpl/wallet"
)

func main() {
    cfg, _ := rpc.NewClientConfig(
        "https://s.altnet.rippletest.net:51234/",
        rpc.WithFaucetProvider(faucet.NewTestnetFaucetProvider()),
    )
    client := rpc.NewClient(cfg)

    signer1, _ := wallet.FromSeed("sEdTtvLmJmrb7GaivhWoXRkvU4NDjVf", "")
    signer2, _ := wallet.FromSeed("sEdSFiKMQp7RvYLgH7t7FEpwNRWv2Gr", "")
    master, _  := wallet.FromSeed("sEdTMm2yv8c8Rg8YHFHQA9TxVMFy1ze", "")
    client.FundWallet(&signer1)
    client.FundWallet(&signer2)
    client.FundWallet(&master)

    // 1. Register signer list on master account
    ss := &transaction.SignerListSet{
        BaseTx:      transaction.BaseTx{Account: master.GetAddress()},
        SignerQuorum: 2,
        SignerEntries: []ledger.SignerEntryWrapper{
            {SignerEntry: ledger.SignerEntry{Account: signer1.GetAddress(), SignerWeight: 1}},
            {SignerEntry: ledger.SignerEntry{Account: signer2.GetAddress(), SignerWeight: 1}},
        },
    }
    flat := ss.Flatten()
    client.Autofill(&flat)
    blob, _, _ := master.Sign(flat)
    client.SubmitTxBlobAndWait(blob, false)

    // 2. Build the multisig transaction
    pay := &transaction.Payment{
        BaseTx:      transaction.BaseTx{Account: master.GetAddress()},
        Amount:      transaction.BaseTx{}.Fee, // placeholder — autofill fills this
        Destination: signer1.GetAddress(),
    }
    flatPay := pay.Flatten()
    client.AutofillMultisigned(&flatPay, 2) // 2 signers

    blob1, _, _ := signer1.Multisign(maps.Clone(flatPay))
    blob2, _, _ := signer2.Multisign(maps.Clone(flatPay))

    combined, err := xrpl.Multisign(blob1, blob2)
    if err != nil {
        panic(err)
    }

    mRes, err := client.SubmitMultisigned(combined, false)
    if err != nil {
        panic(err)
    }
    fmt.Println("engine result:", mRes.EngineResult)
}
```

--------------------------------

### NewClient

Source: https://github.com/xrplf/xrpl-go/blob/main/docs/docs/xrpl/rpc.md

Initializes a new RPC client with a given configuration. The configuration can be customized using various options.

```APIDOC
## NewClient

### Description
Initializes a new RPC client with a given configuration. The configuration can be customized using various options.

### Method Signature
```go
func NewClient(cfg ClientConfig) *Client
```

### Example
```go
cfg, err := rpc.NewClientConfig("https://s.altnet.rippletest.net:51234/",
	rpc.WithFaucetProvider(faucet.NewTestnetFaucetProvider()),
	rpc.WithFeeCushion(1.5),
)
if err != nil {
	// Handle error
}
client := rpc.NewClient(cfg)
```
```

--------------------------------

### Run Specific Go Tests

Source: https://github.com/xrplf/xrpl-go/blob/main/AGENTS.md

Execute specific test files with 'go test ./path/to/file_test.go'. Run specific test functions using 'go test -run TestFunctionName ./path/to/package'. Use 'go test -v ./path/to/package' for verbose output. For integration tests, set the INTEGRATION environment variable, e.g., 'INTEGRATION=localnet go test ./path/to/integration -v'.

```bash
# Run specific test file
go test ./xrpl/transaction/payment_test.go

# Run specific test function
go test -run TestPayment ./xrpl/transaction

# Run with verbose output
go test -v ./xrpl/transaction

# Run integration tests (set INTEGRATION env var)
INTEGRATION=localnet go test ./xrpl/transaction/integration -v
```

--------------------------------

### Configure WebSocket Client Host

Source: https://github.com/xrplf/xrpl-go/blob/main/docs/docs/xrpl/websocket.md

Use the `WithHost` option to set the WebSocket client's connection endpoint. This is required when initializing the client configuration.

```go
func (wc ClientConfig) WithHost(host string) ClientConfig
```

--------------------------------

### Import Clio Package

Source: https://github.com/xrplf/xrpl-go/blob/main/docs/docs/xrpl/queries.md

Import the clio package to interact with the Clio API for NFT history and information retrieval.

```go
import "github.com/Peersyst/xrpl-go/xrpl/queries/clio"
```

--------------------------------

### Wallet Creation Options

Source: https://github.com/xrplf/xrpl-go/blob/main/xrpl/README.md

Create a new wallet randomly, from an existing seed, or from a BIP-39 mnemonic phrase. Ensure the correct crypto implementation is provided for random generation.

```go
// Random wallet (ED25519 or SECP256K1)
w, err := wallet.New(crypto.ED25519())
```

```go
// From an existing seed
w, err := wallet.FromSeed(seed, "")
w, err := wallet.FromSecret(seed) // alias
```

```go
// From a BIP-39 mnemonic (derives via m/44'/144'/0'/0/0)
w, err := wallet.FromMnemonic("word1 word2 ...")
```

--------------------------------

### Run Benchmarks

Source: https://github.com/xrplf/xrpl-go/blob/main/CLAUDE.md

Execute benchmark tests for performance analysis.

```bash
make benchmark
```

--------------------------------

### WebSocket Client Configuration and Subscription

Source: https://github.com/xrplf/xrpl-go/blob/main/xrpl/README.md

Initialize an asynchronous WebSocket client for real-time XRP Ledger events. Subscribe to specific event streams like ledger closures or transactions and read them from typed channels.

```go
cfg := websocket.NewConfig("wss://s.altnet.rippletest.net:51233")
client, err := websocket.NewClient(cfg)
```

```go
// Subscribe to ledger close events
err = client.SubscribeLedger()
```

```go
// Read events from channels
ledger := <-client.GetLedgerClosedChannel()
tx     := <-client.GetTransactionChannel()
```

--------------------------------

### Build Static Website Content

Source: https://github.com/xrplf/xrpl-go/blob/main/docs/README.md

Generates static website content into the 'build' directory. This content can be hosted on any static hosting service.

```bash
$ yarn build
```

--------------------------------

### Run Integration Tests on Testnet

Source: https://github.com/xrplf/xrpl-go/blob/main/CLAUDE.md

Execute integration tests against the XRPL testnet.

```bash
make test-integration-testnet
```

--------------------------------

### Import XRPL Currency Package

Source: https://github.com/xrplf/xrpl-go/blob/main/docs/docs/xrpl/currency.md

Import the currency package to utilize its conversion functions for XRP/drops and non-standard currency codes.

```go
import "github.com/Peersyst/xrpl-go/xrpl/currency"
```

--------------------------------

### Run Integration Tests on Localnet

Source: https://github.com/xrplf/xrpl-go/blob/main/CLAUDE.md

Execute integration tests against a local network instance.

```bash
make test-integration-localnet
```

--------------------------------

### Run Integration Tests on Devnet

Source: https://github.com/xrplf/xrpl-go/blob/main/CLAUDE.md

Execute integration tests against the XRPL devnet.

```bash
make test-integration-devnet
```

--------------------------------

### Import XRPL RPC Package

Source: https://github.com/xrplf/xrpl-go/blob/main/docs/docs/xrpl/rpc.md

Import the XRPL RPC package to utilize its functionalities in your Go project.

```go
import "github.com/Peersyst/xrpl-go/xrpl/rpc"

```

--------------------------------

### Query Wrappers

Source: https://github.com/xrplf/xrpl-go/blob/main/docs/docs/xrpl/websocket.md

The `websocket` package provides query wrappers to send client queries to the XRPL server.

```APIDOC
## Queries

### Description
Allows sending client queries to the XRPL server using the WebSocket connection.

### Usage
Refer to the [XRPL Queries documentation](/docs/xrpl/queries) for details on available queries.
```
Tokens:
Raw