Xaman

https://github.com/wietsewind/xaman-app
Admin
Xaman is a mobile XRP Ledger protocol client (React Native app) that connects to the Xaman platform...
Tokens:6,294
Snippets:32
Trust Score:9.7
Update:1 year ago
Show doc for...
Tokens:
Raw
### Clone Xaman App Repository and Install Dependencies

Source: https://github.com/wietsewind/xaman-app/blob/main/docs/environment-setup.md

Provides commands to clone the Xaman App source code from a GitHub fork and install project dependencies. This involves changing directory, running a make command for npm dependencies, and another make command for environment and pod dependencies.

```shell
cd Xaman-App
```

```shell
make npm-install
```

```shell
make pre-run
```

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

### Clone React Native and Install Dependencies

Source: https://github.com/wietsewind/xaman-app/blob/main/android/app/libs/readme.txt

Clones the React Native repository from GitHub and installs its dependencies using Yarn. This step is essential for building a custom React Native version.

```bash
git clone https://github.com/facebook/react-native.git
cd ~/Desktop/Xaman/react-native
git checkout v0.74.2
yarn install
```

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

### Install Git on macOS using Homebrew

Source: https://github.com/wietsewind/xaman-app/blob/main/docs/environment-setup.md

Installs Git on macOS using the Homebrew package manager. Git is a version control system used for obtaining the source code of the Xaman App and for contributing via pull requests.

```shell
brew install git
```

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

### Install React Native CLI globally using Yarn

Source: https://github.com/wietsewind/xaman-app/blob/main/docs/environment-setup.md

Installs the React Native Command Line Interface (CLI) globally on your system using Yarn. The React Native CLI is necessary for creating and managing React Native projects. The minimum required version is 2.0.1.

```shell
yarn global add react-native-cli
```

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

### Enable Cosmos UI Development Server

Source: https://github.com/wietsewind/xaman-app/blob/main/docs/testing.md

Starts the Cosmos UI development server. This involves running an npm script, uncommenting a specific import line in `index.js`, and commenting out other lines to isolate the Cosmos application.

```bash
npm run cosmos
```

```javascript
import './.cosmos/cosmos.app';
```

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

### Install Watchman on macOS using Homebrew

Source: https://github.com/wietsewind/xaman-app/blob/main/docs/environment-setup.md

Installs Watchman on macOS using the Homebrew package manager. Watchman is a file-watching service required for React Native development, with a minimum version of 2023.12.04.00.

```shell
brew install watchman
```

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

### Install Node.js on macOS using Homebrew

Source: https://github.com/wietsewind/xaman-app/blob/main/docs/environment-setup.md

Installs Node.js on macOS using the Homebrew package manager. Node.js is a prerequisite for React Native development and includes NPM. The minimum required version is 18.19.0.

```shell
brew install node
```

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

### Check Code Style with ESLint

Source: https://github.com/wietsewind/xaman-app/blob/main/docs/testing.md

Verifies the codebase against AirBnB's ES6 and React style guides using ESLint. This command helps maintain code consistency and quality throughout the project.

```bash
make check-style
```

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

### Configure Linux Environment Variables for Android SDK

Source: https://github.com/wietsewind/xaman-app/blob/main/docs/environment-setup.md

Sets up essential environment variables for the Android SDK on Linux systems. This includes defining ANDROID_HOME and adding platform-tools and tools to the system's PATH. The configuration is typically applied by sourcing a profile file like ~/.bash_profile or ~/.zshrc.

```shell
export ANDROID_HOME=/home/<username>/Android/Sdk
export PATH=$ANDROID_HOME/platform-tools:$PATH
export PATH=$ANDROID_HOME/tools:$PATH
```

```shell
source ~/.bash_profile
```

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

### Build and Run Xaman App (Android Gradle)

Source: https://github.com/wietsewind/xaman-app/blob/main/android/app/libs/readme.txt

Commands to clean and assemble the Xaman Android application for debug and release modes. It also includes a command to perform both debug and release builds simultaneously. These are standard Gradle tasks for Android development.

```bash
# Xaman/Android
cd ~/Desktop/Xaman/xaman-app/android
./gradlew clean assembleDebug
./gradlew clean assembleRelease

./gradlew clean assembleDebug assembleRelease
```

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

### Run React Native App on Android

Source: https://github.com/wietsewind/xaman-app/blob/main/android/app/libs/readme.txt

Executes the React Native application on an Android device or emulator using specified build modes (Debug or Release). This command uses the React Native CLI to launch the application.

```bash
#npx react-native run-android --mode=Debug  
#npx react-native run-android --mode=Production
npx react-native run-android --mode=Debug
npx react-native run-android --mode=Release
```

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

### Configure Android Environment Variables on macOS

Source: https://github.com/wietsewind/xaman-app/blob/main/docs/environment-setup.md

Sets up essential environment variables for Android development on macOS. This includes configuring ANDROID_HOME, PATH to include SDK tools, and ANDROID_NDK_HOME. These variables are crucial for the Android SDK and NDK to function correctly.

```shell
export ANDROID_HOME=$HOME/Library/Android/sdk
export PATH=$ANDROID_HOME/emulator:$ANDROID_HOME/platform-tools:$ANDROID_HOME/tools:$PATH
export ANDROID_NDK_HOME=$ANDROID_SDK_ROOT/ndk/25.1.8937393
```

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

### Reload Bash Configuration

Source: https://github.com/wietsewind/xaman-app/blob/main/docs/environment-setup.md

Reloads the bash configuration file after making changes to environment variables. This command ensures that the newly set environment variables are active in the current terminal session.

```shell
source ~/.bash_profile
```

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

### Find and Log Process ID (PID)

Source: https://github.com/wietsewind/xaman-app/blob/main/android/app/libs/readme.txt

Finds the process ID (PID) of the Xaman app (com.xrplabs.xumm) running on the Android device and then streams ADB logs, filtering for that specific PID. This helps in isolating logs related to the application's process.

```bash
adb shell ps | grep "com.xrplabs.xumm"
find pid
adb logcat | grep 23329
```

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

### XRP Ledger Interaction with LedgerService

Source: https://context7.com/wietsewind/xaman-app/llms.txt

This TypeScript code demonstrates how to interact with the XRP Ledger using the LedgerService. It includes fetching account information, retrieving trust lines, submitting signed transactions, and verifying their validation status. It also shows how to get the current network fee and ledger status.

```typescript
import { LedgerService } from '@services';
import { SubmitResultType, VerifyResultType } from '@common/libs/ledger/types';

// Get account information from the ledger
const accountInfo = await LedgerService.getAccountInfo('rXXXXXXXXXXXXXXXXXXXX');
console.log('Balance:', accountInfo.account_data.Balance);
console.log('Sequence:', accountInfo.account_data.Sequence);

// Get trust lines (tokens) for an account
const trustLines = await LedgerService.getAccountLines('rXXXXXXXXXXXXXXXXXXXX', {
  limit: 200,
  ledger_index: 'validated'
});
console.log('Trust lines:', trustLines);

// Submit a signed transaction to the ledger
const txBlob = 'DEADBEEF...'; // Signed transaction blob
try {
  const result = await LedgerService.submitTransaction(txBlob);

  if (result.success) {
    console.log('Transaction submitted:', result.transactionId);
    // Wait for validation
    const verifyResult = await LedgerService.verifyTransaction(result.transactionId);

    if (verifyResult === VerifyResultType.SUCCESS) {
      console.log('Transaction validated successfully');
    }
  } else {
    console.error('Submit failed:', result.engineResult);
  }
} catch (error) {
  console.error('Transaction error:', error);
}

// Get current ledger status for fee calculation
const { Fee, LastLedger } = LedgerService.getLedgerStatus();
console.log('Current network fee:', Fee, 'drops');
console.log('Last validated ledger:', LastLedger);

```

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

### Change Application ID for Incompatible App Signature

Source: https://github.com/wietsewind/xaman-app/blob/main/docs/troubleshooting.md

Fixes 'INSTALL_FAILED_UPDATE_INCOMPATIBLE' errors when installing the Android app, which occur when a development build conflicts with a release version due to signature mismatches. Modifying the application ID ensures a unique identifier for the development build.

```gradle
android/app/build.gradle
```

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

### Android Debugging with ADB Logcat

Source: https://github.com/wietsewind/xaman-app/blob/main/android/app/libs/readme.txt

Clears the Android device's log buffer and then streams logs, filtering for critical errors (FATAL, AndroidRuntime), React Native logs, and debug messages. It excludes specific camera-related logs to focus on application issues. This is essential for diagnosing runtime problems.

```bash
# adb logcat -c
# adb logcat | grep -E "(FATAL|AndroidRuntime|ReactNativeJS|DEBUG|ERROR)"|grep -v ExynosCamera

adb logcat -c; adb logcat | grep -E "(FATAL|AndroidRuntime|ReactNativeJS|DEBUG|ERROR|IPv4Pref)"|grep -v ExynosCamera
```

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

### Disable Hermes in React Native Build (Gradle)

Source: https://github.com/wietsewind/xaman-app/blob/main/android/app/libs/readme.txt

Modifies the React Native Android build configuration to disable Hermes. This involves updating a Gradle properties file and then rebuilding the React Native Android library. It's a crucial step for projects that require a specific JS engine configuration.

```bash
# Disable Hermes in the React Native build
echo "hermesEnabled=true" >> packages/react-native/ReactAndroid/gradle.properties

./gradlew :packages:react-native:ReactAndroid:build
mkdir ~/Desktop/Xaman/xaman-app/android/app/libs
cp packages/react-native/ReactAndroid/build/outputs/aar/* ~/Desktop/Xaman/xaman-app/android/app/libs

./gradlew clean

# First, build the Hermes engine
./gradlew :packages:react-native:ReactAndroid:hermes-engine:build

# Build Hermes engine specifically
./gradlew :packages:react-native:ReactAndroid:hermes-engine:assembleDebug
./gradlew :packages:react-native:ReactAndroid:hermes-engine:assembleRelease

# Clean and rebuild with Hermes
# ./gradlew :packages:react-native:ReactAndroid:clean
# Not this one, fucked hermes ./gradlew :packages:react-native:ReactAndroid:build
./gradlew :packages:react-native:ReactAndroid:assembleDebug
./gradlew :packages:react-native:ReactAndroid:assembleRelease

# Copy the new AARs (these should now include Hermes)
cp packages/react-native/ReactAndroid/build/outputs/aar/* ~/Desktop/Xaman/xaman-app/android/app/libs/
```

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

### Fetch, Build, and Sign Transactions with Xaman Payload

Source: https://context7.com/wietsewind/xaman-app/llms.txt

Demonstrates how to fetch transaction payloads from the Xaman platform, build new payloads locally, sign them, and submit them. It includes validation steps and checks for signing permissions. Dependencies include '@common/libs/payload' and '@common/libs/ledger/types/enums'.

```typescript
import { Payload, PayloadOrigin } from '@common/libs/payload';
import { TransactionTypes } from '@common/libs/ledger/types/enums';

// Fetch payload from Xaman platform by UUID
const payload = await Payload.from('PAYLOAD-UUID-HERE', PayloadOrigin.DEEP_LINK);

console.log('Payload UUID:', payload.meta.uuid);
console.log('Transaction type:', payload.payload.tx_type);
console.log('Created:', payload.Date);
console.log('Expires:', payload.payload.expires_at);
console.log('Custom instruction:', payload.meta.custom_instruction);

// Build payload locally in the app
const builtPayload = Payload.build(
  {
    TransactionType: TransactionTypes.Payment,
    Account: 'rSENDER',
    Destination: 'rRECEIVER',
    Amount: '1000000',
  },
  'Please pay invoice #1234', // custom instruction
  true, // auto-submit after signing
  false // no pathfinding
);

// Get transaction object from payload
const transaction = builtPayload.getTransaction();
console.log('Transaction type:', transaction.Type);

// Check if account can sign this payload
const canSign = payload.meta.signers.length === 0 ||
  payload.meta.signers.includes('rMY_ACCOUNT');

if (canSign) {
  // Get transaction for signing
  const tx = payload.getTransaction([MixingTypes.Sign, MixingTypes.Mutation]);

  // Prepare and sign
  await tx.prepare({ account: 'rMY_ACCOUNT' });
  await tx.sign(account, encryptionKey);

  // Submit signed transaction
  if (payload.meta.submit) {
    const blob = tx.Blob;
    const result = await LedgerService.submitTransaction(blob);
    console.log('Submitted:', result.transactionId);
  }
}

// Payload verification
const isValid = await payload.verify(payload.payload);
if (!isValid) {
  throw new Error('Payload checksum verification failed');
}
```

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

### Integrate with Xaman Backend API using BackendService

Source: https://context7.com/wietsewind/xaman-app/llms.txt

Facilitates communication with the Xaman backend API for managing curated currency lists, payloads, device registration, and currency conversion rates. It requires initialization and supports asynchronous operations like syncing data and fetching rates. Dependencies include '@services/BackendService'.

```typescript
import BackendService from '@services/BackendService';

// Initialize backend service
await BackendService.initialize();

// Get curated IOUs (tokens) for display in wallet
await BackendService.syncCuratedIOUs();

// Get exchange rates for a currency
const rate = await BackendService.getRates('USD');
console.log('XRP to USD rate:', rate.rate);
console.log('Symbol:', rate.symbol);
console.log('Last updated:', rate.lastSync);

// Add a submitted transaction to backend tracking
await BackendService.addTransaction(
  'TRANSACTION_HASH',
  { id: 1, node: 'wss://xrplcluster.com', type: 'mainnet', key: 'mainnet' }
);

// Sync token details from issuer
await BackendService.syncTokensDetails('rISSUER_ADDRESS');

// Activate device for push notifications
await BackendService.activateDevice({
  uniqueDeviceId: 'device-uuid',
  platform: 'ios',
  token: 'fcm-token'
});

// Fetch user payloads (sign requests)
const payloads = await BackendService.getPayloads({
  account: 'rXXXXXXXXXXXXXXXXXXXX',
  limit: 20
});
for (const payload of payloads) {
  console.log('Payload UUID:', payload.uuid);
  console.log('Transaction type:', payload.tx_type);
}
```

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

### Run End-to-End Tests with Detox

Source: https://github.com/wietsewind/xaman-app/blob/main/docs/testing.md

Executes gray box end-to-end tests using Detox. Test files should have the `.spec.js` suffix and be located in the `e2e` directory at the project root. Detox automatically detects and runs these tests.

```bash
make test-e2e
```

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

### Run Unit Tests with Jest

Source: https://github.com/wietsewind/xaman-app/blob/main/docs/testing.md

Executes the unit test suite using Jest. Tests should be written in Javascript files with the `.test.ts` suffix and placed within `__tests__` directories in subfolders of `/src`. Jest automatically discovers and runs these tests.

```bash
make test
```

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

### Real-time XRP Account Monitoring with AccountService

Source: https://context7.com/wietsewind/xaman-app/llms.txt

This TypeScript code snippet demonstrates how to use the AccountService to subscribe to real-time updates for XRP accounts on the ledger. It covers initialization, listening for transactions, and updating account details. The service automatically handles reconnections.

```typescript
import { AccountService } from '@services';

// Initialize the account service
await AccountService.initialize();

// Listen for transactions affecting user accounts
AccountService.on('transaction', (transaction, effectedAccounts) => {
  console.log('Transaction detected:', transaction.transaction.hash);
  console.log('Affected accounts:', effectedAccounts);

  // Transaction object includes full transaction details and metadata
  const { Account, Destination, Amount } = transaction.transaction;
  if (transaction.meta) {
    const deliveredAmount = transaction.meta.delivered_amount;
    console.log('Delivered:', deliveredAmount);
  }
});

// Update specific account details
await AccountService.updateAccountsDetails(['rXXXXXXXXXXXXXXXXXXXX']);

// Service automatically resubscribes on network reconnection

```

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

### Connect to XRPL Nodes with NetworkService

Source: https://context7.com/wietsewind/xaman-app/llms.txt

Manages WebSocket connections to XRPL nodes, supports network switching (mainnet/testnet/devnet), and allows raw XRPL client access. It listens for connection events and state changes. Dependencies include '@services/NetworkService' and 'NetworkRepository'.

```typescript
import NetworkService, { NetworkStateStatus } from '@services/NetworkService';

// Listen for network connection events
NetworkService.on('connect', (network) => {
  console.log('Connected to network:', network.name);
  console.log('Network type:', network.type); // mainnet, testnet, devnet
  console.log('Node:', network.defaultNode.endpoint);
});

// Listen for state changes
NetworkService.on('stateChange', (status) => {
  switch (status) {
    case NetworkStateStatus.Connected:
      console.log('Connected to XRPL node');
      break;
    case NetworkStateStatus.Connecting:
      console.log('Connecting...');
      break;
    case NetworkStateStatus.Disconnected:
      console.log('Disconnected from XRPL node');
      break;
  }
});

// Switch to different network
const testnetNetwork = NetworkRepository.findOne({ type: 'testnet' });
await NetworkService.switchNetwork(testnetNetwork);

// Make raw XRPL API calls through the connection
const response = await NetworkService.send({
  command: 'account_info',
  account: 'rXXXXXXXXXXXXXXXXXXXX',
  ledger_index: 'validated'
});
console.log('Response:', response);

// Get network reserve requirements
const { base, owner } = NetworkService.getNetworkReserve();
console.log(`Base reserve: ${base} XRP, Owner reserve: ${owner} XRP per object`);
```

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

### Manage Screen Navigation in React Native

Source: https://context7.com/wietsewind/xaman-app/llms.txt

This service manages the navigation stack, modals, overlays, and deep linking within a React Native application. It centralizes control over screen transitions and state management. Dependencies include '@services/NavigationService' and '@common/constants'.

```typescript
import NavigationService, { RootType } from '@services/NavigationService';
import { AppScreens } from '@common/constants';

// Initialize navigation service
await NavigationService.initialize();

// Set root based on app state
if (isOnboarded) {
  await NavigationService.setRoot(RootType.DefaultStack);
} else {
  await NavigationService.setRoot(RootType.OnboardingStack);
}

// Push screen to stack
NavigationService.push(AppScreens.Account.Edit.Settings, {
  account: accountObject
});

// Show modal
NavigationService.showModal(AppScreens.Modal.ReviewTransaction, {
  payload: payloadObject,
  onAccept: () => {
    console.log('Transaction accepted');
  },
  onDecline: () => {
    console.log('Transaction declined');
  }
});

// Show overlay (non-modal, appears on top)
NavigationService.showOverlay(AppScreens.Overlay.SwitchAccount, {
  onAccountChange: (account) => {
    console.log('Switched to:', account.address);
  }
});

// Dismiss modal or overlay
NavigationService.dismissModal();
NavigationService.dismissOverlay();

// Pop screen from stack
NavigationService.pop();

// Get current screen information
const currentScreen = NavigationService.getCurrentScreen();
console.log('Current screen:', currentScreen);

// Listen for screen appear events
NavigationService.on('screenAppear', (screen) => {
  console.log('Screen appeared:', screen.componentName);
});

// Handle deep links
const handled = await NavigationService.handleDeepLink('xaman://sign/PAYLOAD_UUID');
if (handled) {
  console.log('Deep link handled successfully');
}
```

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

### Clean Android Project for Duplicate Class Error

Source: https://github.com/wietsewind/xaman-app/blob/main/docs/troubleshooting.md

Resolves 'java.util.zip.ZipException: duplicate entry' during Android app packaging by cleaning the Gradle build. This is typically caused by conflicting class files.

```shell
cd android
./gradlew clean
```

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

### Securely Store and Access Private Keys with Xaman Vault

Source: https://context7.com/wietsewind/xaman-app/llms.txt

Explains how to use the Vault module for encrypted storage of private keys, leveraging platform-specific secure enclaves and optional biometric authentication. It covers creating, opening, checking existence, purging, and re-keying vault entries. Dependencies include '@common/libs/vault' and '@common/libs/biometric'.

```typescript
import Vault from '@common/libs/vault';
import { BiometricAuthentication } from '@common/libs/biometric';

// Create encrypted vault entry for private key
await Vault.create(
  'PUBLIC_KEY_HEX',
  'PRIVATE_KEY_HEX',
  'ENCRYPTION_KEY_DERIVED_FROM_PASSPHRASE'
);

// Open vault with biometric authentication
try {
  const isBiometricAvailable = await BiometricAuthentication.isSupported();

  if (isBiometricAvailable) {
    const authenticated = await BiometricAuthentication.authenticate(
      'Authenticate to sign transaction'
    );

    if (authenticated) {
      const privateKey = await Vault.open('PUBLIC_KEY_HEX', 'ENCRYPTION_KEY');
      console.log('Private key retrieved securely');

      // Use private key for signing, then clear from memory
      // ... signing logic ...

      // Private key is automatically cleared after use
    }
  }
} catch (error) {
  console.error('Vault access failed:', error);
}

// Check if vault entry exists
const exists = await Vault.exist('PUBLIC_KEY_HEX');
console.log('Vault entry exists:', exists);

// Remove vault entry (when removing account)
await Vault.purge('PUBLIC_KEY_HEX');

// Re-key vault with new encryption key (when changing passphrase)
await Vault.reKey(
  'PUBLIC_KEY_HEX',
  'OLD_ENCRYPTION_KEY',
  'NEW_ENCRYPTION_KEY'
);
```

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

### Perform Authenticated HTTP Requests with ApiService

Source: https://context7.com/wietsewind/xaman-app/llms.txt

A low-level HTTP client for secure communication with Xaman backend services. It handles token refresh, request signing, and idempotency. Requires initialization with core settings and supports various HTTP methods. Handles API errors with specific error types. Dependencies include '@services/ApiService' and 'ApiError'.

```typescript
import ApiService from '@services/ApiService';

// Initialize with core settings
await ApiService.initialize(coreSettings);

// Make authenticated API request
try {
  const response = await ApiService.request({
    method: 'GET',
    endpoint: 'v1/app/account-info',
    params: { address: 'rXXXXXXXXXXXXXXXXXXXX' }
  });
  console.log('API response:', response);
} catch (error) {
  if (error instanceof ApiError) {
    console.error('API error:', error.message);
    console.error('Status code:', error.code);
    console.error('Reference:', error.reference);
  }
}

// POST request with data
const result = await ApiService.request({
  method: 'POST',
  endpoint: 'v1/platform/payload',
  body: {
    txjson: {
      TransactionType: 'Payment',
      Destination: 'rDESTINATION',
      Amount: '1000000'
    }
  }
});
console.log('Created payload UUID:', result.uuid);

// Access tokens are automatically refreshed when expired
// Requests include device identification and idempotency keys
```

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

### Resolve Xcode Instruments Error for iOS Builds

Source: https://github.com/wietsewind/xaman-app/blob/main/docs/troubleshooting.md

Addresses the 'xcrun: error: unable to find utility "instruments"' when running 'make run-ios'. This error indicates that Xcode Command Line Tools are not properly configured. The solution involves launching Xcode to accept terms and then selecting a version of the Command Line Tools in Xcode Preferences.

```shell
make run-ios
```

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

### Manage Account Data with AccountRepository

Source: https://context7.com/wietsewind/xaman-app/llms.txt

The AccountRepository facilitates the storage, retrieval, and modification of account data within the local Realm database. It also handles the secure management of encrypted private keys using the Vault system. This includes adding accounts with different access levels, fetching all or specific accounts, updating account details, and listening for account-related events. It also supports the purging of accounts.

```typescript
import { AccountRepository } from '@store/repositories';
import { AccessLevels, AccountTypes } from '@store/types';

// Add a full-access account with private key
const account = await AccountRepository.add(
  {
    address: 'rXXXXXXXXXXXXXXXXXXXX',
    label: 'My Main Account',
    publicKey: 'ED...',
    accessLevel: AccessLevels.Full,
    type: AccountTypes.Regular,
    encryptionLevel: EncryptionLevels.Physical,
  },
  'PRIVATE_KEY_HEX', // Encrypted and stored in vault
  'ENCRYPTION_KEY'
);
console.log('Account created:', account.address);

// Add a read-only account (no private key)
const readOnlyAccount = await AccountRepository.add({
  address: 'rREADONLY_ADDRESS',
  label: 'Watch-only Account',
  accessLevel: AccessLevels.Readonly,
  type: AccountTypes.Regular,
});

// Get all accounts
const accounts = AccountRepository.getAccounts();
console.log(`Total accounts: ${accounts.length}`);

// Find specific account
const myAccount = AccountRepository.findOne({ address: 'rXXXXXXXXXXXXXXXXXXXX' });
console.log('Account label:', myAccount.label);
console.log('Balance:', myAccount.balance);

// Update account details (balance, reserve, flags, etc.)
await AccountRepository.updateDetails('rXXXXXXXXXXXXXXXXXXXX', {
  id: 1,
  balance: '100000000',
  ownerCount: 5,
  regularKey: 'rREGULAR_KEY_ADDRESS',
});

// Listen for account events
AccountRepository.on('accountCreate', (account) => {
  console.log('New account added:', account.address);
});

AccountRepository.on('accountUpdate', (account, changes) => {
  console.log('Account updated:', account.address);
  console.log('Changed fields:', Object.keys(changes));
});

// Remove account
await AccountRepository.purge({ address: 'rXXXXXXXXXXXXXXXXXXXX' });
```

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

### Create XRPL Transactions with TransactionFactory

Source: https://context7.com/wietsewind/xaman-app/llms.txt

The TransactionFactory provides robust functionality for creating strongly-typed XRPL transaction objects from JSON. It includes built-in validation and supports mixins for signing and mutation capabilities, enabling the creation of all XRPL transaction types, including pseudo-transactions. This factory can also parse ledger transactions with their associated metadata.

```typescript
import { TransactionFactory } from '@common/libs/ledger/factory';
import { MixingTypes } from '@common/libs/ledger/mixin/types';
import { TransactionTypes } from '@common/libs/ledger/types/enums';

// Create a transaction object from JSON
const paymentTx = TransactionFactory.getTransaction({
  TransactionType: 'Payment',
  Account: 'rSENDER',
  Destination: 'rRECEIVER',
  Amount: '1000000',
  Fee: '12',
  Sequence: 12345,
});

// Access transaction properties
console.log('Type:', paymentTx.Type);
console.log('From:', paymentTx.Account.address);
console.log('To:', paymentTx.Destination?.address);
console.log('Amount:', paymentTx.Amount);

// Create signable transaction with Sign mixin
const signableTx = TransactionFactory.getTransaction(
  {
    TransactionType: 'TrustSet',
    Account: 'rACCOUNT',
    LimitAmount: {
      currency: 'USD',
      issuer: 'rISSUER',
      value: '1000'
    },
  },
  undefined, // no metadata
  [MixingTypes.Sign] // add signing capability
);

// Sign the transaction
const account = AccountRepository.findOne({ address: 'rACCOUNT' });
const encryptionKey = await getEncryptionKey();
await signableTx.sign(account, encryptionKey);
console.log('Signed transaction blob:', signableTx.Signers);

// Create mutable transaction with Mutations mixin
const mutableTx = TransactionFactory.getTransaction(
  { TransactionType: 'Payment', Account: 'rACCOUNT' },
  undefined,
  [MixingTypes.Mutation]
);

// Prepare transaction for submission (auto-fill fee, sequence, etc.)
await mutableTx.prepare({ account: 'rACCOUNT' });
console.log('Fee:', mutableTx.Fee);
console.log('Sequence:', mutableTx.Sequence);
console.log('LastLedgerSequence:', mutableTx.LastLedgerSequence);

// Parse ledger transaction with metadata
const ledgerTx = TransactionFactory.fromLedger({
  transaction: { /* transaction json */ },
  meta: { /* transaction metadata */ },
  validated: true,
});
console.log('Transaction result:', ledgerTx.TransactionResult);
```

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

### Perform XRP Ledger Cryptographic Operations

Source: https://context7.com/wietsewind/xaman-app/llms.txt

This library provides essential cryptographic functions for XRP Ledger, including address derivation from seeds or mnemonics, key pair generation, and data hashing using ed25519 and secp256k1 curves. It also includes utilities for validating, decoding, and encoding XRP addresses. Dependencies include 'xrpl-accountlib'.

```typescript
import { SHA256, SHA512 } from '@common/libs/crypto';
import { Derive } from 'xrpl-accountlib';

// Generate account from seed
const familySeed = 'sXXXXXXXXXXXXXXXXXXXXXXXXXXX';
const account = Derive.familySeed(familySeed, { algorithm: 'ed25519' });

console.log('Address:', account.address);
console.log('Public key:', account.keypair.publicKey);
console.log('Private key:', account.keypair.privateKey);

// Generate from mnemonic (12 or 24 words)
const mnemonic = 'abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon abandon about';
const mnemonicAccount = Derive.mnemonic(mnemonic, {
  algorithm: 'secp256k1',
  path: "m/44'/144'/0'/0/0"
});
console.log('Mnemonic-derived address:', mnemonicAccount.address);

// Hash data with SHA256
const hash256 = SHA256('data to hash');
console.log('SHA256 hash:', hash256);

// Hash data with SHA512
const hash512 = SHA512('data to hash');
console.log('SHA512 hash:', hash512);

// Validate XRP address
const { isValidAddress } = require('xrpl-accountlib/dist/utils');
const valid = isValidAddress('rXXXXXXXXXXXXXXXXXXXX');
console.log('Valid address:', valid);

// Decode address to hex
const { decodeAccountID } = require('xrpl-accountlib/dist/codec');
const hex = decodeAccountID('rXXXXXXXXXXXXXXXXXXXX');
console.log('Address as hex:', hex);

// Encode hex to address
const { encodeAccountID } = require('xrpl-accountlib/dist/codec');
const address = encodeAccountID(Buffer.from('ACCOUNT_ID_HEX', 'hex'));
console.log('Encoded address:', address);
```
Tokens:
Raw