tld_parser 0.1.0

tld_parser: ^0.1.0 copied to clipboard

example/example.dart

/// Example usage of the TLD Parser SDK
///
/// This example demonstrates the main features of the SDK:
/// - Domain resolution
/// - Reverse lookup
/// - Record fetching
/// - Domain listing
library;

import 'package:solana/solana.dart';
import 'package:tld_parser/tld_parser.dart';

/// Known test wallet that owns domains
const testWallet = '2EGGxj2qbNAJNgLCPKca8sxZYetyTjnoRspTPjzN2D67';

/// Example RPC endpoint (use your own for production)
const rpcEndpoint = 'https://api.mainnet-beta.solana.com';

void main() async {
  // Initialize the TLD Parser with an RPC client
  final rpcClient = RpcClient(rpcEndpoint);
  final parser = TldParser(rpcClient);

  print('TLD Parser SDK Example\n');
  print('=' * 50);

  // Example 1: Resolve a domain to its owner
  await resolveDomainExample(parser);

  // Example 2: Get user's main domain (reverse lookup)
  await mainDomainExample(parser);

  // Example 3: Fetch domain records
  await recordsExample(parser);

  // Example 4: List user's domains
  await listDomainsExample(parser);

  // Example 5: Domain key derivation
  await derivationExample();
}

/// Example: Resolve a domain to its owner
Future<void> resolveDomainExample(TldParser parser) async {
  print('\n📍 Domain Resolution');
  print('-' * 30);

  try {
    // Resolve a .abc domain
    final owner = await parser.getOwnerFromDomainTld('miester.abc');
    if (owner != null) {
      print('Owner of miester.abc: ${owner.toBase58()}');
    } else {
      print('miester.abc: Domain not found or expired');
    }

    // Get the full name record with metadata
    final record = await parser.getNameRecordFromDomainTld('miester.abc');
    if (record != null) {
      print('  Created: ${record.createdAtDateTime}');
      print('  Expires: ${record.expiresAtDateTime ?? "Never"}');
      print('  Is valid: ${record.isValid}');
      print('  Transferable: ${!record.nonTransferable}');
    }
  } catch (e) {
    print('Error: $e');
  }
}

/// Example: Get user's main domain
Future<void> mainDomainExample(TldParser parser) async {
  print('\n🏠 Main Domain (Reverse Lookup)');
  print('-' * 30);

  try {
    final userPubkey = Ed25519HDPublicKey.fromBase58(testWallet);

    // Try to get the user's main domain
    final mainDomain = await parser.tryGetMainDomain(userPubkey);
    if (mainDomain != null) {
      print('User $testWallet');
      print('  Main domain: ${mainDomain.fullDomain}');
      print('  Name account: ${mainDomain.nameAccount.toBase58()}');
    } else {
      print('No main domain set for $testWallet');
    }
  } catch (e) {
    print('Error: $e');
  }
}

/// Example: Fetch domain records
Future<void> recordsExample(TldParser parser) async {
  print('\n📋 Domain Records');
  print('-' * 30);

  try {
    // Fetch multiple records at once
    final records = await parser.getRecords('miester.abc', [
      Record.twitter,
      Record.discord,
      Record.github,
      Record.email,
      Record.sol,
      Record.eth,
    ]);

    print('Records for miester.abc:');
    records.forEach((record, value) {
      if (value != null) {
        print('  ${record.key}: $value');
      }
    });

    // Check if any records were found
    final hasRecords = records.values.any((v) => v != null);
    if (!hasRecords) {
      print('  (No records set)');
    }
  } catch (e) {
    print('Error: $e');
  }
}

/// Example: List user's domains
Future<void> listDomainsExample(TldParser parser) async {
  print('\n📚 User Domains');
  print('-' * 30);

  try {
    final userPubkey = Ed25519HDPublicKey.fromBase58(testWallet);

    // Get all .abc domains owned by the user
    final abcDomains = await parser.getAllUserDomainsFromTld(userPubkey, 'abc');
    print('User owns ${abcDomains.length} .abc domain(s)');

    if (abcDomains.isNotEmpty && abcDomains.length <= 5) {
      // Get parsed domain names for small lists
      final parsed = await parser.getParsedAllUserDomainsFromTld(
        userPubkey,
        'abc',
      );
      for (final d in parsed) {
        print('  - ${d.domain}');
      }
    } else if (abcDomains.length > 5) {
      print('  (Showing first 5 account addresses)');
      for (final account in abcDomains.take(5)) {
        print('  - ${account.toBase58()}');
      }
    }
  } catch (e) {
    print('Error: $e');
  }
}

/// Example: Domain key derivation
Future<void> derivationExample() async {
  print('\n🔑 Domain Key Derivation');
  print('-' * 30);

  try {
    // Derive root domain key
    final domainKey = await getDomainKey('miester.abc');
    print('Root domain (miester.abc):');
    print('  Pubkey: ${domainKey.pubkey.toBase58()}');
    print('  Is subdomain: ${domainKey.isSub}');

    // Derive subdomain key
    final subKey = await getDomainKey('vault.miester.abc');
    print('\nSubdomain (vault.miester.abc):');
    print('  Pubkey: ${subKey.pubkey.toBase58()}');
    print('  Is subdomain: ${subKey.isSub}');
    print('  Parent: ${subKey.parent?.toBase58()}');

    // Derive record key
    final recordKey = await getDomainKey('Twitter.miester.abc', record: true);
    print('\nRecord (Twitter.miester.abc):');
    print('  Pubkey: ${recordKey.pubkey.toBase58()}');
    print('  Is subdomain: ${recordKey.isSub}');
  } catch (e) {
    print('Error: $e');
  }

  print('\n${'=' * 50}');
  print('Example complete!');
}