feat(docs): update docs with new xls changes

GuillemGarciaDev · GuillemGarciaDev · commit 20c7e8a424f4 · 2026-02-02T12:38:14.000+01:00
diff --git a/docs/docs/xrpl/ledger-entry-types.md b/docs/docs/xrpl/ledger-entry-types.md
@@ -17,6 +17,8 @@ The `ledger-entry-types` package contains types and functions to handle ledger o
 - [`Escrow`](https://xrpl.org/docs/references/protocol/ledger-data/ledger-entry-types/escrow)
 - [`FeeSettings`](https://xrpl.org/docs/references/protocol/ledger-data/ledger-entry-types/feesettings)
 - [`Hashes`](https://xrpl.org/docs/references/protocol/ledger-data/ledger-entry-types/ledgerhashes)
+- [`Loan`](https://xrpl.org/docs/references/protocol/ledger-data/ledger-entry-types/loan)
+- [`LoanBroker`](https://xrpl.org/docs/references/protocol/ledger-data/ledger-entry-types/loanbroker)
 - [`NegativeUNL`](https://xrpl.org/docs/references/protocol/ledger-data/ledger-entry-types/negativeunl)
 - [`NFTokenOffer`](https://xrpl.org/docs/references/protocol/ledger-data/ledger-entry-types/nftokenoffer)
 - [`NFTokenPage`](https://xrpl.org/docs/references/protocol/ledger-data/ledger-entry-types/nftokenpage)
diff --git a/docs/docs/xrpl/transaction.md b/docs/docs/xrpl/transaction.md
@@ -29,6 +29,15 @@ These are the transaction types available in the XRPL:
 - [DelegateSet](https://xrpl.org/docs/references/protocol/transactions/types/delegateset)
 - [DIDDelete](https://xrpl.org/docs/references/protocol/transactions/types/diddelete)
 - [DIDSet](https://xrpl.org/docs/references/protocol/transactions/types/didset)
+- [LoanBrokerCoverClawback](https://xrpl.org/docs/references/protocol/transactions/types/loanbrokercoverclawback)
+- [LoanBrokerCoverDeposit](https://xrpl.org/docs/references/protocol/transactions/types/loanbrokercoverdeposit)
+- [LoanBrokerCoverWithdraw](https://xrpl.org/docs/references/protocol/transactions/types/loanbrokercoverwithdraw)
+- [LoanBrokerDelete](https://xrpl.org/docs/references/protocol/transactions/types/loanbrokerdelete)
+- [LoanBrokerSet](https://xrpl.org/docs/references/protocol/transactions/types/loanbrokerset)
+- [LoanDelete](https://xrpl.org/docs/references/protocol/transactions/types/loandelete)
+- [LoanManage](https://xrpl.org/docs/references/protocol/transactions/types/loanmanage)
+- [LoanPay](https://xrpl.org/docs/references/protocol/transactions/types/loanpay)
+- [LoanSet](https://xrpl.org/docs/references/protocol/transactions/types/loanset)
 - [EscrowCancel](https://xrpl.org/docs/references/protocol/transactions/types/escrowcancel)
 - [EscrowCreate](https://xrpl.org/docs/references/protocol/transactions/types/escrowcreate)
 - [EscrowFinish](https://xrpl.org/docs/references/protocol/transactions/types/escrowfinish)
@@ -65,6 +74,309 @@ These are the transaction types available in the XRPL:
 - [XChainCreateClaimID](https://xrpl.org/docs/references/protocol/transactions/types/xchaincreateclaimid)
 - [XChainModifyBridge](https://xrpl.org/docs/references/protocol/transactions/types/xchainmodifybridge)
 
+## MPTokenMetadata
+
+The `MPTokenMetadata` type provides functionality to encode, decode, and validate metadata for Multi-Purpose Tokens (MPTs) as per the [XLS-89 standard](https://xls.xrpl.org/xls/XLS-0089-multi-purpose-token-metadata-schema.html). This metadata includes information about the token such as ticker, name, description, icon, asset classification, and related URIs.
+
+### Overview
+
+MPTokenMetadata is used in MPToken transactions (like `MPTokenIssuanceCreate`) to provide structured metadata about tokens. The metadata is encoded as a hex string and must comply with the XLS-89 standard, which includes:
+
+- Maximum size limit of 1024 bytes
+- Support for both long-form and compact-form JSON keys
+- Validation of required fields, field types, and allowed values
+- Alphabetical ordering of fields for consistent encoding
+
+### Types
+
+#### ParsedMPTokenMetadata
+
+The `ParsedMPTokenMetadata` struct represents the complete metadata structure for an MPToken. Fields are ordered alphabetically by JSON key for consistent encoding.
+
+```go
+type ParsedMPTokenMetadata struct {
+    // Top-level classification of token purpose (required)
+    // Allowed values: "rwa", "memes", "wrapped", "gaming", "defi", "other"
+    AssetClass string `json:"ac"`
+    
+    // Freeform field for key token details (optional)
+    // Can be any valid JSON object or UTF-8 string
+    AdditionalInfo any `json:"ai,omitempty"`
+    
+    // Optional subcategory of the asset class (optional, required if AssetClass is "rwa")
+    // Allowed values: "stablecoin", "commodity", "real_estate", "private_credit", "equity", "treasury", "other"
+    AssetSubclass *string `json:"as,omitempty"`
+    
+    // Short description of the token (optional)
+    Desc *string `json:"d,omitempty"`
+    
+    // URI to the token icon (required)
+    // Can be a hostname/path (HTTPS assumed) or full URI for other protocols (e.g., ipfs://)
+    Icon string `json:"i"`
+    
+    // The name of the issuer account (required)
+    IssuerName string `json:"in"`
+    
+    // Display name of the token (required)
+    Name string `json:"n"`
+    
+    // Ticker symbol used to represent the token (required)
+    // Uppercase letters (A-Z) and digits (0-9) only. Max 6 chars.
+    Ticker string `json:"t"`
+    
+    // List of related URIs (optional)
+    // Each URI object contains the link, its category, and a human-readable title
+    URIs []ParsedMPTokenMetadataURI `json:"us,omitempty"`
+}
+```
+
+**Field Requirements:**
+
+- **Required fields**: `Ticker`, `Name`, `Icon`, `AssetClass`, `IssuerName`
+- **Conditional**: `AssetSubclass` is required when `AssetClass` is `"rwa"`
+- **Optional fields**: `Desc`, `URIs`, `AdditionalInfo`
+
+#### ParsedMPTokenMetadataURI
+
+The `ParsedMPTokenMetadataURI` struct represents a URI entry within the metadata. Fields are ordered alphabetically by JSON key for consistent encoding.
+
+```go
+type ParsedMPTokenMetadataURI struct {
+    // The category of the link (required)
+    // Allowed values: "website", "social", "docs", "other"
+    Category string `json:"c"`
+    
+    // A human-readable label for the link (required)
+    Title string `json:"t"`
+    
+    // URI to the related resource (required)
+    // Can be a hostname/path (HTTPS assumed) or full URI for other protocols (e.g., ipfs://)
+    URI string `json:"u"`
+}
+```
+
+### Functions
+
+#### EncodeMPTokenMetadata
+
+Encodes a `ParsedMPTokenMetadata` struct into a hex string compliant with XLS-89.
+
+```go
+func EncodeMPTokenMetadata(meta ParsedMPTokenMetadata) (string, error)
+```
+
+**Returns:**
+- `string`: The encoded hex string (uppercase)
+- `error`: An error if encoding fails
+
+#### DecodeMPTokenMetadata
+
+Decodes a hex string into a `ParsedMPTokenMetadata` struct. Handles input with either long-form or compact-form keys via custom `UnmarshalJSON` methods.
+
+```go
+func DecodeMPTokenMetadata(hexInput string) (ParsedMPTokenMetadata, error)
+```
+
+**Returns:**
+- `ParsedMPTokenMetadata`: The decoded metadata struct
+- `error`: An error if decoding fails (e.g., invalid hex, invalid JSON)
+
+#### ValidateMPTokenMetadata
+
+Validates MPToken metadata according to the XLS-89 standard. Checks for:
+- Valid hex string format
+- Maximum size limit (1024 bytes)
+- Valid JSON structure
+- Required fields presence
+- Field types and formats
+- Allowed values for enums
+- Field count limits
+
+```go
+func ValidateMPTokenMetadata(input string) error
+```
+
+**Returns:**
+- `error`: `nil` if valid, or `MPTokenMetadataValidationErrors` containing all validation errors
+
+### Constants
+
+```go
+// Maximum byte length for MPToken metadata (1024 bytes)
+const MaxMPTokenMetadataByteLength = 1024
+
+// Allowed values for the asset class field
+var MPTokenMetadataAssetClasses = [6]string{"rwa", "memes", "wrapped", "gaming", "defi", "other"}
+
+// Allowed values for the asset subclass field
+var MPTokenMetadataAssetSubClasses = [7]string{"stablecoin", "commodity", "real_estate", "private_credit", "equity", "treasury", "other"}
+
+// Allowed values for the URI category field
+var MPTokenMetadataURICategories = [4]string{"website", "social", "docs", "other"}
+```
+
+### Usage Examples
+
+#### Creating and Encoding Metadata
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
+)
+
+func main() {
+    // Create metadata struct
+    assetSubclass := "treasury"
+    desc := "A yield-bearing stablecoin backed by short-term U.S. Treasuries."
+    
+    metadata := types.ParsedMPTokenMetadata{
+        Ticker:        "TBILL",
+        Name:          "T-Bill Yield Token",
+        Desc:          &desc,
+        Icon:          "https://example.org/tbill-icon.png",
+        AssetClass:    "rwa",
+        AssetSubclass: &assetSubclass,
+        IssuerName:    "Example Yield Co.",
+        URIs: []types.ParsedMPTokenMetadataURI{
+            {
+                URI:      "https://exampleyield.co/tbill",
+                Category: "website",
+                Title:    "Product Page",
+            },
+            {
+                URI:      "https://exampleyield.co/docs",
+                Category: "docs",
+                Title:    "Yield Token Docs",
+            },
+        },
+        AdditionalInfo: map[string]any{
+            "interest_rate": "5.00%",
+            "maturity_date": "2045-06-30",
+        },
+    }
+    
+    // Encode to hex string
+    hexStr, err := types.EncodeMPTokenMetadata(metadata)
+    if err != nil {
+        panic(err)
+    }
+    
+    fmt.Printf("Encoded metadata: %s\n", hexStr)
+}
+```
+
+#### Decoding Metadata
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
+)
+
+func main() {
+    hexStr := "7B226163223A22727761222C226173223A227472656173757279222C..."
+    
+    // Decode from hex string
+    metadata, err := types.DecodeMPTokenMetadata(hexStr)
+    if err != nil {
+        panic(err)
+    }
+    
+    fmt.Printf("Ticker: %s\n", metadata.Ticker)
+    fmt.Printf("Name: %s\n", metadata.Name)
+    fmt.Printf("Asset Class: %s\n", metadata.AssetClass)
+}
+```
+
+#### Validating Metadata
+
+```go
+package main
+
+import (
+    "fmt"
+    "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
+)
+
+func main() {
+    hexStr := "7B226163223A22727761222C226173223A227472656173757279222C..."
+    
+    // Validate metadata
+    err := types.ValidateMPTokenMetadata(hexStr)
+    if err != nil {
+        fmt.Printf("Validation failed: %v\n", err)
+        return
+    }
+    
+    fmt.Println("Metadata is valid!")
+}
+```
+
+#### Using in MPTokenIssuanceCreate Transaction
+
+```go
+package main
+
+import (
+    "github.com/Peersyst/xrpl-go/xrpl/transaction"
+    "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
+)
+
+func main() {
+    // Create and encode metadata
+    metadata := types.ParsedMPTokenMetadata{
+        Ticker:      "TBILL",
+        Name:        "T-Bill Yield Token",
+        Icon:        "https://example.org/tbill-icon.png",
+        AssetClass:  "rwa",
+        IssuerName:  "Example Yield Co.",
+    }
+    
+    hexStr, _ := types.EncodeMPTokenMetadata(metadata)
+    
+    // Use in transaction
+    tx := transaction.MPTokenIssuanceCreate{
+        BaseTx: transaction.BaseTx{
+            TransactionType: "MPTokenIssuanceCreate",
+            Account:         "rajgkBmMxmz161r8bWYH7CQAFZP5bA9oSG",
+        },
+        AssetScale:     2,
+        TransferFee:    314,
+        MaximumAmount: "50000000",
+        MPTokenMetadata: types.MPTokenMetadata(hexStr),
+    }
+    
+    // ... continue with transaction signing and submission
+}
+```
+
+### JSON Key Formats
+
+The implementation supports both long-form and compact-form JSON keys for backward compatibility and flexibility:
+
+**Long-form keys:**
+- `ticker`, `name`, `desc`, `icon`, `asset_class`, `asset_subclass`, `issuer_name`, `uris`, `additional_info`
+- `uri`, `category`, `title` (for URI objects)
+
+**Compact-form keys:**
+- `t`, `n`, `d`, `i`, `ac`, `as`, `in`, `us`, `ai`
+- `u`, `c`, `t` (for URI objects)
+
+Both formats are accepted when decoding, but encoding always uses compact-form keys for consistency and size efficiency.
+
+### Import
+
+To use MPTokenMetadata types and functions, import:
+
+```go
+import "github.com/Peersyst/xrpl-go/xrpl/transaction/types"
+```
+
 ## Usage
 
 To use the `transaction` package, you need to import it in your project:
diff --git a/docs/docs/xrpl/wallet.md b/docs/docs/xrpl/wallet.md
@@ -8,6 +8,7 @@ This package enables you to do the following actions:
 
 - Generate new wallets using a seed, mnemonic or random.
 - Sign and multisign transactions.
+- Authorize payment channel redemptions.
 - Access to wallet's public and private keys and address.
 
 ## Generating a wallet
@@ -62,6 +63,56 @@ There's also the `SignMultiBatch` package function that signs each `RawTransacti
 func SignMultiBatch(wallet Wallet, tx *transaction.FlatTransaction, opts *SignMultiBatchOptions) error
 ```
 
+## Authorizing payment channel redemptions
+
+The `AuthorizeChannel` function allows you to create a signature that authorizes the redemption of a specific amount of XRP from a payment channel. This is useful for payment channels where the source account needs to authorize claims before they can be redeemed.
+
+```go
+func AuthorizeChannel(channelID, amount string, wallet Wallet) (string, error)
+```
+
+- `channelID` identifies the payment channel (hex-encoded string).
+- `amount` is the amount to redeem, expressed in drops (XRP's smallest unit).
+- Returns the signature string that can be used to authorize the channel claim.
+
+:::info
+
+Payment channels allow for off-ledger transactions between two parties. The `AuthorizeChannel` function creates a signature that authorizes a specific amount to be claimed from the channel. Learn more about payment channels in the [official documentation](https://xrpl.org/docs/concepts/payment-types/payment-channels).
+
+:::
+
+### Example
+
+```go
+package main
+
+import (
+	"fmt"
+	"log"
+
+	"github.com/Peersyst/xrpl-go/xrpl/wallet"
+)
+
+func main() {
+	// Create a wallet from a seed
+	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)
+}
+```
+
 ## Usage
 
 In this section, we will see how to generate a `Wallet`, call the faucet to get XRP, and send the XRP to another account.
