durt2 0.6.6

Dart library for interacting with Duniter v2s blockchains. Provides wallet management, transaction signing, Squid GraphQL requests, and more

Durt2 Library

Overview

Durt2 is a Dart library designed for Duniter v2s blockchain and cryptocurrency management. It provides a comprehensive SDK for building Duniter applications with built-in wallet management, transaction processing, identity services, and GraphQL indexer integration.

Features

• Polkadart Integration: Direct access to Duniter blockchain via WebSocket connections
• Wallet Services: Comprehensive wallet and safe management with encrypted storage
• Transaction Processing: Support for payments, certifications, identity operations, and Universal Dividends
• GraphQL Services: Integration with Squid indexer for transaction history and Cesium+ for profiles
• Multi-network Support: Seamless switching between networks (gdev, gtest, g1, local)
• Auto-discovery: Automatic endpoint discovery and connection management
• State Management Agnostic: Works with any state management solution (Riverpod, Provider, Bloc, etc.)
• Multilingual BIP39: Support for multiple languages in mnemonic generation

Getting Started

Installation

Add Durt2 to your pubspec.yaml file:

dependencies:
  durt2: <version>

Run the following command to get the package:

flutter pub get

Basic Initialization

import 'package:durt2/durt2.dart';

void main() async {
  // Choose your network
  final selectedNetwork = Networks.gtest; // or Networks.gdev, Networks.g1

  // Initialize Durt2 with network and key pair type
  final durt = Durt();
  await durt.init(
    network: selectedNetwork,
    keyPairType: KeyPairType.ed25519
  );

  // Connect to the network
  await durt.connect();

  runApp(MyApp());
}

Accessing Services

Once initialized, you can access all services through the global Durt instance:

import 'package:durt2/durt2.dart';

// Access the global Durt instance
final durt = Durt.i;

// Access individual services
final walletService = durt.wallets;
final duniterService = durt.duniter;
final squidService = durt.squid;
final storageService = durt.storage;
final cesiumPlusService = durt.cesiumPlus;

// Get current network and connection status
final currentNetwork = durt.network;
final isConnected = durt.isConnected;
final connectionStatus = durt.duniterConnectionStatus;

// Listen to connection status changes
durt.duniterConnectionStatusStream.listen((status) {
  print('Connection status: $status');
});

Basic Usage Examples

Making a Payment

Future<void> sendPayment() async {
  final durt = Durt.i;

  // Get sender key pair
  final keypair = await durt.wallets.getKeyPairFromAddress(
    address: 'sender_address',
    pinCode: '123456',
  );

  // Send payment
  final transactionStream = durt.duniter.pay(
    keypair: keypair,
    destAddress: 'destination_address',
    amount: 10.0, // in G1 units
    comment: 'Payment comment',
  );

  // Listen to transaction status
  await for (final status in transactionStream) {
    print('Transaction status: ${status.state}');
    if (status.state == TransactionState.included) {
      print('Transaction included in block!');
      break;
    }
  }
}

Getting Wallet Balance

Future<void> getWalletBalance(String address) async {
  final durt = Durt.i;

  try {
    final balance = await durt.storage.getBalance(address);
    print('Transferable: ${balance.transferableBalance / 100} G1');
    print('Free: ${balance.free / 100} G1');
    print('Reserved: ${balance.reserved / 100} G1');
    print('Unclaimed UDs: ${balance.unclaimedUds}');
  } catch (e) {
    print('Error getting balance: $e');
  }
}

Transaction History

Future<void> getTransactionHistory(String address) async {
  try {
    final result = await SquidClientManager.client.getAccountHistory(
      address,
      number: 20,
    );

    if (result != null) {
      for (final edge in result.edges) {
        final tx = edge.node;
        print('Amount: ${tx.amount / 100} G1');
        print('Comment: ${tx.comment?.remark ?? 'No comment'}');
        print('From: ${tx.fromId}');
        print('To: ${tx.toId}');
        print('---');
      }
    }
  } catch (e) {
    print('Error getting transaction history: $e');
  }
}

Network Configuration

Durt2 automatically discovers and manages endpoints for different networks. The configuration is handled through JSON files, which are used only to bootstrap network scan and fallback:

• config/duniter_endpoints.json: WebSocket endpoints for Duniter nodes
• config/squid_endpoints.json: GraphQL endpoints for Squid indexers
• config/cesium_plus_endpoints.json: REST endpoints for Cesium+ profile services

You can also set custom endpoints programmatically:

// Switch networks
await Durt.i.switchNetwork(Networks.gdev);

// Test endpoint connectivity
final isWorking = await Durt.i.testDuniterEndpoint('wss://example.com/ws');

// Set a fixed endpoint
await Durt.i.setFixedEndpoint('wss://custom-node.com/ws');

Connection Status Monitoring

void monitorConnectionStatus() {
  final durt = Durt.i;

  // Get current status
  print('Current connection status: ${durt.duniterConnectionStatus}');
  print('Is connected: ${durt.isConnected}');

  // Listen to status changes
  durt.duniterConnectionStatusStream.listen((status) {
    switch (status) {
      case ConnectionStatus.connected:
        print('Connected to Duniter network');
        break;
      case ConnectionStatus.connecting:
        print('Connecting to Duniter network...');
        break;
      case ConnectionStatus.disconnected:
        print('Disconnected from Duniter network');
        break;
      case ConnectionStatus.error:
        print('Connection error');
        break;
    }
  });

  // Also monitor Squid connection
  durt.squidConnectionStatusStream.listen((status) {
    print('Squid indexer status: $status');
  });
}

Advanced Features

Multi-language Mnemonic Support

// Generate mnemonic in user's language
final durt = Durt.i;
final mnemonic = durt.wallets.generateMnemonic(
  language: Language.french, // or Language.english, Language.spanish, etc.
);

// Import wallet from mnemonic
final wallet = await durt.wallets.importRootWallet(
  mnemonic: 'words in any supported language',
  pinCode: '123456',
);

Safe Management

// Create a new safe
final durt = Durt.i;
await durt.wallets.createSafe(
  mnemonic: 'your twelve word mnemonic phrase here ...',
  pinCode: '123456',
  safeName: 'My Safe',
);

// Set default safe by its number
durt.wallets.setDefaultSafeBoxNumber(0);

Architecture

Durt2 follows a service-oriented architecture:

• ConnectionOrchestrator: Handles network connections and endpoint discovery
• WalletService: Manages wallets, safes, and cryptographic operations
• DuniterService: Provides blockchain transaction capabilities
• DuniterStorageService: Caches blockchain data with real-time subscriptions
• SquidClientManager: GraphQL client for transaction indexing
• CesiumPlusService: REST client for identity profiles

All services are accessed through the main Durt singleton.